C语言基础 数组与排序

 数组

用来保存多个相同数据类型的数据集合

定义变量 变量类型 变量名称;

定义数组 变量类型 数组名称[元素个数];

定义一个可以容纳5个int类型的数据的数组

int scores[5];

1.数组只有定义了才能初始化

2.只定义数组没有初始化那么数组中都是垃圾值,所以数组只有初始化了才可以使用.

/*

总结:

1.数组元素作为函数参数传递是值传递,和普通变量是一样的

2.数组作为函数参数传递是地址传递,如果改变形参数组的某个元素的值,那么会影响实参数组中该元素的值

3.数组作为函数参数传递会自动转换为指针类型,所以在函数中不能获取形参数组的长度,只能由主调函数传入

*/

1.先定义数组然后进行初始化

使用常量作文元素个数

int scores[5];

//数组遍历 : 取出数组中每一个元素看一下

//数组所占用的字节数

int count = sizeof(scores) / sizeof(int);

for (int i = 0;i < 5; i++)

{

printf(“%d”,socres[i]);

}

使用变量作为元素个数,C99不支持使用变量作为元素个数,但是LLVM支持使用变量作为元素个数.

使用变量作为元素个数的好处: 可以在程序运行到这一行的时候再去决定要创建有多少元素的数组.

2.定义数组的同时进行初始化

2.1 指定元素个数 , 同时进行全部初始化

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

2.2 不指定元素个数,全部进行初始化

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

2.3 指定元素个数 , 部分初始化,从下表为0的元素开始初始化,没有显示初始化的元素系统会将其初始化为0

int num[5] = {1,2}

2.4 指定元素个数, 位指定的元素进行初始化

int nums[5] = { [3] = 5 , [4] = 10 };

 定义数组的同时进行初始化, 如果没有显示初始化的元素系统会将其初始化为0

定义数组同时进行初始化的时候,不可以使用变量作为元素个数

int length = 5;

int num = [length];

数组的地址就是第一个元素的地址

数组是一块连续的存储空间

下标小的元素在小地址上,下标大的元素在大地址上

数组的地址就是数组所占存储空间的首地址

char chars[] = {‘a’,’b’,’d’};

//1.数组名称本身就是一个地址

printf(“%p\n”,chars);

//2.取出下标问为0的元素的地址

printf(“%p\n”,&chars);

char nums1[] = {1};

char nums2[] = {1};

num2[1] = 20;

printf(“%d\n”,nums1[0]);

1.越错对象,访问不该访问的元素

数组下标越结

1.越错了对象: 访问不该访问的元素,导致莫名的错误

2.程序奔溃

第二注意点 : 使用变量作为元素个数不可以进行整体赋值.

第三注意点 : 整体赋值只有在数组定义的时候才可以 , 也就是说数组定义后

使用空瓶子法

int nums[] = {2, 1, 4,6};

int temp = nums[1];

nums1[1] = nums[2];

nums2[2]= temp;

改变数组中的某个元素

数组作为函数参数传递是地址传递

void changeArray(int array[],int index)

{

printf(“%p\n”,array);

array[index] = 10;

}

int main()

{

int nums[] = { 4,2,5,6 };

printf(“nums = %p\n”,nums);

changeArray(nums);

print

return 0;

}

改变数组中的某个元素值

数组作为函数参数传递是地址传递, 如果在函数中改变数组红某个值, 实参的值也会改变

// 指针用来存放地址变量 , 指针占用 8 个字节存储空间

// 当数组作为函数参数传递到时候, 会被自动转换为指针类型

void printArry(int array[] , int count)

printf

 

 二维数组

元素为一堆数组的数组

一维数组 : 数据类型 数组名称[元素个数]

二维数组 : 数组类型 数组名称[一维数组的个数][一维数组的元素个数]

三维数组 : 数据类型 数组名称[二维数组的个数][一位数组的个数][一维数组的元素个数]

二维数组的注意点:

       如果二维数组仅仅是定义没有初始化里面的元素都是垃圾值(垃圾值)

       二维数组进行初定义的同时初始化,那么没有显示初始化的元素会被自动初始化为0

       定义二维数组的时候,必须要指定一维数组元素个数

      

//定义一个二维数组

char scores[3][2];

 

// 1分别对每个元素进行初始化

scores[0][0] = 1;

scores[0][1] = 100;

scores[1][0] = 50;

scores[1][1] = 50;

2.1 指定一位数组的个数同时对全部元素进行初始化

int scores[20][2] ={{1,100},{20,10}};

2.2 不指定一维数组的个数对数组中的全部元素进行初始化

int scores[][2] ={{1,100},{50,80}};

3.3 指定一维数组的元素个数,全部元素初始化

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

//遍历二维数组

       for ( int  i = 0 ; i < 3;i++){

              for(int j = 0;j <2;j++){ 

                      printf(“score[%d][%d]=%d\n”,i,j,score[i][j])

              }

       }

//宏定义 : 它是一种编译预处理指令

# define ROWS 6

定义函数外部变量 , 我们全局变量

1.它在整个程序还没有启动的时候就进行分配类存初始化了

2.它在所有函数

 

选择排序

写一个函数对数组中的元素进行排序

void selectSort( int array[],int count )

{

//外层循环控制趟数

for (int i = 0;i < count;i++){

//内存循环 选择除最小值

       for (j =  ;j < count ; j++){

//当前面的元素大于后面的元素就交换位置

              if(nums[i] > nums[j]) {

                      int temp =array[i];

                      array[i] = array[j];

                      array[j] = temp;

                      }

              }

       }

}

// 第二中选择排序

void selectSort2(int array[],int count)

{

       for (int i = 0 ; i < count -1 ; i++) {

              int min = i;

              for (int j = i+1 ;j < count ;j++){

                      if(array[min] > array[j]){

                      min = j;

              }

       }

              if (i != min){

                      int temp =array[i];

                      array[i] = array[min];

                      array[min] = temp;

       }

}

//按升序排列 : 从小到大

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

//外层循环控制趟数

//计算数组的长度

int  length = sizeof(nums) /sizeof(int)

       printArray(nums,length);

       selectSort(nums,length);

}

 

——————————————————————

冒泡排序

规则 : 两两比较,大的下沉小的上浮

void bubbleSort(int array[],int count )

{

for (int i = 0 ; i < count ;i++) {

//两两比较大下沉小上浮

       for (int j = 0 ; j < count - 1 - i ; j++) {

              //如果上面大于下面就交换位置

                             if ( array [ j ] > array [ j+ 1 ] 

                           {

                             int temp = array[j];

                             array[j] = array [j+1];

                             array[j+1] = temp;

                      }

              }

       }

}

int  nums[5] = {8,6,10,2,1};

//计算数组长度

int length = sizeof(nums) /sizeof(int);

       //外层循环控制趟

 

——————————————————————

折半查找

从一个有序的数组中找出某一个值所对应的下标, 如果找到了就返回那个下标,如果没有找到就返回 -1