C语言复习 数组

数组（在内存中开辟连续的内存空间）

一、一维数组

1、如何定义一个一维数组：

类型符   数组名[常量表达式]

int          a[10]

注：

         (1)数组中每个元素均没有变量名

         (2)下标法表示数组中的某个元素，从0开始计数

程序示例：（下标法访问）

定义一个数组并初始化（一）（二）

（一）仅限于学习，不建议使用

#include <stdio.h>
/*
 *     定义一个数组并初始化(一)
 *     过程繁琐，不建议使用
 */
int main()
  {
      int a[10];     //10表示数组的大小，数组中元素的总个数

      a[0] = 100;
      a[1] = 101;
      a[2] = 102;
      a[3] = 103;

          return 0;
  }

（二）

#include <stdio.h>
/*
 *      创建并初始化数组（二）
 */
int main()
  {
      int a[10];
      int i;

      for(i=0;i<10;i++)
        {
             a[i] = i+100;
             printf("a[%d] = %d\n",i,a[i]);
        }
      printf("done\n");
         return 0;
  }

 2、数组初始化的几种方式及计算数组的大小

全部赋值：int a[10] = {0,1,2,3,4,5,6,7,8,9};

部分赋值：int a[10] = {1,2,3,4,5};        //编译器会将后面没有的数据自动补零(浪费空间)

初始化为0：int a[10] ={0};

根据数组大小自动分配空间：int a[] = {0,1,2,3,4,5,6,7,8,9};

计算数组中元素的个数：

int size;

size = sizeof(a) / sizeof(a[0]);     //整个数组的总字节数 / 单个元素的字节数 = 数组的个数 

#include <stdio.h>
/*
 *      数组的初始化的方式
 */
int main()
  {
     // int a[10] = {0,1,2,3,4,5,6,7,8,9};       //全部赋值
     // int a[10] = {0,1,2,3};                   //部分赋值
     // int a[10] = {0};                         //初始化为0
      int a[] = {0,1,2,3,4,5,6,7,8,9};         //根据数组大小自动分配空间

      int i;
      //计算数组的大小
      int size;
      size = sizeof(a) / sizeof(a[0]);

      for(i=0;i<size;i++)
        {
             printf("address:%p  a[%d] = %d\n",&a[i],i,a[i]);
        }
      printf("done\n");
         return 0;
  }

 数组的练习：

（1）逆序输出：

#include <stdio.h>
/*
 *      数组的逆序输出
 */
int main()
  {
      int a[] = {0,1,2,3,4,5,6,7,8,9};
      int i;
      int size;
      size = sizeof(a)/sizeof(a[0]);
      printf("size: %d\n",size);

      for(i=size-1;i>=0;i--)
        {
             printf("address: %p a[%d] = %d\n",&a[i],i,a[i]);
        }

          return 0;
  }

  （2）冒泡排序：18，9，27，32 （从小到大）

           推理过程：

冒泡排序

	0	1	2	MIN
0	18，9，27，32	18，27，9，32	18，27，32，9	9
1	27，18，32	27，32，18		18
2	32，27			27

                                                i=0                     j=0   j= 1   j=2

                                                i=1                     j=0   j=1

                                                i=2                     j=0   

                                                i = len(len为排序数字的总个数)

                                                j = 0       ;       j = len-i-1

程序实现：

外层循环是用来判断循环次数的

#include <stdio.h>
/*
 *       冒泡排序：32 33 98 34 53 52 87 90 48 39
 *       从小到大排序
 */

int main()
  {
       int arr[] = {32,33,98,34,53,56,87,90,48,39};
       int i;
       int j;
       int size = sizeof(arr) / sizeof(arr[0]);
       int tmp;    //临时存放交换的数值

       for(i=0;i<size-1;i++)
         {
           for(j=0;j<size-i-1;j++)
             {
                if(arr[j] > arr[j+1])     // > 从小到大排列     < 从大到小排列
                 {
                    tmp      = arr[j];
                    arr[j]   = arr[j+1];
                    arr[j+1] = tmp;
                 }
             }
         }

       //输出排序结果
       for(i=0;i<size;i++)
         {
             printf("%d ",arr[i]);
         }
       printf("done\n");
          return 0;
  }

(3)选择排序：8 7 12 0

0  ：原先的数值 

0  ：交换完的数值

推理过程：逻辑能理解，推理不出来，直接记住结果

选择排序

	0	1	2	MIN
0	7 8 12 0	7 8 12 0(未交换)	0 8 12 7	0
1	8 12 7(未交换)	7 12 8		7
2	8 12			8

                                                i = len - 1

                                                j = i + 1      ；      j < len       

程序实现：

#include <stdio.h>
/*
 *       选择排序：32 33 98 34 53 52 87 90 48 39
 *       从小到大排序
 */

int main()
  {
       int arr[] = {32,33,98,34,53,56,87,90,48,39};
       int i;
       int j;
       int size = sizeof(arr) / sizeof(arr[0]);
       int tmp;    //临时存放交换的数值

       for(i=0;i<size-1;i++)
         {
           for(j=i+1;j<size;j++)
             {
                if(arr[j] > arr[j+1])     // > 从小到大排列     < 从大到小排列
                 {
                    tmp      = arr[j];
                    arr[j]   = arr[j+1];
                    arr[j+1] = tmp;
                 }
             }
         }

       //输出排序结果
       for(i=0;i<size;i++)
         {
             printf("%d ",arr[i]);
         }
       printf("done\n");
          return 0;
  }

---

---

 

二、二维数组：

 1、如何定义一个二维数组

类型符   数组名[常量表达式][常量表达式]

int  arr[3][4]；

程序示例：

/*
*         二维数组定义、初始化、遍历二维数组
*/
#include <stdio.h>

int main()
  {
      /* 
       *  二维数组的定义
       */
      int arr[2][3];       //定义一个两行三列的二维数组
                           //注意：行列只是逻辑上的行和列


      /*
       *  二维数组的定义及初始化
       */
      int arr1[2][3] = {{000,111,222},{444,555,666}};   //定义一个两行三列的二维数组及初始化
      int arr2[2][3] = {1,2,3,4,5,6};                   //二维数组初始化方法二
      //以上两种方式只是表现方式不一致，输出方式和结果一致

      /*
       * 遍历二维数组的方法
       */
      int i,j;     //i表示行，j表示列
      for(i=0;i<2;i++)
       {
          for(j=0;j<3;j++)
            {
                 printf("%d %d %d\n",i,j,arr2[i][j]);
            }
          printf("\n");
       }


         return 0;
  }

 2、二维数组的部分初始化（在没有赋初值的地方自动补“0”）

方式一：int a[3][4] = {{1},{2},{3}};

只对各行第一列(即序号为0的列)的元素赋初值，其余元素值自动为0，赋初值后数组各元素为：

                                  1  0  0  0

                                  2  0  0  0

                                  3  0  0  0

方式二： int a[3][4] = {{1},{0,2},{0,0,5}};

对某行中任意列元素赋初值（只会补充赋初值元素后面的“0”）

                                 1  0  0  0

                                 0  2  0  0

                                 0  0  5  0

方式三:    int a[3][4] = {{1},{0,3,}}; 

对某行中的所有元素赋初值（对没有赋初值的行，整行自动补“0”）

                                1  0  0  0

                                0  3  0  0

                                0  0  0  0

方式四： int a[ ][4] = {{1},{2},{3}};      //二维数组定义时行可以不写，列必须写

 程序示例：

/*
*         二维数组初始化、遍历二维数组
*/
#include <stdio.h>

int main()
  {
       /*
        *      二维数组初始化的几种方式：
        */
       int arr[3][4]  = {{1},{2},{3}};                 //方式一：给每行的第一列赋初值，其余元素自动为零
       int arr1[3][4] = {{1},{0,2},{0,0,5}};           //方式二：对某行中任意元素赋初值
       int arr2[3][4] = {{1},{0,3}};                   //方式三：对某行中的所有元素赋初值（对没有赋初值的行，整行自动补“0”）
       int arr3[ ][4] = {{},{},{}};                    //方式四：二维数组定义时行可以不写，列必须写


       for(int i=0;i<3;i++)
        {
               for(int j=0;j<4;j++)
                {
                       printf("%d ",arr3[i][j]);
                }
               printf("\n");
        }
         return 0;
  }

题目：有一个3x4的矩阵，要求编程序求出其中值最大的那个元素的值，以及其所在的行号及列号

（怎么找最大值）

/*
 *   题目：有一个3x4的矩阵，要求编程序求出其中值最大的那个元素的值，以及其所在的行号及列号
 *
 *   解题思路：先确定一个数，认为他就是最大的，然后一次和别的去比较，比这个数大，他两就交换位置
 */
#include <stdio.h>

int main()
  {
       int i,j;
       int max;     //最大值
       int tmp_i;
       int tmp_j;

       int arr[3][4] = {{0,12,3,56},{13,45,87,28},{1,36,16,54}};
       max = arr[0][0];
       /*遍历所有的元素 */
       for(i=0;i<3;i++)
        {
             for(j=0;j<4;j++)
              {
                  printf("%d \t",arr[i][j]);        //     /t ：水平制表符
              }
             printf("\n");
        }

       /*找到矩阵里面的最大值*/
       for(i=0;i<3;i++)
        {
             for(j=0;j<4;j++)
              {
                   if(arr[i][j] > max)
                    {
                          max = arr[i][j];
                          tmp_i = i;
                          tmp_j = j;
                    }
              }
        }

        printf("第%d行 第%d列  值：%d\n",tmp_i+1,tmp_j+1,max);              //加1是为了更加符合人类的阅读习惯
        return 0;
  }