C数组

生活中我们经常会用到容器，比如我们去超市购物需要使用购物袋装购买的商品。

同样我们在程序中也需要容器，只不过该容器有点特殊，它在程序中是一块连续的，大小固定并且里面的数据类型一致的内存空间，它还有个好听的名字叫数组。可以将数组理解为大小固定，所放物品为同类的一个购物袋，在该购物袋中的物品是按一定顺序放置的。

我们来看一下如何声明一个数组：

数据类型 数组名称[长度];

数组只声明也不行啊，看一下数组是如何初始化的。说到初始化，C语言中的数组初始化是有三种形式的，分别是：

1、 数据类型 数组名称[长度n] = {元素1,元素2…元素n};
2、 数据类型 数组名称[] = {元素1,元素2…元素n};
3、 数据类型 数组名称[长度n]; 数组名称[0] = 元素1; 数组名称[1] = 元素2; 数组名称[n-1] = 元素n;
我们将数据放到数组中之后又如何获取数组中的元素呢？
获取数组元素时： 数组名称[元素所对应下标];
如：初始化一个数组 int arr[3] = {1,2,3}; 那么arr[0]就是元素1。

注意：

1、数组的下标均以0开始；

2、数组在初始化的时候，数组内元素的个数不能大于声明的数组长度；

3、如果采用第一种初始化方式，元素个数小于数组的长度时，多余的数组元素初始化为0；

4、在声明数组后没有进行初始化的时候，静态（static）和外部（extern）类型的数组元素初始化元素为0，自动（auto）类型的数组的元素初始化值不确定。

#include <stdio.h>
int main()
{
    //1、数组的下标均以0开始；
    //2、数组在初始化的时候，数组内元素的个数不能大于声明的数组长度；
    //3.如果采用第一种初始化方式，元素个数小于数组的长度时，多余的数组元素初始化为0；
    //4.在声明数组后没有进行初始化的时候，静态（static）和外部（extern）类型的数组元素初始化元素为0，自动（auto）类型的数组的元素初始化值不确定
    
    //第一种形式
    int arrFirst[10] = {1,2,3,4,5};
   
    
    //第二种形式
    int arrSecond[] = {1,2,3};
    
    //第三种形式
    int arrThird[3];
    //给arrThird数组每个元素初始化
    arrThird[0] = 1;
    arrThird[1] = 2;
    arrThird[3] = 3;
    
    //输出第一个数组中的第二个元素
    printf("%d\n", arrFirst[1]);
    //输出第二个数组中的第二个元素
    printf("%d\n", arrSecond[1]);
    //输出第三个数组中的第二个元素
    printf("%d\n", arrThird[1]);
    return 0;
}

数组遍历时要注意以下几点：
1、最好避免出现数组越界访问，循环变量最好不要超出数组的长度，比如：

2、C语言的数组长度一经声明，长度就是固定，无法改变，并且C语言并不提供计算数组长度的方法。

由于C语言是没有检查数组长度改变或者数组越界的这个机制，可能会在编辑器中编译并通过，但是结果就不能肯定了，因此还是不要越界或者改变数组的长度

#include <stdio.h>
int main()
{
    int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    //补全代码实现对数组arr的遍历
    //可以采用你自己喜欢的循环结果
   
   int length = sizeof(arr)/sizeof(arr[0]);

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

void selectSort (int arr[] ,int length)
{
    //选择法排序
    for (int i = 0; i < length - 1; i ++) {
        for (int j = i + 1; j < length; j ++) {
            if (arr[i] > arr[j]) {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }

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

void bubbleSort (int arr[] ,int length)
{
//冒泡法排序
    for (int i = 0; i < length - 1; i++) {
        for (int j = 0; j < length - i - 1; j++) {
            if (arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
    for (int i = 0; i < length; i ++) {
        printf("%d ",arr[i]);
    }
    printf("\n");
}

int main ()
{
    int arr[] = {99,88,95,77,97,93,86,90};
    int length = sizeof(arr)/sizeof(arr[0]);
    bubbleSort(arr,length);
    selectSort(arr,length);
    return 0 ;
}

#include <stdio.h>

int main ()
{
    int a[27];
    /*
     一、认识数组
     声明了数组a;是一个复合类型（由基础类型组成的自定义类型），相当于声明了27个int；
     这27个int，分别为a[0],a[1],...,a[26]; 在内存中【连续排列】，成为数组a的元素。
     1.内存中是一堆开关， 每8个开关是一个字节，每个字节有一个编号，这个编号就成为地址；
     a[0]占四个字节（每个int占四个字节）
     
     计算a的类型大小
     a的类型是int [27],不是int。看一个变量的类型，认准变量名是标识符，如上述变量名是a,不是a[10]。
     盖住变量名剩下的就是a的类型， 即变量名为int [27]
     
     一个变量的类型，是为了表示：1.变量的类型； 2.占用内存大小。
     */
    
    printf("%ld, %ld\n",sizeof(a), sizeof(int [27]));
    
    //旁证
    int (*p[10])[10];
    printf("%ld, %ld\n",sizeof(p), sizeof(int (*[10])[10]));
    
    //经典C面试题
    //求一个h数组的元素个数
    int len = sizeof(a)/sizeof(a[0]);
    
    for (int i = 0; i < len; i ++) {
        printf("a[%d] = %d\n",i, a[i]);
    }
    /*
     如果数组为初始化， 则数组内元素未知

     a[0] = -389519312
     a[1] = 32766
     a[2] = 384304387
     a[3] = 1
     a[4] = -389519280
     a[5] = 32766
     a[6] = 0
     a[7] = 0
     a[8] = 0
     a[9] = 0
     a[10] = -389519256
     a[11] = 32766
     a[12] = -389519280
     a[13] = 32766
     a[14] = 116887552
     a[15] = 1
     a[16] = 2
     a[17] = 14
     a[18] = 0
     a[19] = 0
     a[20] = 0
     a[21] = 0
     a[22] = 0
     a[23] = 0
     a[24] = 0
     a[25] = 0
     a[26] = 0
     */
    
    
    /*
     一、数组的初始化和赋值。
     int a[5] = {0,1,2,3,4};
     char b[5] = {'a','b','c','d','e'};
     如果初始化数组的每一个元素，称为完全初始化。
     
     或
     int a[5];
     char b[5];

     a[0] = 0;
     a[1] = 1;
     a[2] = 2;
     a[3] = 3;
     a[4] = 4;
     
     
     int c[10] = {0,1,2,3};
     如果只初始化部分元素， 按照顺序初始化前面元素， 未初始化部分为0
     
     数组清空方法：
     int a[10] = {};或int a[10] = {0};
     
     如果数组未初始化， 则数组内元素未知
     
     */
    
    
    int d[] = {0,1,2,3,4};//完全初始化，可省略下标
    
    return 0;
}