C语言回顾 四 数组

   
数组是一种构造类型，相同数据类型构成新的数据类型。数组的每个成员成为一个数组元素。
最简单的数组是：一位数组。
一维数组的定义： 类型说明符 数组名【常量表达式】 = {值1，值2......};
在数组之中，有一些问题需要注意：
a.数组越界，很危险
b.数组元素个数可以省略，但是必须赋初值，否则没有办法决定元素的个数
c.数组不能直接参与运算，数组中的元素可以参与运算
d.定义数组必须有数据类型
e.取数组元素时，元素下标不能够省略
f.定义数组时，如果没有赋值，那么整型默认为0，字符型默认为'0'
g.%s打印遇到'\0'停止
h.元素的下标从0开始，元素下标的范围为[0, 数组元数个数 - 1]
例如： int array[3] = {1,2,3};  //int 定义元素的类型
          数组名： array             
          数组类型：int [3]  
          初始值： {1，2，3}
    //类型说明符：
    //定义一个数组（每个元素都是int类型）
    //注意： 定义数组时[]内只能是常量表达式，不能是变量；
    int array2[] = {};//定义数组时[]内的值不能是变量；
    int array[3] = {1, 3, 5};//array[0] array[1] array[2]
    printf("%d",array[2]);
    int array[3] 和array[3] (千万不要越界）；
    float array[10] = {0};
    for (int i = 0; i <= 9; i++) {
    array[i] = arc4random() % (40 - 20 + 1) +20;
    printf("%.2f ",array[i]);//使用的事后array【可以使变量】,定义的时候不可以
    }
    
    short array1[5] = {1,2,3,4,5};
    for (int a = 0; a < 5; a++) {
        printf("%hd ",array1[a]);   }
    
    char a[5] = {'n','k','j','w','d'};
    for (int i = 0; i < 5; i++) {
        printf("%c ",a[i]);
    }
    
    //数组元素进行赋值array[下标] = 值
    int array[10] = {0};
    for (int i =0; i < 10 ; i++) {
        array[i] = arc4random() % (80 - 10 + 1) +10;
        printf("%d ",array[i]);
    }
    
    int a[20] ={0};
    int sum =0;
    for (int i = 0; i < 20; i++) {
        a[i] = arc4random() % (70 - 30 + 1) + 30;
        sum += a[i];
        printf("%d",a[i]);
    } printf("结果：%d ",sum);
    
    int a[20] = {0};
    int max =0;
    printf("数组的数据：");
    for (int i = 0; i < 20; i++) {
        a[i] = arc4random() % (70 - 30 +1) +30;
        printf("%d ",a[i]);
        if (max < a[i]) {
            max = a[i];
        }
    }printf("\n最大值：%d",max);
    //复制一个数组，即两个数组的容量一样，把其中一个数组的元素复制到拧一个数组中去
    //定义一个数组（赋初始值）
    int arr[] = {1, 4, 5, 7,9};
    //定义一个数组（赋值上边数组的内容）；
    int arr1[5] = {0};//
    //把arr的内容复制到arr1中,并打印
    for (int i =0; i < 5; i++) {
        arr1[i] = arr[i];
        printf("%d ", arr1[i]);
    }
    
    int array[5] = {0};
    int array1[5] = {0};
    for (int i = 0; i < 5; i++) { //第一部分 随机数组1的五个值
        array[i] = arc4random() % ( 70 - 30 + 1) + 30;
        printf("%d ", array[i]);
    }printf("\n");
    for (int i = 0; i < 5; i++) {  //把数组1 的值 移动到 数组2中；
        array1[i] = array[i];
        printf("%d ",array1[i]);
    }
    
 生成两个数组，每个数组都有10个元素，元素取值40 --- 20 之间，数组对应的元素相加放到另一个数组中；
    int array[10] = {0}; //先定义三个相同容量的数组，并赋初值
    int array1[10] = {0};
    int array2[10] = {0};  
    for (int i = 0; i < 10; i++) {  //随机两个数组的值并移动到一个数组中
        array[i] = arc4random() % (40 - 20 + 1) + 20;
        array1[i] = arc4random() % (40 - 20 + 1) +20;
        array2[i] = array[i] + array1[i];  //数组中的元素相加
        printf("%d " ,array[i]);
    }printf("\n");//换行
    for (int i = 0; i <10; i++) {
        printf("%d ",array1[i]);
    }printf("\n");
    for (int i = 0; i < 10; i++) {
        printf("%d ",array2[i]);
    }
   
    数组排序
    方法比如：冒泡排序，选择排序，插入排序，归并排序；
    冒泡排序涉及双循环，外层控制循环趟数，内层控制比较次数
     9 6 5 8 2（小--大） 5个数（数组元素个数）
     第0趟 6 8 5 2 | 9    4次    次数= 个数 - 1 - 趟数;
     第1趟 6 5 2 | 8 9    3次   j = n - 1 -j;
     第2趟 5 2 | 6 8 9    2次
     第3趟 2 | 5 6 8 9    1次
    //作业1 冒泡排序 20遍 （手敲版）；
    int array[5] = {9, 6, 5, 8, 2};
    for (int i = 0; i < 5 -1; i++) {  //比较趟数=数组元素n-1
        for (int j =0; j < 5 - 1 - i; j++) { //比较次数=n-1-趟次
            if (array[j] > array[j+1]) {
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }i
        }
    } for (int i = 0; i < 5; i++) {
        printf("%d ",array[i]);
    }
    
   //定义一个数组，并﹣初值，[]中的常量表达式不能为变量
    int a[10] ={0};
    int i =0;
printf("开始摇人：");
//随机出一个数组，并打印
    for(i = 0; i < 10; i++){
        a[i] = arc4random() % (40 -20 + 1) + 20;
        printf("%d ",a[i]);
    }
printf("\n");
//开始比较大小排序（冒泡）
    for (i = 0; i < 10 -1; i++) {   //趟数：i < n - 1;
        for (int j = 0; j < 10 - 1 - i; j++) {  //比较次数： j < n - 1 - i;
            //比较（第j个和第j+1个），如果第j个大于第j+1个交换；
            if (a[j] > a[j+1]) {
                int temp = 0;
                temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
            }
        }
    }printf("全体排队：");
    for (int i = 0; i < 10; i++) {
        printf("%d ",a[i]);
    }
    
//字符数组
    char c[] = {'i', 'p', 'h', 'o', 'n', 'e'};
    char c1[] = "iphone";//字符串有一个隐含的‘、0’作为结束标志，所以在存储的时候，字符的个数最多是元素的个数-1个；
    printf("****%lu\n",sizeof(c));// 6
    printf("****%lu",sizeof(c1));// 7
    
    //字符数组不一定是字符串（有\0结束标志的）；
    //字符串一定是字符数组
    
    //1 单个字符的操作
    c1[0] = 'p'; //改变字符串的摸个字符的值；
    printf("\n");
    for (int i = 0; i < 6; i++) { //打印字符串中的某个字符
        printf("%c ",c1[i]);
    }
    
    //整个字符串的操作
    //打印整个字符串，占位符%s
    printf("\n%s",c1);
/*字符串的处理函数
 sizeof() 计算字节数，（）内部可以是表达式也可以是类型
     strlen()  计算字符串⻓长度
     strcpy()  字符串拷⻉贝
     strcat()  字符串拼接
     strcmp()  字符串⽐比较
     注意： 有'\0'结束标志的才能使用
    
    //字符串长度（有效长度，既字符的个数）；
    char str[10] = "iPhone"; //字节数=有效长度+1；char [10]定义字节数有10个
    printf("str所占的字节数：%lu\n",sizeof(str));//10  str[10]
    printf("str字符串的长度：%lu",strlen(str));//6
  
    //字符串拷贝（把一个字符串的内容拷贝到另一个字符串中）；
    
    char strArr[] = "lanou";
    char atrArr1[6] = {0};
    //前一个位置，拷贝到哪
    //后一个位置，从哪拷贝
    //接收的数组一定不能比原来的数组小
    strcpy(atrArr1, strArr);
    printf("%s\n",strArr);
    
    
    //字符串拼接 （）
    char strArr[10] = "lanou";  //占10个字符，有效长度6
    char strArr1[] = "keji";
    //第一个位置，被拼接的字符
    //第二个位置，拼接的是什么
    //第一个位置需要有足够的空间
    strcat(strArr, strArr1);
    printf("%s\n",strArr);
    
    
    
    //字符串比较
    char ss1[] = "aaa";
    char ss2[] = "bbb";
    printf("%d",strcmp(ss2, ss1)); // 1    数组2>数组1为真
    /*将字符倒转
例如， "a f n p u e"   交换     交换     交换
        0 1 2 3 4 5   0《=》5  1《=》4  2《=》3
     转变 成字符串 “eupnfe”
    char str[] = "afnpue";
    for (int i = 0; i < strlen(str)/2; i++) {
        //交换第i个位置和第strlen(str) - 1 - i位置的值
        char temp = str[i];
        str[i] = str[strlen(str ) - 1 - i];
        str[strlen(str ) - 1 - i] = temp;
    }
    
    printf("%s",str);
     */
  
        return 0;
}





数组排序问题
1、问题描述
    数组排序（即按某种特定的顺序排列数据，如升序或降序）是最重要的计算应用之一，银行用帐号对所有的支票进行能够排序，并根据排序结果准备月底的财务报 告，学校学生成绩管理系统用数组排序的方法将考试成绩从高到低进行排名，数组排序方法很多，有直接插入排序、冒泡排序、快速排序、直接选择排序，下面来详 细介绍这四种基本的排序方法及其实现。
2、方法总结
   1）直接插入排序：数据表A中每个元素距其最终位置不远，数据表A按关键字值基本有序，可用此方法排序较快。
   2）冒泡排序法：将较小的值“上浮”到数组顶部，而较大值“下沉”到数组底部，这种排序技术要比较好几趟，每一趟要比较连续的数组元素对，如果某对数值是按升序排序的（或者这两个值相等），那就保持原样，如果某对数组是按降序排列的，就要交换它们的值。
   3）快 速排序法：快速排序是对冒泡排序的一种改进。它的基本思想是：通过一躺排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有 数据都要小，然后再按次方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
   4）直 接选择排序法：直接选择排序的作法是：第一趟扫描所有数据，选择其中最小的一个与第一个数据互换；第二趟从第二个数据开始向后扫描，选择最小的与第二个数 据互换；依次进行下去，进行了(n-1)趟扫描以后就完成了整个排序过程。它比起冒泡排序有一个优点就是不用不断的交换。
3、算法实现
    1）直接插入法实现
1.	#include<stdio.h>  
2.	#include<conio.h>  
3.	  
4.	int main()  
5.	{  
6.	        void InsertSort(int [],int);  
7.	        int a[7]={8,10,2,3,1,7,13};  
8.	        int i;  
9.	        InsertSort(a,7);  
10.	        for(i=0;i<7;i++)  
11.	           printf("%4d",a[i]);  
12.	        getch();  
13.	}  
14.	void InsertSort(int a[],int count)  
15.	{  
16.	        int i,j,temp;  
17.	        for(i=1;i<count;i++)     
18.	        {  
19.	           temp=a[i];  
20.	           j=i-1;  
21.	           while(a[j]>temp && j>=0)  
22.	           {  
23.	             a[j+1]=a[j];  
24.	              j--;  
25.	           }  
26.	           if(j!=(i-1))       
27.	             a[j+1]=temp;  
28.	         }  
29.	}  

      2）冒泡法实现 
1.	#include<stdio.h>  
2.	#include<conio.h>  
3.	int main()  
4.	{  
5.	         void BubbleSort(int []);  
6.	         int a[10];  
7.	         int i,j,temp;  
8.	         printf("Input tem integer numbers for a[10]:");  
9.	         for(i=0;i<10;i++)  
10.	            scanf("%d,",&a[i]);  
11.	         printf("\n");  
12.	         BubbleSort(a);  
13.	         printf("The sorted array is:\n");  
14.	            for(j=0;j<10;j++)  
15.	                 printf("%d,",a[j]);  
16.	         printf("\n\n");  
17.	         getch();  
18.	}  
19.	  
20.	void BubbleSort(int array[])  
21.	{  
22.	         int i,j,temp;  
23.	           for(j=0;j<9;j++)  
24.	              for(i=0;i<9-j;i++)  
25.	                 if(array[i]>array[i+1])  
26.	                  {  
27.	                      temp=array[i];  
28.	                      array[i]=array[i+1];  
29.	                      array[i+1]=temp;  
30.	                   }  
31.	}  

        3）快速排序法实现 
1.	#include<stdio.h>  
2.	#include<conio.h>  
3.	#define Max 8  
4.	  
5.	int main()  
6.	{  
7.	         void QuickSort(int a[],int p,int r);  
8.	         int a[]={2,8,7,1,3,5,6,4};  
9.	         QuickSort(a,1,Max);  
10.	         printf(" The sorted array is :");  
11.	            for(int i=0;i<Max;i++)  
12.	               printf("%d,",a[i]);  
13.	         printf("\n");  
14.	         getch();  
15.	}  
16.	  
17.	void QuickSort(int a[],int p,int r)  
18.	{  
19.	         int Partition(int a[],int p,int r);  
20.	         if(p<r)  
21.	         {  
22.	            int q=Partition(a,p,r);  
23.	            QuickSort(a,p,q-1);  
24.	            QuickSort(a,q+1,r);  
25.	         }  
26.	}  
27.	  
28.	int Partition(int a[],int p,int r)  
29.	{  
30.	         int i=p-1;  
31.	         int x=a[r-1];  
32.	            for(int j=p;j<r;j++)  
33.	            {  
34.	               if(a[j-1]<=x)  
35.	                {  
36.	                   i=i+1;  
37.	                   int temp;  
38.	                   temp=a[j-1];  
39.	                   a[j-1]=a[i-1];  
40.	                   a[i-1]=temp;  
41.	                 }  
42.	             }  
43.	         int temp;  
44.	         temp=a[i];  
45.	         a[i]=a[r-1];  
46.	         a[r-1]=temp;  
47.	         return i+1;  
48.	}  

        4）直接选择法实现 

1.	#include<stdio.h>  
2.	#include<conio.h>  
3.	  
4.	int main()  
5.	{  
6.	         void ChooseSort(int []);  
7.	         int i,j,a[10];  
8.	         printf("Input ten integer numbers for a[10]: ");  
9.	            for(i=0;i<10;i++)  
10.	               scanf("%d,",&a[i]);  
11.	         printf("\n");  
12.	         ChooseSort(a);  
13.	         printf("The sorted array is:\n");  
14.	            for(j=0;j<10;j++)  
15.	               printf("%d,",a[j]);  
16.	         printf("\n\n");  
17.	         getch();  
18.	}  
19.	  
20.	void ChooseSort(int array[])  
21.	{  
22.	         int j,temp,*p1,*p2;  
23.	         for(p1=array;p1<array+9;p1++)  
24.	            {   
25.	              j++;  
26.	              for(p2=array+j;p2<=array+9;p2++)  
27.	                if(*p2<*p1)  
28.	                  {  
29.	                     temp=*p2;  
30.	                     *p2=*p1;  
31.	                     *p1=temp;  
32.	                  }  
33.	            }  
34.	}  

4、各种方法比较
    1）时间性能比较
    按平均的时间性能来分，四种类排序方法时间复杂度分别为：
    直接插入排序法：O(n^2)
    冒泡排序法：O(n^2)
    快速排序法：O(nlogn)
    直接选择排序法：O(n^2)
    时间复杂度为O(n^2)的有：直接插入排序、起泡排序和简单选择排序，其中以直接插入为最好，特 别是对那些对关键字近似有序的记录序列尤为如此；当待排记录序列按关键字顺序有序时，直接插入排序和起泡排序能达到O(n)的时间复杂度;而对于快速排序 而言，这是最不好的情况，此时的时间性能蜕化为O(n2)，因此是应该尽量避免的情况。
    2）排序方法的稳定性能比较
    1.稳定的排序方法指的是，对于两个关键字相等的记录，它们在序列中的相对位置，在排序之前和经过排序之后，没有改变。
    2.当对多关键字的记录序列进行LSD方法排序时，必须采用稳定的排序方法。
    3.对于不稳定的排序方法，只要能举出一个实例说明即可。
    4.快速排序是不稳定的排序方法。