【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,初始化值为2，3，34，4，依据初始化的值，确定数组的长度

（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];

2）int 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得地址

// 相当于s和a都指向了同一块内存区域

// 操作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;