返回
多御浏览器
广告
多御浏览器
广告

数组

发布时间：2023-01-05 10:23:42 378
相关标签： # 数据

一维数组

  • 一维数组的创建
  • 一维数组的初始化
  • 一维数组的使用
  • 一维数组在内存中的存储

二维数组

  • 二维数组的创建
  • 二维数组的初始化
  • 二维数组的使用
  • 二维数组在内存中的存储

数组作为函数参数

  • ​数组名
  • 冒泡排序函数​

一维数组

一维数组的创建

数组是一组相同类型元素的集合。数组的创建方式：

type_t  arr_name[const_n];
//type_t 数组的元素类型
//arr_name 数组名
//const_n  常量表达式，数组的大小

例1：创建一个整型10元素数组

int arr[10];

错误示例：错误原因是count是变量，数组大小[ ]须使用常量

int count = 10;
int arr2[count];

一维数组的初始化

初始化是指，创建数组的同时给数组赋初始值。

例1：不完全初始化，剩下的元素默认初始化为零

int arr[10] = {1, 2, 3};//1 2 3 0 0 0 0 0 0 0 
char arr2[5] = {'a', 'b'};//'a' 'b' 0 0 0
char arr3[5] = {'a', 98};//'a' 'b' 0 0 0 等价于上一行代码
char arr4[5] = "ab";//'a' 'b' '\0' 0 0
char arr5[] = "abcdef";//'a' 'b' 'c' 'd' 'e' 'f' '\0'

例2（易错）：sizeof和strlen的区别

#include 
int main
{
    char arr[] = "abcdef";
    printf("%d\n", sizeof(arr));
    printf("%d\n", strlen(arr));
    return 0;
}

sizeof

  • 是操作符。
  • 计算arr所占空间的大小（单位：字节）。
  • 7个元素（包含末尾\0）×1字节=7字节

strlen

  • 是库函数，使用得引用头文件。
  • 求字符串的长度，在\0之前停止计数。注意只能是字符串。
  • 答案为6

进一步对比练习：

#include 
int main()
{
    char arr1[] = "abc";
    char arr2[] = {'a', 'b', 'c'};
    printf("%d\n", sizeof(arr1));
    printf("%d\n", sizeof(arr2));
    printf("%d\n", strlen(arr1));
    printf("%d\n", strlen(arr2));
}
//输出结果为：4 3 3 随机值

一维数组的使用

数组名[ ]，即可使用数组。注意数组编号从0开始。

例1：

#include 
int main()
{
    char arr[] = "abcdef";//[a][b][c][d][e][f][\0]
    printf("%c\n", arr[3]);
    return 0;
}
//运行结果为d

例2：

#include 
int main()
{
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
    int sz = sizeof(arr)/sizeof(arr[0]);//数组大小的计算方式
    int i = 0;
    for(i=0; i<sz; i++)
    {
        printf("%d", arr[i]);
    }
    return 0;
}
//运行结果为1 2 3 4 5 6 7 8 9 0

一维数组在内存中的存储

用代码实现：

#include 
int main()
{
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int sz = sizeof(arr)/sizeof(arr[0]);
    int i = 0;
    for(i=0; i<sz; i++)
    {
        printf("&arr[%d] = %p\n", i, &arr[i]);
    }
    return 0;
}

运行结果：

&arr[0] = 001EFAA4
&arr[1] = 001EFAA8
&arr[2] = 001EFAAC
&arr[3] = 001EFAB0
&arr[4] = 001EFAB4
&arr[5] = 001EFAB8
&arr[6] = 001EFABC
&arr[7] = 001EFAC0
&arr[8] = 001EFAC4
&arr[9] = 001EFAC8

不难发现，数组的每个元素都是上一个元素加4。

结论：一维数组在内存中是连续存放的。


二维数组

二维数组的创建

例1:

int arr[3][4];//3行4列
char arr2[3][5];
double arr3[2][4];

二维数组的初始化

例1：第1行按顺序放完，再放第2行。剩下的元素默认初始化为零。

int arr[3][4] = {1,2,3,4,5};
//第1行：1 2 3 4
//第2行：5 0 0 0
//第3行：0 0 0 0
//第4行：0 0 0 0

例2：两个{ }的表示方式

int arr[3][4] = {{1,2,3},{4,5}};
//第1行：1 2 3 0
//第2行：4 5 0 0
//第3行：0 0 0 0
//第4行：0 0 0 0

例3：二维数组初始化不能省略列[ ]中的常量，行[ ]中常量可以省略

int arr[][] = {{1,2,3,4},{5,6,7,8}};//错误
int arr[2][] = {{1,2,3,4},{5,6,7,8}};//错误
int arr[][4] = {{1,2,3,4},{5,6,7,8}};//正确，等价于下一行代码
int arr[2][4] = {{1,2,3,4},{5,6,7,8}};//正确

二维数组的使用

数组名[ ][ ]，即可使用数组。注意数组编号从0开始。

例1：

#include 
int main()
{
    int arr[3][4] = {{1,2,3},{4,5}};
    int i = 0;
    for(i=0; i<3; i++)
    {
        int j = 0;
        for(j=0; j<4; j++)
        {
            printf("%d", arr[i][j]);
        }
        printf("\n")
    }
    return 0;
}
//运行结果：
//1 2 3 0
//4 5 0 0
//0 0 0 0

二维数组在内存中的存储

用代码实现：

#include 
int main()
{
    int arr[3][4] = {{1,2,3},{4,5}};
    int i = 0;
    for(i=0; i<3; i++)
    {
        int j = 0;
        for(j=0; j<4; j++)
        {
            printf("&arr[%d][%d] = %p\n", i, j, arr[i][j]);
        }
    }
    return 0;
}

运行结果：

&arr[0][0] = 0016F724
&arr[0][1] = 0016F728
&arr[0][2] = 0016F72C
&arr[0][3] = 0016F730
&arr[1][0] = 0016F734
&arr[1][1] = 0016F738
&arr[1][2] = 0016F73C
&arr[1][3] = 0016F740
&arr[2][0] = 0016F744
&arr[2][1] = 0016F748
&arr[2][2] = 0016F74C
&arr[2][3] = 0016F750

不难发现，数组的每个元素都是上一个元素加4。

结论：二维数组在内存中也是连续存放的，先存完第1行，再存第2行，以此类推。

进而得到一维数组和二维数组之间的联系：

int arr[3][4]

arr[0]取的就是arr的第1行
arr[1]取的就是arr的第2行
arr[2]取的就是arr的第3行

数组作为函数参数

数组名

易混淆：

#include 
int main()
{
    int arr[] = {1,2,3,4,5,6,7};
    printf("%p\n", arr);
    printf("%p\n", &arr[0]);
    printf("%d\n", *arr);
    return 0;
}
//输出结果：
//0076FAE0
//0076FAE0
//1

结论：数组名是数组首元素的地址（有两个例外）。

例外1：sizeof(数组名)，此时数组名表示整个数组，sizeof(数组名)计算的是整个数组的大小（单位：字节）。

例外2：&数组名，此时数组名表示整个数组，&数组名取出的是整个数组的地址。注意，数组的地址表面上也是数组首元素的地址，但​​&arr+1​​​输出值和​​&arr​​相比增加了1C，即28（7个元素×4字节）。

#include 
int main()
{
    int arr[] = {1,2,3,4,5,6,7};
    printf("%p\n", arr);
    printf("%p\n", arr+1);
    
    printf("%p\n", &arr[0]);
    printf("%p\n", &arr[0]+1);
    
    printf("%d\n", &arr);
    printf("%d\n", &arr+1);
    return 0;
}
//输出结果：
//00D3F900
//00D3F904
//00D3F900
//00D3F904
//00D3F900
//00D3F91C


冒泡排序函数

冒泡次数=总元素个数-1

#include 
//冒泡排序升序
void bubble_sort(int arr[])
{
    //确定冒泡排序的趟数
    int i = 0;
    int sz = sizeof(arr) / sizeof(arr[0]);//总元素个数
    for(i=0; i<sz-1; i++)//冒泡次数=总元素个数-1
    {
        //每一趟冒泡排序
        int j = 0;
        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;
            }
        }
    }   
}

int main()
{
    int arr[] = {9,8,7,6,5,4,3,2,1,0};
    int i = 0;
    int sz = sizeof(arr) / sizeof(arr[0]);
    //对arr进行升序排序
    bubble_sort(arr);//冒泡排序函数
    for(i=0; i<sz; i++)
    {
        printf("%d", arr[i]);
    }
    return 0;
}

上述代码是错误的。

原因在于arr是数组，数组传参时传递过去的并不是数组本身，而是arr首元素的地址，即​​&arr[0]​​。那么，在函数bubble_sort中，sz的值恒为1，导致无法进入冒泡排序的for循环。

改进方法：令sz为函数的输入值，即在外部进行sz的运算，代码如下

#include 
//冒泡排序升序
void bubble_sort(int arr[], int sz)
{
    //确定冒泡排序的趟数
    int i = 0;
    for(i=0; i<sz-1; i++)//冒泡次数=总元素个数-1
    {
        //每一趟冒泡排序
        int j = 0;
        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;
            }
        }
    }   
}

int main()
{
    int arr[] = {9,8,7,6,5,4,3,2,1,0};
    int i = 0;
    int sz = sizeof(arr) / sizeof(arr[0]);
    //对arr进行升序排序
    bubble_sort(arr, sz);//冒泡排序函数
    for(i=0; i<sz; i++)
    {
        printf("%d", arr[i]);
    }
    return 0;
}

上述代码虽然正确，但仍有优化的空间。实际上，一旦出现一整趟都不交换，就说明冒泡排序完成了。

优化代码：在冒泡函数中加入一个判断项

#include 
//冒泡排序升序
void bubble_sort(int arr[], int sz)
{
    //确定冒泡排序的趟数
    int i = 0;
    for(i=0; i<sz-1; i++)//冒泡次数=总元素个数-1
    {
        int flag = 1;//假设这一趟要排序的数据已经有序
        //每一趟冒泡排序
        int j = 0;
        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;
                flag = 0;//本趟排序的数据不完全有序
            }
        }
        if(flag == 1)
        {
            break;
        }
    }   
}

int main()
{
    int arr[] = {9,8,7,6,5,4,3,2,1,0};
    int i = 0;
    int sz = sizeof(arr) / sizeof(arr[0]);
    //对arr进行升序排序
    bubble_sort(arr, sz);//冒泡排序函数
    for(i=0; i<sz; i++)
    {
        printf("%d", arr[i]);
    }
    return 0;
}

注意：break语句只能用于循环语句（for和switch）或开关，在if语句中不能使用。


文章来源： https://blog.51cto.com/u_15883132/5987011
特别声明：以上内容（图片及文字）均为互联网收集或者用户上传发布，本站仅提供信息存储服务！如有侵权或有涉及法律问题请联系我们。
举报
评论区(0)
按点赞数排序
用户头像
精选文章
thumb 中国研究员首次曝光美国国安局顶级后门—“方程式组织”
thumb 俄乌线上战争，网络攻击弥漫着数字硝烟
thumb 从网络安全角度了解俄罗斯入侵乌克兰的相关事件时间线
下一篇
扫雷 2023-01-05 09:44:37