【C语言疯狂讲义】(八)C语言一维数组

1、数组的基本概念:

 

    相同类型    若干个     有序

 

    由若干个相同类型的数据组成的有序的集合

 

    有序:存储地址连续

         下标连续

 

    

    数组名:用来存放数组首地址的变量

    数组元素:构成数组的每一个数据

    数组的下标:给数组的每一个元素做一个编号

    数组的长度:构成数组的数据的个数

 

 2、一维数组的定义

 

    数组的使用的流程:先定义   ---> 初始化   --->使用

 

    数组定义完成后,如果不初始化里面存放的时垃圾值

 

    格式:int arr[10];

         定义长度为10的整型数组,每个都是Int型的,数组的名称 arr

 

         float f1[12];

         char c[10];

 

    1) 定义变量的同时,可以定义数组

         int a[10],b,c;

    2) int a1[3+2]; 

    3) int n=5;   int a2[n];  //其他编译器数组定义的时候,数组长度不能使用变量,但是xcode做了优化,这是可以的

    4#define N 5      int a3[N+3];

    5) int a4; int a4[10]; 数组的名称不能和变量名重名

    6)数组名的命名原则严格遵守标示符命名原则

 

 

 3、初始化和使用

 

    数组中,一旦有一个元素被初始化了,其他元素也都被初始化了

 

    1)定义的时候初始化

 

        int a[10] = {0};

 

       (1) 完全初始化(数组的每一个元素都被初始化了)

 

           int a[3]={2,3,4};  //完全初始化  a[0]=2,a[1]=3,a[2]=4

 

           不指定数组长度的完全初始化

           int a1[]={2,3,34,4}; //定义int型数组a1,初始化值为23344,根据初始化的值,确定数组的长度

 

      2)部分初始化(只指定数组的一部分初始化值)

 

          int a2[10]={0}   //相当于有a2所有的元素都初始化为0

                           //a[0]=0,

          int a3[5]={1,2,3}; 

 

          指定下标的数组元素的初始化

 

          int a4[6]={[3]=100,[0]=23};

 

          //a[3]=100,a[0]=23;没有初始化的值,系统自动初始化为0

 

 

 

    2)先定义,后初始化

 

         int a5[10];

         a5[0]=1;

         a5[1]=2;

         ...

         a5[9]=100;

 

 

    3)数组的引用

 

      取出数组中存放的内容

 

      数组只能通过数组的下标来获取对应的内容

   

      int a[n];

      下标的范围:0 ~ (n-1)

 

      越界(越界访问):访问的数组元素的下标超出了最大的下标

 

      int a6[3]={1,2,3,4,5};

 

 4、数组的存储方式

 

      数组在内存中是如何存储的?

 

      1)数组在内存中分配的时连续的一片内存空间

 

      2)数组的名称存放连续内存空间的首地址

 

      3)数组的第一个元素存放到数组内存的低地址(首地址)

   

      4)首地址 = &a[0] = a 

 

      如何计算数组的长度

      

      1) int a[5];   

   

      2int a[]={1,2,3,34,6,6,67};

 

      数组占用总得存储空间

 

         sizeof(a)

 

      计算数组的元素的个数(长度)

 

        sizeof(a)/sizeof(int)

 

 

 5、数组和函数之间的关系

 

     1) 数组的元素作为函数的参数(实参)

 

        int a[3]={1,2,3};

 

        int sum(int x,int y){

 

             return x+y;

        }

 

        sum(a[0],a[1]);

 

        注意:值传递

 

     2)数组名作为函数的参数(实参)

 

        void sum(int s[]){

 

 

        }

 

        sum(a);   // int s[];  s=a;  s存放了a得地址

                  // 相当于sa都指向了同一块内存区域

                  // 操作s等同于操作a

 

        注意:地址的传递

 

 

 6、几个算法

  

   1)选择排序

 

         每一次找到一个最小值,跟未排序的第一元素进行交换

         0   1  2   3  4

         12  2  3  56  1

       min=0

       a[j],j=1

 

             min=1

             a[j] j=2

 

 第一趟0   1   2  3  56  12

 第二趟1   1   2  3  56  12

 第三趟2   1   2  3  56  12

 第四趟3   1   2  3  12  56

 

 

 

   2)冒泡排序(必须要掌握的)

 

        冒泡排序:大数下沉(每一趟最大的数跑到最后一个元素中)    小数上浮

 

          0   1  2   3  4

 

          12  2  3  56  1

 第一趟0

  1        2   12 3  56  1

  2        2   3  12 56  1

  3        2   3  12 56  1

  4        2   3  12 1   56

                                  len-1-0   4

 

 第二趟1    2   3  12 1   56

  1       2   3  12 1   56

  2       2   3  12 1   56

  3       2   3  1  12  56

                                  len-1-1   3

 第三趟2    2   3  1  12  56

  1       2   3  1  12  56 

  2       2   1  3  12  56

 

 第四趟3

  1       1   2  3  12  56

 

   3)折半查找

 

      在一个有序的数据序列中查找一个数,用最快的方法

 

 low=0          high=4

 

 int mid = (low+high)/2

 

           0   1  2  3   4

 ------------------------------------- key = 5

           1   2  3  12  56

                  h  l

                     m

 

        key>a[mid]    low = mid+1

        key==a[mid]   return mid;

        key<a[mid]    high = mid-1;

 

        结束:查找到了, return mid;

             没查找到(l>h  return -1;

郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。