数组与函数 数组的排序

IOS学习第11天

参数的值传递

参数的类型是 int  float double char 等基本数据类型的时候

    调用者传入一个实参,然后在函数中改变这个参数的值,那么调用者中的实参不会改变
    int num = 10;
    test(num);//在test函数中对num进行了修改
    不会影响到 调用者中实参的值
    ```

**数组名代表数组的资质,数组当参数时传递的是数组名,即数组的地址**

**在函数内部无法使用sizeof计算参数数组的长度,因为参数数组实际上是一个存储数组地址的指针变量,所以若一个函数用到数组的长度时,必须在添加一个数组长度参数**

* **结论**

当数组作为函数参数的时候,是地址传递,在函数内部修改数组,会对原来的数组产生影响

###数组排序

* 选择排序

思路:
1.固定一个下标,与下标之后的元素相比
2.依次固定所有元素的下标

int main(int argc, const char * argv[]) {

    int arr[] = {12,1,3,24,346,4,532,3,46,5};

    //计算出数组的长度
    int len = sizeof(arr) / sizeof(arr[0]);

    for(int i = 0; i < len - 1; i++)//外层循环控制轮数. n个数,需要比较n-1轮.
    {
        //拿下标为i的元素 和后面的所有的元素依次进行比较.比较到最后一个元素,所以j<len
        for(int j = i+1; j < len; j++)
        {
            if(arr[i] > arr[j])
            {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }

    for(int i = 0; i < len; i++)
    {
        printf("%d\n",arr[i]);
    }

    return 0;
    ```

* 冒泡排序

1.每一轮,相邻两个数 两两之间进行比较
2.每循环一次从尾部确定一个数
3.循环n次就搞定了


    int arr[] = {12,1,32,4,35,46,4,53,24,36,5,76};

    //计算出数组的长度
    int len = sizeof(arr) / sizeof(arr[0]);
     //循环 目的:控制轮数
    for (int i = 0; i < len - 1; i++) {
        //每一轮 两两比较
        //第i轮 比较多少次? len - 1 - i
        for (int j = 0; j < len - 1 - i; j++) {
            //arr[0] arr[1]
            //arr[1] arr[2]
            if(arr[j] > arr[j+1]){
                //交换
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }

    }
    ```
###二维数组

* 遍历二维数组元素

int nums[3][4];
可以看成3行4列的表格
/*
10 20 30 40
50 60 70 80
90 90 89 80
*/
for (int i = 0; i < 行数; i++) {
for (int j = 0; j < 列数; j++) {
//nums[i][j];
}
printf(“\n”)
}
“`

• 二维数组的初始化

“`
1.在定义的同时初始化:静态初始化
1>全部赋值
int nums[3][4] = {{1,2,3,4},{5,6,6,8},{4,5,6,7}};
int nums[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
2>部分赋值
int nums[3][4] = {{1,2},{3,4},{5,6,7}};
/*
1 2 0 0
3 4 0 0
5 6 7 0

     */
    int nums[3][4] = {1,2,3,4,5,6,7};
    /*
     1 2 3 4
     5 6 7 0
     0 0 0 0

     */
    // 行可以省略 列不能省略
    int nums[][4] = {1,2,3,4,5,6,7,8,9,10};
    /*
     1 2 3 4
     5 6 7 8
     9 10 0 0

     */

    3>奇葩的方式
    int nums[3][4] = {[0]= {1,2,3,4},[2]= {6,7,8,9}};
    int nums[3][4] = {[0][1] = 10};
    /*
     1 2 3 4
     0 0 0 0
     6 7 8 9
     */

2.先定义后初始化:动态初始化,只有一种方法,挨个赋值
int nums[3][3];
nums[0][0] = 0;



只要是静态初始化,没有初始化的部分默认值是0,
    int nums[3][4] = {0};
动态初始化中如果默写元素没有赋值 那么就是垃圾值
```