C语言------数组

最新推荐文章于 2024-05-20 20:08:58 发布
最新推荐文章于 2024-05-20 20:08:58 发布
阅读量377 收藏
点赞数 19
文章标签： c语言 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80863610/article/details/138309734
版权

一维数组

数组的概念

为了能够存放多个相同类型的数组，就有了数组！！

数组是一组相同类型的元素的集合

数组一般分为一维数组和多维数组

数组在创建的时候可以指定数组的大小和数组的元素类型

数组的语法格式：type arr_name ----------

type指定的是数组中存放数据的类型，可以是char、short、int 、float

arr_name指的是数组的名字

[ ]中的常量值是用来指定数组的大小，根据实际需要来定义

数组是不需要取地址的

//type arr_name

//存放20个成绩
    //int math[20];//数组有20个元素，每个元素的类型是Int
    存放字符
    //char ch[5];
    //double arr[6];
    int math[20] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};//完全初始化
    int math[20] = { 1,2,3,4,5,6,7,8,9,10 };
    char ch[5] = { 'a','b','c','d','e'};//不完全初始化，剩下的元素默认初始化为0
    char ch[5] = "abc";
    double arr[6] = {0.0};





int main()
{
    int a = 10;
    char ch = 'w';
    double d = 0.0;

    int arr[10] = { 0 };
    //数组有没有类型
    //数组的类型是什么？
    //数组的元素类型是int 
    //数组arr的类型的类型是--------int[10]
    //int arr1[10]和int arr2[5]数组类型是不一样的
    return 0;





  数组是有下标的，下标是从0开始的，假设有n个元素，那么最后一个元素的下标就是n-1
  当数组为1 2 3 4 5 6
  则对应的下标就是0 1 2 3 4 5    //数组元素的编号


 通过下标找到对应的元素：

 int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    //arr[5]  //通过下标找到对应的元素
    printf("%d", arr[5]);


    return 0;
}
  输出结果是：6 


 查找元素时使用的arr[],,,这里的[]是 下标引用操作符 
    与上方面的int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };截然不同，45行的10是指定数组元素个数的，而47行的5是数组元素的下标




当数组进行初始化的时候，数组的大小可以忽略的，就是arr后面的方括号内可以不用填写数字 。
编译器会根据数组的初始化内容，自动计算数组的元素个数





用循环打印数组中的所有元素：

for循环    
int main()
{
    int arr[] = { 1,2,3,4,5,6,7,8,9,10 };

    int i = 0;
    for (i = 0; i < 10; i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}



while循环   
int main()
{
    int arr[] = { 1,2,3,4,5,6,7,8,9,10 };

    int i = 0;
    while (i < 10)
    {

        printf("%d ", arr[i]);
        i++;
    }


    return 0;
}  



do while循环  
int main()
{
    int arr[] = { 1,2,3,4,5,6,7,8,9,10 };

    int i = 0;
    do
    {
        printf("%d ", arr[i]);
        i++;

    } while (i < 10);


    return 0;
}  



打印自己输入数组的全部内容：
int main()
{
    int arr[] = { 1,2,3,4,5,6,7,8,9,10 };

    int i = 0;
    /*do
    {
        printf("%d ", arr[i]);
        i++;

    } while (i < 10);*/
    for (i = 0; i < 10; i++)
    {
        //输入10个元素放在数组里面，
        scanf_s("%d ", &arr[i]);//arr[i]是整型元素，需要取地址，数组名才是地址
    }
    for (i = 0; i < 10; i++)
    {
        //在打印数组中的元素
        printf("%d ", arr[i]);
    }

一维数组在内存中的存储

int main()
{
    int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
    //打印这是个元素的地址
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        /*printf("%d\n", arr[i]);*/ //现在不是打印数组的元素，而是所有数组的地址
        printf("&arr[%d]=%p\n", i,&arr[i]);//在上方数字的基础上添加&---取地址
        //地址要用%p来打印,i对应的是%d   ,

    }
    return 0;

    return 0;
}


打印结果：
&arr[0]=0000004275FEF8A0
&arr[1]=0000004275FEF8A4
&arr[2]=0000004275FEF8A8
&arr[3]=0000004275FEF8AC
&arr[4]=0000004275FEF8B0
&arr[5]=0000004275FEF8B4
&arr[6]=0000004275FEF8B8
&arr[7]=0000004275FEF8BC
&arr[8]=0000004275FEF8C0
&arr[9]=0000004275FEF8C4


地址过于长，因为我们的配置是x64的环境
在64位的环境中地址是64bit位的，就比较长 
为了观察方便，将配置环境该成x86的环境，就是32位的环境

 调试后的结果：
&arr[0]=0081F984
&arr[1]=0081F988
&arr[2]=0081F98C
&arr[3]=0081F990
&arr[4]=0081F994
&arr[5]=0081F998
&arr[6]=0081F99C
&arr[7]=0081F9A0
&arr[8]=0081F9A4
&arr[9]=0081F9A8 
这里显示的地址是16进制的



十进制的数字：0 1 2 3 4 5 6 7 8 9
十六进制的数字：0 1 2 3 4 5 6 7 8 9 10-a 11-b 12-c 13-d 14-e 15-f
十六进制中，逢十六进一，，，，，6c+4  个位上的c+4等用于12+4=16，满16进一，1+6=7，所以6c+4=70
所以上述的数组的地址都只相隔4

1个int类型的字节占4个字节



得出结论：
1.数组在内存中是连续存放的
2.随着数组下标的增长，地址也是由小（低）到大（高）变化

sizeof计算数组元素的个数

int main()
{
    int a = 0;
    int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
    printf("%d\n", sizeof(arr));//计算变量的长度，单位是字节

    return 0;
}


输出结果是：
40

10个6元素都是int ,每个int的长度都是4，所以数组的长度为4*10=40

计算的是数组所占内存空间的总大小，单位是字节

int main()
{
    int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
    int a = sizeof(arr) / sizeof(arr[0]);
    printf("%d", a);

    return 0;
        ;
}


sizeof(arr)是整个数组的长度
sizeof(arr[0])是单个元素的长度，每个元素的长度都相等，两个相除就可以得到数组里面元素的个数了





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("%d", arr[i]);
    }

    return
在第24行直接令i<sz

二维数组

数组的创建

概念

将一维数组作为数组的元素，就是二维数组

将二维数组作为数组的元素，就是三维数组

二维数组以上的被称为多维数组

type name[行][列]
数组名字根据自己需求定义
float score[5][30]// 5个班，每个班30人的分数，都为小数

二维数组的初始化

int date[3][5] = {1,2,3,4,5,6,7,8};//不完全初始化
int date[3][5] = {0};//不完全初始化
int date[3][5] = {1,2,3,4,5, 2，3,4,5,6， 3,4,5,6,7};//完全初始化

我们希望1，2放在第一行，3,4放在第二行，5,6,放在第三行，应该如何做？
int date[3][5] = {1,2,3,4,5,6};
改变如下：
int date[3][5] = {{1,2},{3,4},{5,6}};
因为二维数组里面的元素是一维数组


二维数组在初始化的时候行可以省略，列不能省略
int date[][5] = {{1,2},{3,4},{5,6}};

二位数组的使用

数组名是地址

c语言默认行和列默认从0开始的

int arr[3][5] = {1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7};
printf("%d\n",arr[1][2]);
输出结果为4
printf("%d\n",arr[1][2]);
输出结果为7



int main()
{
    int arr[3][5] = { 0 };
    int i = 0;

    //输入
    for (i = 0; i < 3; i++)
    {
        int j = 0;
        for (j = 0; j < 5; j++)
        {
            scanf_s("%d", &arr[i][j]);
        }
    }
    //输出
    for (i = 0; i < 3; i++)
    {
        int j = 0;
        for (j = 0; j < 5; j++)
        {
            printf("%d", arr[i][j]);
        }
        printf("\n");
    }
    return 0;
}

二维数组在内存中的存储

二维数组行可以省略

二维数组的位置

int main()
{
    int arr[3][5] = { 0 };
    int i = 0;
    for (i = 0; i < 3; i++)
    {
        int j = 0;
        for (j = 0; j < 5; j++)
        {

            printf("&arr[%d][%d]= %p\n",i,j ,&arr[i][j]);
        }
    }




    return 0;
}






int main()
{
    int arr[3][5] = { 1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7 };
    //1 2 3 4 5
    //2 3 4 5 6
    //3 4 5 6 7 
    int i = 0;
    for (i = 0; i < 5; i++)
    {
        int j = 0;
        for (j = 0; j < 3; j++)//将行和列置换过来
        {
            printf("%d", arr[j][i]);
        }
        printf("\n");
    }

    return 0;
}


输出结果是：
123
234
345
456
567


变长数组：

在vs2020无法使用，但是在devc++可以使用
int main()
{
    int n = 0;
    int arr[n];
    int i = 0;
    for (i = 0; i < n; i++)
    {
        scanf("%d", &arr[i]);
    }
    for (i = 0; i < n; i++)
    {
        printf("%d", arr[i]);
    }


    return 0;
}


int main()
{
    int n = 0;
    int arr[n];
    int i = 0;
    scanf("%d", &n);
    for (i = 0; i < n; i++)
    {
        arr[i]=6;
    }
    for (i = 0; i < n; i++)
    {
        printf("%d", arr[i]);
    }


    return 0;
}




变长数组不能初始化，好处就是程序员可以为数组分配一个精确的长度

变长数组的意思就是：数组的大小可以使用变量来指定的

数组训练

#include <string.h>//一定要添加的头文件，对于stelen 
#include <stdio.h>
int main()
{
    //char arr[] = "abc";
    //a b c \0
    //0 1 2 3对应的下标，最右边的结尾c所对应的下标应该-1
    char arr1[] = "hello bit!!!!!!";
    char arr2[] = "###############";
    int left = 0;

    int right = strlen(arr1) - 1;//看5、6、7行理解为什么这么写
     //数组的最右边应该从arr1数组的长度减一开始算
    while (left<=right)//循环停止的条件
    {
        arr2[left] = arr1[left];    // arr2的左边等于arr1的左边
        arr2[right] = arr1[right];  // arr2的右边等于arr1的右边
        printf("%s\n", arr2);    // 再将改变后的arr2打印出来
        left++;                   //left依次向右边走
        right--;                  right依次向左边走
    }

    return 0;
}





若是想看到动态变化效果，改动如下：
添加睡眠时间1000毫秒，在44行
#include <stdio.h>
#include <string.h>
#include <wiindows.h>
int main()
{
    char arr1[] = "hello bit!!!!!!";
    char arr2[] = "###############";
    int left = 0;

    int right = strlen(arr1) - 1;
    while (left<=right)//循环停止的条件
    {
        arr2[left] = arr1[left];    // arr2的左边等于arr1的左边
        arr2[right] = arr1[right];  // arr2的右边等于arr1的右边
        printf("%s\n", arr2);    // 再将改变后的arr2打印出来
        Sleep(1000);//1000的单位是毫秒，休眠1000毫秒
        left++;                   //left依次向右边走
        right--;                  //right依次向左边走


    }

    return 0;
}

引用Sleep()需要引用头文件#include <windows.h>


在47行后面添加这么一串代码去//执行系统命令清理屏幕，使出现的代码只出现在第一行，清理控制台平屏幕的信息      
system("cls");





改动如下：
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <wiindows.h>
int main()
{
    char arr1[] = "hello bit!!!!!!";
    char arr2[] = "###############";
    int left = 0;

    int right = strlen(arr1) - 1;
    while (left<=right)//循环停止的条件
    {
        arr2[left] = arr1[left];    // arr2的左边等于arr1的左边
        arr2[right] = arr1[right];  // arr2的右边等于arr1的右边
        printf("%s\n", arr2);    // 再将改变后的arr2打印出来
        Sleep(1000);//1000的单位是毫秒，休眠1000毫秒
        system("cls");//执行系统命令清理屏幕
        left++;                   //left依次向右边走
        right--;                  //right依次向左边走


    }

    return 0;
}

注意###//system()使用的话需要引用头文件：
  #include <stdlib.h>


但是最后一次代码也被清除了
所以我们仍需做出改动：
int main()
{
    char arr1[] = "hello bit!!!!!!";
    char arr2[] = "###############";
    int left = 0;

    int right = strlen(arr1) - 1;
    while (left<=right)//循环停止的条件
    {
        arr2[left] = arr1[left];    // arr2的左边等于arr1的左边
        arr2[right] = arr1[right];  // arr2的右边等于arr1的右边
        printf("%s\n", arr2);    // 再将改变后的arr2打印出来
        Sleep(1000);//1000的单位是毫秒，休眠1000毫秒
        system("cls");//执行系统命令清理屏幕
        left++;                   //left依次向右边走
        right--;                  //right依次向左边走                  
    }
    printf("%s\n", arr2);
    return 0;
}
在循环的结束末尾再次打印就好了
system("cls");这个代码仅仅只是清理屏幕，但是数组内的内容还在
因为数组里面的内容还在，再将内容打印一遍就出现最后的结果了

折半查找也叫二分查找
查找的前提条件是数据是有序的

通过下标选择中间元素

一次二分查找如下
int main()
{
    int arr[] = { 1,2,3,4,5,6,7,8,9,10 };//输入一个数组
    int k = 0;     //定义一个变量
    scanf_s("%d", &k);//输入要查找的值，假设是7
    int sz = sizeof(arr) / sizeof(arr[0]);    //得到数组的长度
    int left = 0;   // 左端下标
    int right = sz-1;//左右下标确定，因为是从0开始的，所以右端下标要-1
    while (left<=right)//当left<=right时，应该就同时指向同一个数//此处为循环的的条件
    {
        int mid = (left + right) / 2;    //下标的中间值
        if (arr[mid] < k)//如果中间值对应的数小于想要查找的值，就从下标mid+1的后面开始寻找
        {
            left = mid + 1;
        }
        else if (arr[mid] > k)
        {
            right = mid - 1;//如果下标是中间值所对应的数字大于要寻找的数字，那么下标右边的数字可以不用看了，直接从中间值左边的那一个下标所对应的数字看起，左边的那个数字为新的right
        }
        else
        {
            printf("找到了，下标是%d\n", mid);
            break;  //找到了就break跳出循环
        }
    }
    if (left > right)
    {
        printf("找不到\n");
    }
    return 0;
}

如果left<=right一直满足，程序就会一直循环，直到找到你输入的值



思考：此处的while()里面的括号内能放1吗？
因为找不到就死循环了，找不到不会break




第二种写法：定义flag//定义flag为0，就是没找到，但是 如果找到了就定义flag成1，没找到依然为0
int main()
{
    int flag = 0;//假设找不到为0
    int arr[] = { 1,2,3,4,5,6,7,8,9,10 };//输入一个数组
    int k = 0;     //定义一个变量
    scanf_s("%d", &k);//输入要查找的值，假设是7
    int sz = sizeof(arr) / sizeof(arr[0]);    //得到数组的长度
    int left = 0;   // 左端下标
    int right = sz-1;//左右下标确定，因为是从0开始的，所以右端下标要-1
    while (left<=right)//当left<=right时，应该就同时指向同一个数//此处为循环的的条件
    {
        int mid = (left + right) / 2;    //下标的中间值
        if (arr[mid] < k)//如果中间值对应的数小于想要查找的值，就从下标mid+1的后面开始寻找
        {
            left = mid + 1;
        }
        else if (arr[mid] > k)
        {
            right = mid - 1;//如果下标是中间值所对应的数字大于要寻找的数字，那么下标右边的数字可以不用看了，直接从中间值左边的那一个下标所对应的数字看起，左边的那个数字为新的right
        }
        else
        {
            printf("找到了，下标是%d\n", mid);
            flag = 1;  //找到就为1
            break;  //找到了就break跳出循环
        }
    }
    if (flag == 0)//如果变为0，就是没找到
    {
        printf("找不到");
    }

    return 0;
}


为什么这里写的是sizeof，而不是strlen,因为strlen是求字符串长度的，而这里的arr被int定义为整型，strlen只能针对字符串或者字符数组


用(left + right) / 2去求平均值存在问题，那么如何求两个较大的数的平均值呢？
假设现在有两个数a和b，现在a>b，去求平均值，将a>b的那部分减下来，然后除以二，给b一部分，给a一部分，现在a=b现在a和b的值就是他们原先值的平均值，以后求平均值可以这么写
int num = a+(b-a)/2
凯子坚持 c
关注
  • 19
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C语言--数组的创建与使用
WangLongxyd的博客
01-22 8197
数组
C语言-数组
04-05
数组在C语言中可谓是重头戏，在其他的科目中都有重要应用。本PPT即是针对数组的讲解。
c语言 -- 数组
qq_51947882的博客
03-30 1万+
目录 1.一维数组的创建和初始化 2.一维数组的使用 3.一维数组在内存中的存储 4.二维数组的创建和初始化 5.二维数组的使用 6.二维数组在内存中的存储 7.数组作为函数参数 1.一维数组的创建和初始化 2.一维数组的使用 3.一维数组在内存中的存储 4.二维数组的创建和初始化 5.二维数组的使用 6.二维数组在内存中的存储 7.数组作为函数参数 ...
c语言---数组
weixin_51912875的博客
01-17 7584
数组
C语言-运算 循环 数组
weixin_74346443的博客
11-05 1753
运算 循环
C语言--数组
m0_64035128的博客
08-23 204
数组
c语言-柔性数组
pyc68的博客
01-23 1264
本篇文章介绍c语言中的柔性数组。
C语言-数组（详细版）
qq_58662017的博客
06-13 1672
数组是由一组数据类型相同的元素组成的集合当我们声明了数组之后，我们的编译器会根据信息正确地创建数组引用数组可以存储大量元素，便于定义很多个变量，并给它一次性初始化（赋值），我们的一维数组可以模拟直线（线性表），二维数组可以模拟一个平面，而三维数组模拟是立体，而多维数组可以模拟我们看不到的事物，数组还有个局限性数组，数组下标是个固定值只能人为去设定一个值。
C语言-数组练习题（附答案）
热门推荐
weixin_57007253的博客
02-05 2万+
目录 1.输入10名学生的成绩，计算总分和平均分，输出平均分。 2.输入10个学生的成绩，输出高于平均分的学生成绩。 3.打印图片 4.杨辉三角 5.输入一个以回车符为结束标志的字符串（少于10个字符），提取其中的所有数字字符,将其转换为一个十进制整数,再将十进制整数转化为二进制数输出。 6.判断回文 7.输入3个字符串，要求找出其中最大的。 8.编一个程序，将两个字符串连接起来，不用strcat函数。 9.编写一个程序，将字符数组S2中的全部字符复制到字符数组S1中。不用str...
C语言--指针详解
01-27
C语言里，变量存放在内存中，而内存其实就是一组有序字节组成的数组，每个字节有唯一的内存地址。CPU 通过内存寻址对存储在内存中的某个指定数据对象的地址进行定位。这里，数据对象是指存储在内存中的一个指定数据...
C语言-数组篇详细解读
01-02
C语言-----数组篇详细解读
C语言-数组及测试代码
08-04
C语言-数组及测试代码
C语言-数组部分课件
05-26
C语言-数组部分课件，需要可下载！！！！！！！！！！
C语言——模拟实现库函数atoi
2302_80250536的博客
05-13 404
INT_MAX 和 INT_MIN 是 C语言 的两个预定义宏，代表了整型变量能够存储的最大正整数21474836472^31 − 1）和最小负整数-2^31这个值是相对于二进制补码表示的，也就是说，负数的范围比正数大 1,这两个宏在头文件中定义。
C语言：设计循环队列
Another_Shi的博客
05-18 764
本篇博客是写完LeetCode_662.设计循环队列之后有感而发，于是写下了一些思路和总结。本题用了两种方法来解答——顺序表和链表。
【算法】二分算法——x的平方根
2302_79031646的博客
05-17 783
用二分边界算法来求解——x的平方根，从暴力求解到二分的优化细说
力扣62 不同路径 Java版本
最新发布
m0_47066863的博客
05-20 185
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。从左上角开始，总共有 3 条路径可以到达右下角。题目数据保证答案小于等于 2 * 109。输入：m = 3, n = 7。输入：m = 3, n = 2。输入：m = 7, n = 3。输入：m = 3, n = 3。问总共有多少条不同的路径？
数据结构c语言-顺序栈
10-05
在C语言中，顺序栈的存储结构可以使用一个一维数组来存放栈中的元素，同时使用一个指示器top来指示栈顶的位置。在进行进栈和出栈操作时，需要更新top的值，使其指向栈顶元素。 下面是一种常见的顺序栈的定义和基本...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值