C语言之数组（内含冒泡排序法）

最新推荐文章于 2024-03-06 18:39:06 发布

贰月磐石

最新推荐文章于 2024-03-06 18:39:06 发布

阅读量676

点赞数 12

分类专栏：初学者文章标签： c语言排序算法算法 Powered by 金山文档

本文链接：https://blog.csdn.net/sclwc/article/details/128882530

版权

初学者专栏收录该内容

12 篇文章 2 订阅

订阅专栏

一维数组

一维数组的创建

所谓数组，是指将那些具有相同类型的、数量有限的若干个变量通过有序的方法组织起来的一种便于使用的形式。数组属于一种构造类型，其中的变量被称为数组的元素。数组元素的类型可以是基本数据类型，也可以是特殊类型和构造类型。

简单地说：数组是一组相同类型元素的集合。

数组创建：

 Int arr[10]
//代码1 
int arr1[10]; 
//代码2 
int count = 10; 
int arr2[count];//数组时候可以正常创建？
//代码3 
char arr3[10]; 
float arr4[1]; 
double arr5[20];

注：代码二这种肯定是不允许的，数组创建，在C99标准之前,[] 中要给一个常量才可以,不能使用变量。在C99标准支持了变长数组的概念，数组的大小可以使用变量指定，但是数组不能初始化

数组的初始化

数组的初始化是指，在创建数组的同时给数组的内容一些合理初始值（初始化）。

int arr1[10] = {1,2,3}; 
int arr2[] = {1,2,3,4}; 
int arr3[5] = {1，2，3，4，5}；
char arr4[3] = {'a',98, 'c'}; 
char arr5[] = {'a','b','c'}; 
char arr6[] = "abcdef";

数组在创建的时候如果想不指定数组的确定的大小就得初始化。数组的元素个数根据初始化的内容来确

定。

但是对于下面的代码要区分，内存中如何分配。

 char arr1[] = "abc"; 
char arr2[3] = {'a','b','c'};

像第二种初始化方式，一定要再最后加上一个/0

char arr2[3] = {'a','b','c'，'\0'};

 #include<stdio.h>
 
int main() {
    int arr[9];
    int i;
    for (i = 0; i < 9; i++)
    {
        arr[i] = i + 1;
        printf("arr[%d]=%d\t", i, arr[i]);
        printf("\n");
    }
    return 0;
}

运行结果：

一维数组的使用

#include <stdio.h> 
int main() 
{ 
int arr[10] = {0};//数组的不完全初始化
   //计算数组的元素个数
   int sz = sizeof(arr)/sizeof(arr[0]); 
//对数组内容赋值,数组是使用下标来访问的，下标从0开始。所以：
int i = 0;//做下标
for(i=0; i<10; i++)//这里写10，好不好？
{ 
arr[i] = i; 
} 
//输出数组的内容
for(i=0; i<10; ++i) 
{ 
printf("%d ", arr[i]); 
} 
return 0; 
}

总结:

1. 数组是使用下标来访问的，下标是从0开始。

2. 数组的大小可以通过计算得到。

 int arr[10]; 
int sz = sizeof(arr)/sizeof(arr[0]);

二维数组

二维数组的创建

 //数组创建
intarr[3][4]; 
chararr[3][5]; 
doublearr[2][4];

二维数组的初始化

 //数组初始化
intarr[3][4] = {1,2,3,4}; 
intarr[3][4] = {{1,2},{4,5}}; 
intarr[][4] = {{2,3},{4,5}};//二维数组如果有初始化，行可以省略，列不能省略

二维数组的使用也是通过下标的方式。

看代码：

     #include<stdio.h>
 
     int main() {
   int arr[4][3];
  for (int i = 0; i < 4; i++)
  {
    for (int j = 0; j < 3; j++)
    {
      printf("&arr[%d][%d]=%d\t", i, j, &arr[i][j]);
    }
    printf("\n");
  }
  return 0;
}

将二维数组arr视为一个矩阵，下图显示了数组中每个元素在矩阵中的存放位置。

这里看一个题，更深刻的理解一下二维数组

//二维数组相加

 #include<stdio.h>
#define MAXN 105
int A[MAXN][MAXN];
int B[MAXN][MAXN];
int C[MAXN][MAXN];
 
int  main()
{
     int n,m,i,j,k;
        while(scanf("%d%d",&n,&m)!=EOF)
        {
        for(i=1;i<=n;i++)
        for(j=1;j<=m;j++)
        scanf("%d",&A[i][j]);
 
        for(i=1;i<=n;i++)
        for(j=1;j<=m;j++)
        scanf("%d",&B[i][j]);
 
        for(i=1;i<=n;i++)
        for(j=1;j<=m;j++)
        C[i][j]=A[i][j]+B[i][j];
 
        for(i=1;i<=n;i++)
        {
        for(j=1;j<=m;j++)
        {
            printf("%d ",C[i][j]);
        }
        printf("\n");
 
        }
 
        }
 
        return 0;
        }

数组的下标是有范围限制的。

数组的下规定是从0开始的，如果数组有n个元素，最后一个元素的下标就是n-1。

所以数组的下标如果小于0，或者大于n-1，就是数组越界访问了，超出了数组合法空间的访问。

C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就

是正确的，

所以程序员写代码时，最好自己做越界的检查

 #include <stdio.h> 
int main() 
{ 
int arr[10] = {1,2,3,4,5,6,7,8,9,10}; 
   int i = 0; 
   for(i=0; i<=10; i++) 
  { 
       printf("%d\n", arr[i]);//当i等于10的时候，越界访问了
  } 
return 0; 
}
二维数组的行和列也可能存在越界。

在这个代码中，当i=10的时候，就已经越界了。

千呼万唤始出来，下面开始最详解的C语言冒泡排序法。

冒泡排序

冒泡排序的核心思想是两两相邻的元素进行比较

我们现在是要从小到大排

3 1 5 9 2 4 7 6 8 0

先看前两个数字，3和1，我们的目的是升序排列，3>1，所以让3和1交换一下位置，就变成了

1 3 5 9 2 4 7 6 8 0

再看3和5，3<5,所以他俩位置不变，依旧是

1 3 5 9 2 4 7 6 8 0

接着往后看，5<9，不变

1 3 5 9 2 4 7 6 8 0

接着往后看，9>2,交换位置

1 3 5 2 9 4 7 6 8 0

接着往后看，9>4，互换位置

1 3 5 2 4 9 7 6 8 0

接着往后看，9>7，互换位置

1 3 5 2 4 7 9 6 8 0

接着往后看，9>6，互换位置

1 3 5 2 4 7 6 9 8 0

接着往后看，9>8，互换位置

1 3 5 2 4 7 6 8 9 0

接着往后看，9>0，互换位置、

第一轮互换结束，这一组数字变成了

1 3 5 2 4 7 6 8 0 9

最大的9到了最后一位。

接下来就进行第二轮呗。

一样的道理，先比较前两个数字，1和3，1<3,位置不变，

再比较3和5，3<5，位置不变

再比较5和2，5>2，互换位置

1 3 2 5 4 7 6 8 0 9

再比较5和4，5>4，互换位置

1 3 2 4 5 7 6 8 0 9

再比较5和7，5<7，位置不变

再比较7和6，7>6，互换位置

1 3 2 4 5 6 7 8 0 9

再比较7和8，7<8，位置不变

再比较8和0，8>0，互换位置

1 3 2 4 5 6 7 0 8 9

再比较8和9，8<9，位置不变

第二轮结束，接下来就是第三轮，第四轮........

最后成功排序

注意，我们每一轮冒泡排序，都是将一个数字，放到属于他的位置，所以，给十个数字排序，需要9轮冒泡排序

原理懂了，代码就非常好实现了

#include<stdio.h>
int main()
{
    int arr[10] = {3,1,5,9,2,4,7,6,8,0};
    int sz = sizeof(arr) / sizeof(arr[0]);
    int i = 0;
    int j = 0;
    for (i = 0; i < sz - 1; i++)//冒泡排序的轮数
    {
        for (j = 0; j < sz - 1 - i; j++)//一轮比较的数字组数
        {
            if (arr[j] > arr[j + 1])
            {
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }
    for (i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }

    return 0;
}

有任何不懂得都可以评论区指出

欢迎大家来我的gitee提取更多有趣代码

https://gitee.com/two-moon-rock/first-bloodf.git