数组

数组

一、一维数组的定义和初始化

数组是一组具有相同类型的变量的集合；

定义数组的格式：

数据类型（基类型） 数组名 数组长度（维数） = { …..};

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

• 构成数组的每个数据项称为数组元素，c语言通过数组的下标实现对数组的访问；

• 与其他语言类似，c语言的数组下标也是从0开始的；

• 在定义数组时不能使用变量定义数组的大小；

• 初始化列表中的的初值个数不能多于定义的长度；

• int score[] = {1, 2, 3, 4, 5};这样编辑器会自动设置数组长度；

• 如果未给数组定义长度，系统会自动按照初始化列表中的初值个数对数组进行初始化并确定数组的大小；所以只给部分数组赋值的时候，对数组的长度声明是不能省略的；

• 当数组被声明为静态存储类型和外部存储类型的时候，再不给定初值的情况下，数组元素将在程序编译阶段自定初始化为0；

• static int score[5];
  static int score[5] = {0, 0, 0, 0, 0};

• 在访问数组的时候，一定要注意不能对数组越界访问，否则回引起错误；

• 同一个数组中，所有元素的数据类型都是相同的；

• c语言不允许对数组的大小做动态定义；

• 数组元素有序不是指元素大小顺序，而是指其下标有序;

• float a[0]; /* 数组大小为0没有意义*/；

• c语言中不带下标的数组名有着特殊的含义，它代表数组的首地址；

二、二维数组的定义和初始化

一般格式：

类型 数组名 [第一维长度][第二维长度];

一位数组在内存中占用字节数：数组长度 * sizeof(基类型）；
二维数组在内存中占用字节数：数组一维长度 * 二维长度 * sizeof(基类型）；
注意：在不同的编译系统中，int占用的字节数是不同的；
上面出现的sizeof运算符是用来计算一个类型或者变量在内存中所占的字节数；

short matrix{][4] = {1, 2, 3, 4, 5, 6, 7, 8};
short matrix[2][4] = {1, 2, 3, 4, 5, 6, 7, 8};

在二维数组中，可以不定义一维数组的长度，但是必须定义二维数组的长度；

三、向函数专递一维数组

#include "stdio.h"
#define N 10

int addArray(int a[], int n) //数组做被调函数的形参的时候，数组的长度可以不指定；
{
    int i, sum = 0;
    for(i=0;i<n;i++)
    {
        sum += a[i]; 
    }
    return sum;
}

int main()
{
    int a[5] = {1, 2, 3, 4, 5};
    int b = 5;
    int result;
    result = addArray(a, b);    //**向函数传递数组，只需将数组名作为函数实参调用函数即可；**
    printf("This array sum is: %d", result);
    return 0;
}

结果是：
This array sum is: 15

由于函数名代表一个数组的第一个元素的首地址，所以用数组名作为函数的实参实际上是将数组的首地址传给被调函数；
数组做被调函数的形参的时候，数组的长度可以不指定；因为数组名方括号后面的数字不能真正代表接收数组的大小；
下面我们来上一段代码实践一下：

#include "stdio.h"
#define N 40

int Average(int score[], int n);
int ReadScore(int score[]);
int main()
{
    int score[N], aver, n;
    n = ReadScore(score);
    aver = Average(score, n);
    printf("Average score is %d\n ", aver);
    return 0;
}  

int ReadScore(int score[])
{
    printf("Please input sccore:(input negative number is end!)\n");
    int i = -1;
    do{
        i++;
        scanf("%d", &score[i]); //这里其实我们已经将负数写到了数组里面，但是在计算的时候，我们只读到正数的那一项，负数的不读； 
    }while(score[i] >= 0);
    return i;
}

int Average(int score[], int n)
{
    int i, sum = 0;
    for(i=0;i<n;i++)
    {
        sum += score[i];
    }
    return  (sum / n);
}

结果是：
Please input sccore:(input negative number is end!)
89（输入）
99
79
-1
Average score is 89（输出）

四、排序和查找

1、交换排序算法

交换排序算法就是如果有五个数降序排序的话，那么我们需要进行4次。
第一次排序：我们排出5个数中最大的一个数，放在5个数的第一个位置；
第二次排序：我们排出5个数中第二个较大的数，放在5个数的第二个位置；
第三次排序：我们排出5个数中第三个较大的数，放在5个数的第三个位置；
第四次排序：我们排出5个树中较小的数，放在5个数的第四个位置；
第五次排序：我们排出5个数中最小的数，放在5个数中的第五位置；

#include "stdio.h"

void DataSort(int score[], int n);

int main()
{
    int score[5] = {89, 81, 71, 76, 100};
    int n = 5;
    int i; 
    printf("Sorting before!\n");
    for(i=0;i<n;i++)
    {
        printf("%-5d", score[i]);
    }
    printf("\n");
    DataSort(score, n);
    printf("Sort after!\n");
    for(i=0;i<n;i++)
    {
        printf("%-5d", score[i]);
    }
    return 0;
}

void DataSort(int score[], int n)
{
    int i, j;
    int temp;
    for(i=0;i<n;i++)
    {
        for(j=i+1;j<n;j++)      //这个就是该算法的关键，从下一个数开始比较；
        {
            if(score[j]>score[i])
            {
                temp = score[j];
                score[j] = score[i];
                score[i] = temp;
            }
        }
    }
}

结果是：
Sorting before!
89 81 71 76 100
Sort after!
100 89 81 76 71

### 2.选择排序算法
选择排序算法就是用第i个数和后面的数进行比较，从而找最大的数；将最大的数和第i个数交换位置；这样每一轮最多只有一次两个数进行交换。整个算法最多进行 n-1次两数交换。相比较于交换排序算法，减少的两数交换的次数，提高了效率。

#include "stdio.h"

void DataSort(int score[], int n);

int main()
{
    int score[5] = {89, 81, 71, 76, 100};
    int n = 5;
    int i; 
    printf("Sorting before!\n");
    for(i=0;i<n;i++)
    {
        printf("%-5d", score[i]);
    }
    printf("\n");
    DataSort(score, n);
    printf("Sort after!\n");
    for(i=0;i<n;i++)
    {
        printf("%-5d", score[i]);
    }
    return 0;
}

void DataSort(int score[], int n)
{
    int i, j, k;
    int temp;
    int max = score[0];
    for(i=0;i<n;i++)
    {
        k = i;      //标记排序的次数和位置；
        for(j=i+1;j<n;j++)
        {
            if(score[j]>score[k])
            {
                k = j;      //标记最大数的的位置
            }
        }
        if(k != i)      //最大叔的位置不是下标位置；
        {
            temp = score[k];
            score[k] = score[i];
            score[i] = temp;
        } 
    }
}

结果是：
Sorting before!
89 81 71 76 100
Sort after!
100 89 81 76 71