c语言--数组

通过前一阵子的c语言学习，相信对变量，基本输入输出有了一定的了解，下面我们继续开始学习c语言比较重要的一块–数组

概括

1.什么叫数组？为什么要有数组？
2.数组的基本操作
a.查询
b.插入
c.删除
d.简单排序
3.二维数组
4.字符数组和字符串的区别
5.数组越界的问题（垃圾值）

为什么要有数组？什么叫数组？

那个通过前一阵的学习的学习，相信你了解了C语言中的变量，就是先想好变量的类型，定好名字，然后赋值什么的。对一个变量的基本操作相信你已经会了，那么现在我要你对一群相同的变量进行同样的操作的时候，这个时候你该怎么办？
可能一：一个一个进行操作，反正不嫌麻烦，一个个赋值什么的。
可能二：既然它们都是相同的数据类型，又进行同样的操作，有没有什么办法，让它们统一操作，这样简单方便，节约时间。

相信聪明的你一定会选可能二，这就是数组存在的原因。
至于什么叫数组，相信你已经猜出来了
数组：就是只能存放一种数据类型，比如int类型的数组、float类型的数组，里面存放的数据称为“元素”

数组的定义：
首先声明数组的类型，然后声明数组元素的个数（也就是需要多少存储空间）
格式： 元素类型 数组名[元素个数];
比如： int a[3];
就是告诉编译器，你现在有3个int类型的元素放在a这个数组里面
数组元素有顺序之分，每个元素都有一个唯一的下标（索引），而且都是从0开始(这点必须记住)
数组元素的访问: a[i]
数组元素的初始化：
 int a[3] = {10, 9, 6};
 int a[3] = {10,9};
 int a[] = {11, 7, 6};
 int a[4] = {[1]=11,[0] = 7};

数组的初始化
上面的代码是先定义数组再给数组赋值，我们也可以在定义数组的同时赋值：
int a[4] = {20, 345, 700, 22};
{ }中的值即为各元素的初值，各值之间用,间隔。

对数组赋初值需要注意以下几点：
1) 可以只给部分元素赋初值。当{ }中值的个数少于元素个数时，只给前面部分元素赋值。例如：
int a[10]={12, 19, 22 , 993, 344};
表示只给 a[0]~a[4] 5个元素赋值，而后面5个元素自动赋0值。

当赋值的元素少于数组总体元素的时候，剩余的元素自动初始化为 0
对于short、int、long，就是整数0；
对于char，就是字符 ‘\0’；
对于float、double，就是小数0.0。

我们可以通过下面的形式将数组的所有元素初始化为 0：
int a[10] = {0};
char c[10] = {0};
float f[10] = {0};
由于剩余的元素会自动初始化为0，所以只需要给第0个元素赋0值即可。

#include<stdio.h>

int main()
{
    //数组的定义格式： 类型 变量名[元素个数];
    //int ages[5];

    //数组的赋值方式：
    /*
    ages[0] = 12;
    ages[1] = 19;
    ages[2] = 14;
    ages[3] = 26;
    ages[4] = 18;
     */

    //int ages[5] = {[2] = 14,[3] = 26};
    //int ages[5] = {12,19};
    int ages[5] = {12,19,14,26,18};

    //错误写法：
    //int ages[];
    //错误写法
    //int ages[5];     只能在定义数组的时候进行初始化
    //ages = {12,19,14,26,18};
    //错误写法,如果想在定义数组的同时进行初始化，数组元素个数必须是常量或者不写
    //int ages[count] = {12,19,14,26,18};

    /*数组的遍历，按顺序查看数组的每一个元素*/

    //1.for循环遍历
    for (int i = 0; i <5; i++)
    {
        printf("ages[%d] = %d\n",i ,ages[i]);
    }



    return 0;
}

数组的基本操作

查询

在数组中查询有两种情况：
a.知道数组的一个下标，知道该下标的元素的值
b.知道一个元素，想看看数组里面有没有或者求这个元素在数组的下标

这两种都很好操作
a.知道在数组a中，求下标为key的元素，直接在用啊a[key]得出这个元素的值。
b.利用for循环哈，从下标为0的开始找，直到找到或者已经找完全部元素了

for(int i = 0;i < 5;i++){
    if(b==a[i]){
        printf("元素b的下标为%d",i);
        break;
    }
`
}

插入

C语言中，数组是一组连续的相同类型的数据集合。 所以要在数组中插入元素，需要按照以下步骤：
1、找到插入点；
2、将插入点所在元素，及之后的所有元素，都向后移动一个单位；
3、将插入点赋值为要插入的元素。
以固定位置插入，代码举例如下：

#include <stdio.h>
void insert(int *a, int n, int i, int v)
//将长度为n的数组a, 下标为i的位置插入值为v的元素。 插入后，数组长度为n+1.
{
    int j;
    for(j = n-1; j>=i; j --)//将i及以后的后移一位。 由于是固定位置插入，所以不需要查找插入位置。 
        a[j+1] = a[j];
    a[i] = v;//插入元素。 
}

int main()
{
    int a[5] = {1,3,6,7};/五个元素数组，初始化四个值。
    int i;

    insert(a, 4, 2, 5);//将5插入到a[2]位置。 
    for(i = 0; i < 5; i ++)
        printf("%d ", a[i]);//输出结果，为1 3 5 6 7 
    return 0;
}

删除

C语言中，数组的删除和插入操作类似。 所以要在数组中删除元素，需要按照以下步骤：
1、找到删除点；
2、将插入点所在元素，及之后的所有元素，都向前移动一个单位；
3、数组的元素个数减一；
以固定位置插入，代码举例如下：

#include "stdio.h"
int main()
{  int a[10],x;//x是要删除数组元素的下标
   int i;
    for(i=0;i<10;i++)
      scanf("%d",&a[i]); //输入10个数据放在数组中
    for(i=0;i<10;i++)
      printf("%d  ",a[i]);   
   printf("请输入要删除元素的下标值：\n");
    scanf("%d",&x); //输入要删除的数组元素的下标 
    for(i=x;i<10;i++)
      a[i]=a[i+1];
  for(i=0;i<9;i++)  //因为删除了一个元素，所以有9个元素 
      printf("%d  ",a[i]); 

}

数组的排序

数组的排序是和很重要的一块算法，有很多方法，比如快排，桶排，冒泡排序等等，在你以后的学习中是必须要掌握的，下面只是简单介绍下冒泡排序和桶排序：

冒泡排序
自己对冒泡排序这个名字觉得蛮有意思的，就像鱼鱼吐泡泡一样，小的数不断往上跑，其实这个算法也蛮简单的，就是两重循环，大的循环是要走的趟数，趟数是n-1，n为要排序的数的个数，小循环里面是每循环一次，就把改数组里最大的或最小的数放到最后面，下一次小循环，就把剩下的数，最大的或最小的放在剩下的数的最后面，这样就完成了从小到大排序或从大到小排。

#include <stdio.h>
int main(void)
{
    int a[100],i,j,t,n;
    scanf("%d",&n);  //输入要排序的数的个数
    for( i =0;i< n;i++)
    {
        scanf("%d",&a[i]);
    }
    //冒泡排序的核心部分
    for(i =0;i<n-1;i++)
    {
        for(j=0;j<n-i;j++)
        {
            if(a[j]<a[j+1])
            {
                t = a[j];
                a[j] = a[j+1];
                a[j+1] = t;
            }
        }
    } 
    for(i =0 ;i < n;i++)
    {
        printf("%d",a[i]
);
    } 
    return 0;
} 

桶排序–最简单最快的排序
桶排序，从名字上都觉得蛮有意思的，它实现的方法很简单，就是弄一大堆桶，每个桶上按顺序贴上标签，比如我要10个数排序，这10个数的范围是0到100，于是我就创建一个啊a[101]的数组数组，也就是100个桶，下标就是代表该桶的值。然后排序的时候，出现一个数，就让该数值的桶里面放个石头，也就是该数组元素的值+1，然后排序的时候，就可以从第一个桶开始数，看里面有石头没，有几个，如果有就输出该桶上的值，没有就看下一个，这样就从小到大排序了哈，如果想从大到小排序，就从最后一个桶开始往前数。

#include <stdio.h>
int main(void)
{
    int book[1000],i,j,k,t,n;
    //输出数字的范围是0到999，也就是999个桶
    for(i = 0;i < 1000;i++)
    {
        book[i] = 0;  //清空数组，也就是所有桶里一开始没有石头 
    }

    scanf("%d",&n);   //输入你要排序多少个数

    for(i = 0;i < n;i++)  //循环读入n个数 
    {
        scanf("%d",&t);
        book[t]++;          //桶里放石头哈 
    } 

    for(i=1000;i>=0;i--)     //从大到小排序 
    {
        for(j=0;j<book[i];j++)
        {
            printf("%d ",i);    //有几个石头就输出几次 
        }
               `

    } 

    return 0;
} 

二维数组

二维数组的定义：
一个数组能表示一个班人的年龄，如果想表示很多班呢？
什么是二维数组？int ages[3][10]; 三个班，每个班10个人，相当于3行10列，相当于装着3个一维数组
二维数组是一个特殊的一维数组：它的元素是一维数组。例如int a[2][3]可以看作由一维数组a[0]和一维数组a[1]组成，这两个一维数组都包含了3个int类型的元素

定义形式： 类型 数组名[ 行数] [列数]
int a[2][3]; //2行3列的二维数组

二维数组的存放顺序是按行存放的，先存放第一行的元素，再存放第2行的元素。例如int a[2][3]的存放顺序是：a[0][0] → a[0][1] → a[0][2] → a[1][0] → a[1][1] → a[1][2]
二维数组的内存存储分配：

(注意：a[0]、a[1]也是数组，是一维数组，而且a[0]、a[1]就是数组名，因此a[0]、a[1]就代表着这个一维数组的地址)

1> 数组a的地址是ffc1，数组a[0]的地址也是ffc1，即a = a[0]；

2> 元素a[0][0]的地址是ffc1，所以数组a[0]的地址和元素a[0][0]的地址相同，即a[0] = &a[0][0]；

3> 最终可以得出结论：a = a[0] = &a[0][0]，以此类推，可以得出a[1] = &a[1][0]
//如果上面的关于地址的方面看不懂的话，没关系，先简单了解下，学完指针再回头来看
二维数组的初始化：
二维数组的初始化
二维数组的初始化可以按行分段赋值，也可按行连续赋值。

例如对数组a[5][3]，按行分段赋值可写为：
int a[5][3]={ {80,75,92}, {61,65,71}, {59,63,70}, {85,87,90}, {76,77,85} };
按行连续赋值可写为：
int a[5][3]={80, 75, 92, 61, 65, 71, 59, 63, 70, 85, 87, 90, 76, 77, 85};
这两种赋初值的结果是完全相同的。

对于二维数组初始化赋值还有以下说明
1) 可以只对部分元素赋初值，未赋初值的元素自动取0值。例如：
int a[3][3]={{1},{2},{3}};
是对每一行的第一列元素赋值，未赋值的元素取0值。 赋值后各元素的值为：
1 0 0
2 0 0
3 0 0

int a [3][3]={{0,1},{0,0,2},{3}};
赋值后的元素值为：
0 1 0
0 0 2
3 0 0

2) 如对全部元素赋初值，则第一维的长度可以不给出。例如：
int a[3][3]={1,2,3,4,5,6,7,8,9};
可以写为：
int a[][3]={1,2,3,4,5,6,7,8,9};

3) 二维数组可以看作是由一维数组嵌套而成的，把一维数组的每个元素看作一个数组，就组成了二维数组。当然，前提是各元素类型必须相同。根据这样的分析，一个二维数组也可以分解为多个一维数组，C语言允许这种分解。

如二维数组a[3][4]，可分解为三个一维数组，其数组名分别为：a[0]、a[1]、a[2]。

对这三个一维数组不需另作说明即可使用。这三个一维数组都有4个元素，例如：一维数组a[0]的元素为a[0][0], a[0][1], a[0][2], a[0][3]。必须强调的是，a[0], a[1], a[2]不能当作下标变量使用，它们是数组名，不是一个单纯的下标变量。

字符串和字符数组的区别

用来存放字符的数组称为字符数组，例如：

char a[10];  //一维字符数组
char b[5][10];  //二维字符数组
char c[20]={'c', '  ', 'p', 'r', 'o', 'g', 'r', 'a','m'};  // 给部分数组元素赋值
char d[]={'c', ' ', 'p', 'r', 'o', 'g', 'r', 'a', 'm' };  //对全体元素赋值时可以省去长度

字符数组实际上是一系列字符的集合，也就是字符串（String）。在C语言中，没有专门的字符串变量，没有string类型，通常就用一个字符数组来存放一个字符串。

C语言规定，可以将字符串直接赋值给字符数组，例如：

char str[30] = {"abcaaaaaaaaaaaa"};
char str[30] = "abcaaaaaaaaaaaa";  //这种形式更加简洁

数组第0个元素为 ‘a’，第1个元素为 ‘b’，第2个元素为 ‘c’，后面的元素以此类推。也可以不指定数组长度，例如：

char str[] = {"aaaaaaaaaaaaaa"};
char str[] = "aaaaaaaaaaaaaaaa";  //这种形式更加简洁

在C语言中，字符串总是以’\0’作为串的结束符。上面的两个字符串，编译器已经在末尾自动添加了’\0’。
‘\0’是ASCII码表中的第0个字符，用NUL表示，称为空字符。该字符既不能显示，也不是控制字符，输出该字符不会有任何效果，它在C语言中仅作为字符串的结束标志。
puts 和 printf 在输出字符串时会逐个扫描字符，直到遇见 ‘\0’ 才结束输出。请看下面的例子：

#include <stdio.h>
int main(){
    int i;
    char str1[30] = "aaaaaaaaaa";
    char str2[] = "bbbbbbbbbb";
    char str3[30] = "You are a good\0 boy!";
    printf("str1: %s\n", str1);
    printf("str2: %s\n", str2);
    printf("str3: %s\n", str3);
    return 0;
}

运行结果：
str1: aaaaaaaaaa
str2: bbbbbbbbbb
str3: You are a good

str1 和 str2 很好理解，编译器会在字符串最后自动添加 ‘\0’，并且数组足够大，所以会输出整个字符串。对于 str3，由于字符串中间存在 ‘\0’，printf() 扫描到这里就认为字符串结束了，所以不会输出后面的内容。
需要注意的是，用字符串给字符数组赋值时由于要添加结束符 ‘\0’，数组的长度要比字符串的长度（字符串长度不包括 ‘\0’）大1。例如：
char str[] = “C program”;
该数组在内存中的实际存放情况为：

字符串长度为 9，数组长度为 10。

数组越界的问题

C语言数组不会自动扩容，当下标小于零或大于等于数组长度时，就发生了越界（Out Of Bounds），访问到数组以外的内存。如果下标小于零，就会发生下限越界（Off Normal Lower）；如果下标大于等于数组长度，就会发生上限越界（Off Normal Upper）。

C语言为了提高效率，并不会对越界行为进行检查，即使越界了，也能够正常编译，只有在运行期间才可能会发生问题。请看下面的代码：

#include <stdio.h>
#include <stdlib.h>
int main()
{
    int a[3] = {10, 20, 30}, i;
    for(i=-2; i<=4; i++){
        printf("a[%d]=%d\n", i, a[i]);
    }
    system("pause");
    return 0;
}

运行结果：
a[-2]=-858993460
a[-1]=-858993460
a[0]=10
a[1]=20
a[2]=30
a[3]=-858993460
a[4]=-858993460

越界访问的数组元素都是垃圾值，没有实际的含义，因为数组之外的内存我们并不知道是什么，可能是其他变量的值，可能是附加数据，可能是一个地址，这些都是不可控的。

由于C语言的”放任“，我们访问数组时必须非常小心，要确保不会发生越界。

当发生数组越界时，如果我们对该内存有访问权限，程序将正常运行，但会出现不可控的结果（如上例所示）；如果没有访问权限，程序将会崩溃。请看下面的例子：

#include <stdio.h>
#include <stdlib.h>
int main()
{
    int a[3];
    printf("%d", a[10000]);
    system("pause");
    return 0;
}

这样的程序会挂，，，每个程序可访问的内存都是有限的，该程序要访问 4*10000 字节处的内存，显然太远了，超出了程序的访问范围。这个地方的内存可能是其他程序的内存，可能是系统本身占用的内存，可能是没被使用的内存，如果放任这种行为，将带来非常危险的后果，操作系统只能让程序停止运行。

数组溢出

当赋予数组的元素个数超过数组长度时，就会发生溢出（Overflow）。如下所示：
int a[3] = {1, 2, 3, 4, 5};
数组长度为3，初始化时却赋予5个元素，超出了数组容量，所以只能保存前3个元素，后面的元素被丢弃。
一般情况下数组溢出不会有什么问题，顶多是丢弃多余的元素。但对于字符数组，有时会产生不可控的情况，请看下面的代码：

#include <stdio.h>
#include <stdlib.h>
int main()
{
    char str[10] ="aaaaaaaaaaaaaaaaaaaaaaa";
    puts(str);
    system("pause");
    return 0;
}

在有的编译器下是过不了编译的，有的会输出”aaaaaaaaaa烫烫烫烫”等莫名其妙的汉字.
字符串的长度大于数组长度，数组只能容纳字符串的前面一部分，也就是 “aaaaaaaaaa”，即使编译器在最后添加了 ‘\0’，它也保存不到数组里面，所以 printf() 扫描数组时不会遇到结束符 ‘\0’，只能继续向后扫描。而后面内存中的数据我们不知道是什么，字符能否识别，何时遇到 ‘\0’，这些都是不确定的。当字符无法识别时，就会出现乱码，显示奇怪的字符。

由此可见，在用字符串给字符数组赋值时，要保证数组长度大于字符串长度，以容纳结束符 ‘\0’。