DAY6 C基础-数组；一维字符数组

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

 

一、数组

数组可以连续存储多个同一类型的数据。

【1】定义

存储类型 数据类型 数组名[数组长度];

int  arr[40];         //定义了一个能存40个整形数据的数组

【2】初始化和赋值

数组只能再定义的时候进行整体初始化，定义结束之后，不能给数组中元素整体赋值

#include <stdio.h>
int main(int argc, const char *argv[])
{
    int arr[3];  //能存3个整形数据的数组arr，数组中的元素是随机值
    int arr1[4]={12,56,90,1};   //定义了一个整形数组arr1，能存4个整形数据，并完全初始化
    int arr2[4]={12,6}; //定义了一个能存4个数据的整型数组，不完全初始化，未初始化的部分都是0
    int arr3[4]={0};  //定义了一个整形数组能存4个整形数据，全部初始化为0
 int arr4[] = {12,56,90}; 
 //定义了一个整形数组arr4，没有指定长度，系统会根据初始化列标给数组分配空间
 //arr4长度是3
 int arr5[] = {};  //数组的长度为0
    

 //arr={100};  error，数组只能在定义的时候，进行整体初始化


    //访问数组中的元素，通过元素的下标
    //数组中元素的下标从0开始
    printf("arr1[0]=%d\n",arr1[0]); //12
    printf("arr1[1]=%d\n",arr1[1]); //56
    printf("arr1[2]=%d\n",arr1[2]); //90
    printf("arr1[3]=%d\n",arr1[3]); //1
 arr3[2]=100;   //给arr3中下标为2的元素赋值为100
    return 0;
}

【3】数组中元素的访问

通过下标访问数组中元素，元素的下标从0开始

数组中元素的最大下标=长度-1;

[ ]的两种用法：

  1. 在定义数组的时候，表示是一个数组
  2. 在访问数组中元素的时候，表示元素下标

练习：

1、定义一个整型数组，完成数组中元素的循环输入输出。

2、验证数组中元素的地址连续。

#include <stdio.h>
#define N 5
int main(int argc, const char *argv[])
{
 
    int arr[N],i;   


    //循环变量i需要从0开始
    //终端输入
    for(i=0;i<N;i++)
    {
        scanf("%d",&arr[i]);
    }

    //输出
    for(i=0;i<N;i++)
    {
        printf("arr[%d]=%d\n",i,arr[i]);
    }
 for(i=0;i<N;i++)
    {
        printf("arr[%d]=%p\n",i,arr[i]);
    }

    return 0;
}

【4】数组的大小和长度

int arr[4];

sizeof(arr);         求出的是数组所占内存空间的大小

sizeof(int)          长度

int len = sizeof(arr)/sizeof(int);    数组的长度，用数组的大小/单个元素的大小

数组的大小 = 单个元素的大小 * 长度

【5】数组的长度

可以使用变量定义数组的长度，但是不论变量如何修改，数组长度都不变

并且，使用变量定义数组长度时，数组不能初始化。

#include <stdio.h>
 
int main(int argc, const char *argv[])
{
    int n = 9; 
    int arr[n],i;   //虽然使用变量n定义数组的长度，使用变量定义数组的长度定义时不能初始化
    //但是arr仍然是一个定长数组.
    int len = sizeof(arr)/sizeof(int);  //求数组长度
    printf("数组的长度为%d\n",len);
    return 0;
}

练习：

1、使用数组实现斐波那契的前10项

#include <stdio.h>
int main(int argc, const char *argv[])
{
    int arr[10]={1,1};  //定义了一个长度为10的整型数组，前两个元素为1，后面的元素都是0
    int i,len=sizeof(arr)/sizeof(arr[0]);  //求数组的长度
    //斐波那契数列的赋值
    for(i=2;i<len;i++)
    {
        arr[i]=arr[i-1]+arr[i-2];
    }
    
    //输出
    for(i=0;i<len;i++)
    {
        printf("arr[%d]=%d\n",i,arr[i]);
    }
    return 0;
}

2、定义数组arr和brr，终端输入arr中的数据，把arr中偶数下标的元素乘2，赋给brr中对应的元素，把arr中奇数下标的元素加一，赋给brr中对应的元素。arr和brr长度为10

#include <stdio.h>
#define LEN 10
int main(int argc, const char *argv[])
{
    int arr[LEN],brr[LEN],i;
    for(i=0;i<LEN;i++)
    {
        scanf("%d",&arr[i]);
    }

    printf("**********************\n");
    //赋值
    for(i=0;i<LEN;i++)
    {
        if(i%2==0)
        {
            brr[i]=arr[i]*2;
        }
        else
        {
            brr[i]=arr[i]+1;
        }
    }
    //打印
    for(i=0;i<LEN;i++)
    {
        printf("%d\n",brr[i]);
    }
    return 0;
}

3、有数组int arr[]={12,89,100,101,32,76,98}；写一个程序，求出数组中元素的最大值及其下标。

#include <stdio.h>
int main(int argc, const char *argv[])
{
    int arr[]={12,89,100,101,32,76,98};
    int len = sizeof(arr)/sizeof(arr[0]);  //求数组长度
    int i,max_index=0;  //定义循环变量i和最大值下标
    //假定最大值的下标是0
    
    for(i=1;i<len;i++)  //循环遍历数组中的每一个元素
    {
        //通过最大值下标取到最大值，再进行比较
        if(arr[i]>arr[max_index])
        {
        //如果数组中元素，比假定的最大值还大，就更新最大值下标
        max_index = i;
        }
    }

    printf("%d\n",i);  //7
    printf("最大值下标为%d\t最大值为%d\n",max_index,arr[max_index]);
    return 0;
}

求数组中元素的最大值

#include <stdio.h>
int main(int argc, const char *argv[])
{
    int arr[]={301,89,100,101,32,76,200};
    int len = sizeof(arr)/sizeof(arr[0]);  //求数组长度
    int max = arr[0];  //让假定的最大值，是数组中的数
    int i;
    //由于max假定是数组中的第一个元素，所以第一个元素不需要再参与比较了
    for(i=1;i<len;i++)
    {
        //如果数组中元素比假定的最大值还大，就更新最大值
        if(arr[i]>max)
        {
        max = arr[i];
            }
    }
    printf("%d\n",max);
    return 0;
}

4、编写程序，实现数组中元素的逆置。

 1、

#include <stdio.h>
int main(int argc, const char *argv[])
{
    int arr[]={301,89,100,101,32,76,200};
    int len = sizeof(arr)/sizeof(arr[0]),i,temp;
    //循环逆置
    for(i=0;i<len/2;i++)
    {
     //三杯水交换
    temp = arr[i];
    arr[i]=arr[len-1-i];
    arr[len-1-i]=temp;
    }

    //打印输出
    for(i=0;i<len;i++)
    {
        printf("%d\n",arr[i]);
    }
    return 0;
}

 2、

#include <stdio.h>
int main(int argc, const char *argv[])
{
    int arr[]={301,89,100,101,32,76,200};
    int len = sizeof(arr)/sizeof(arr[0]);
    int i,j,temp;
    //两个下标，分别指向第一个元素和最后一个元素
    //指后面的每次向前移动，指前面的每次向后移动
    for(i=0,j=len-1;j>i;i++,j--)
    {
        temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    //打印输出
    for(i=0;i<len;i++)
    {
        printf("%d\n",arr[i]);
    }

    return 0;
}

【6】冒泡排序

相邻的两个元素之间两两比较并且交换，每一次都会比较一个最大的数放在后面。

 

//升序
#include <stdio.h>
int main(int argc, const char *argv[])
{
    int arr[]={301,89,100,101,32,76,200};
    int len=sizeof(arr)/sizeof(arr[0]),temp,i,j;
    //外层循环控制排序趟数
    for(i=1;i<len;i++)
    {
        //控制的是比较的次数
        for(j=0;j<len-i;j++)  //for(j=0;j<=len-1-i;j++)
        {
            if(arr[j]>arr[j+1])
            {
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
    //打印输出
    for(i=0;i<len;i++)
    {
        printf("%d\n",arr[i]);
    }
    return 0;
}

练习：

1、实现数组元素的降序冒泡排序

#include <stdio.h>
int main(int argc, const char *argv[])
{
    int arr[]={301,89,100,101,32,76,200};
    int len=sizeof(arr)/sizeof(arr[0]),temp,i,j;
    //外层循环控制排序趟数
    for(i=1;i<len;i++)
    {
        //控制的是比较的次数
        for(j=0;j<len-i;j++)  //for(j=0;j<=len-1-i;j++)
        {
            if(arr[j]<arr[j+1])   //决定了排序的结果是升序还是降序
            {
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
    //打印输出
    for(i=0;i<len;i++)
    {
        printf("%d\n",arr[i]);
    }
    return 0;
}

【7】选择排序

每次从待排序序列中，选出最大/最小的数，和待排序序列中的第一个数交换

选择排序，找到下标再交换

#include <stdio.h>
int main(int argc, const char *argv[])
{
    int arr[]={89,100,101,32,76};
    int len = sizeof(arr)/sizeof(arr[0]);
    int min_index,i,j,temp;
    //控制排序的次数
    for(i=1;i<len;i++)
    {
        min_index = i-1;  //假定每次待排序序列中最小元素是待排序序列中的第一个元素
        //选择排序找元素下标，根据下标交换数组中元素
        for(j=i;j<len;j++)  //让j从待排序序列中的第二个元素开始遍历
        //因为min_index已经是待排序序列中的第一个元素
        {
            if(arr[min_index]>arr[j])
            {
                min_index = j;   //找最小值的下标
            }
        }

        //判断找到的最小值是否是第一个元素
        if(min_index!=i-1)
        {
            //三杯水交换
            temp = arr[i-1];
            arr[i-1] = arr[min_index];
            arr[min_index] = temp;
        }
    }
    //打印输出
    for(i=0;i<len;i++)
    {
        printf("%d\n",arr[i]);
    }

    return 0;
}

二、一维字符数组

常用于存储字符串

【1】定义

例如：char arr[4];         //定义了一个能存4个字符类型数据的数组arr

【2】字符数组与字符串相结合

#include <stdio.h>
int main(int argc, const char *argv[])
{
    char arr[4];  //定义了一个能存4个char类型数据的数组arr
    char arr1[4] = {'a','b','c','d'};  //定义了一个能存4个char类型数据的数组arr1并完全初始化
    char arr2[4] = {'a','b'}; //定义了一个能存4个char类型数据的数组arr
    //不完全初始化，未初始化的部分是'\0'
    char str[] = "hello";  //str的大小为6，字符串结尾有一个'\0'
    //'h','e','l','l','o','\0'
    printf("%s\n",str);
    //使用字符串初始化字符数组
    char str1[7] = {'\0'};
    str[3] = 'i';  //给str中下标为3的元素赋值
    printf("%s\n",str);

    //循环遍历字符数组中的每个元素，完成输入输出

    return 0;
}

【3】字符串的输入输出函数

i）gets()

scanf  不能获取带空格的字符串

gets    可以获取带空格的字符串

函数原型：char *gets(char *s);

gets:功能终端输入带空格的字符串

参数:地址

*使用gets会报警告，这是友好的警告，gets不会检查数组越界，不用管这个警告

 

ii）puts()

函数原型：int puts(const char *s);

功能:输出字符串

参数:字符串的地址

#include <stdio.h>
int main(int argc, const char *argv[])
{
    char str[] = "hello";
    printf("%p\n",str);  //数组中首元素的地址
    printf("%p\n",&str[0]);
/******************************************/
   
    puts(str);
    printf("%s\n",str); 
 //%s要一个地址，从该地址开始输出，直到'\0'停止
    str[3] = '\0';
    puts(str);

/******************************************/
   
    gets(str);  //可以获取带空格的字符串
    puts(str);  //终端输出字符串
    printf("%c",'\0');
    return 0;
}

【4】字符串函数族的函数

#include <string.h>

i）strlen

函数原型： size_t strlen(const char *s);

参数是地址

功能：求字符串实际的长度

ii）strcpy

函数原型：char *strcpy(char *dest, const char *src);

dest是目标字符串的地址，src是源字符串的地址

dest也要足够大，容纳src的结果

功能:把src中的内容拷贝到dest中

iii）strcat

函数原型：char *strcat(char *dest, const char *src);

功能：把src拼接到dest后面

要求dest足够大

参数:目标字符串和源字符串的地址

#include <stdio.h>
#include <string.h>
int main(int argc, const char *argv[])
{
    char str[20] = "hello ";
    int len=0,i=0;
    //如果没有走到'\0'就计数，长度++
/*    while(str[i])
    {
        i++;
        len++;
    }
    printf("%d\n",len);*/
    char str1[10]="world";
    strcat(str,str1);
    puts(str);  //hello world
    return 0
}

练习：

1、自己实现strlen的功能。

#include <stdio.h>
int main(int argc, const char *argv[])
{
    char str[20] = "hello";
    int len=0,i=0;
    //如果没有走到'\0'就计数，长度++
    while(str[i])
    {
        i++;
        len++;
    }
    printf("%d\n",len);
    return 0;
}

作业：

1.整理思维导图

 

2.冒泡排序，从后往前交换

 

3.自己实现strcpy和strcat函数功能

 

 

4.认真复习课上内容，包括两数交换

野猪骑士丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言学习第四天-数组
weixin_43943624的博客
01-19 904
C语言学习第四天-数组
C语言基础入门——一维数组，字符数组
浪漫的诗人博客
04-23 1162
引言：某班学生的学习成绩、一行文字、一个矩阵等数据的特点如下:(1）具有相同的数据类型。(2）使用过程中需要保留原始数据。C语言为了方便操作这些数据，提供了一种构造数据类型——数组.所谓数组，是指一组具有相同数据类型的数据的有序集合。类型说明符 数组名 [ 常量表达式 ]；定义了一个整型数组，数组名为a，它有10个元素。初始化字符数组时，一定要让字符数组的大小比看到的字符串的长度多对每个字符的单独赋值进行初始化对整个数组进行初始化：但是。
一维字符数组与字符串
weixin_74014969的博客
11-10 572
一维字符数组与字符串
C语言总结（一维数组、二维数组、字符数组和字符串）
热门推荐
csuft20164442的博客
01-23 12万+
C语言总结第七章、数组一维数组一维数组的定义一维数组的引用一维数组的初始化程序举例二维数组及多维数组二维数组的定义二维数组元素的引用二维数组元素的初始化程序举例字符数组和字符串字符数组 第七章、数组 数组是构造数据类型之一 数组： 有序数据的集合,用数组名标识 元素： 属同一数据类型,用数组名和下标确定 一维数组 一维数组的定义 定义方式： 例： int a[6] 一维数组的引用 1、数组...
c语言一维数组字符串数组初始化,一维数组的定义、初始化和引用
weixin_33765593的博客
05-17 8034
一维数组的定义、初始化和引用一维数组的定义、初始化和引用1.一维数组的定义方式为:类型说明符 数组名［常量表达式］(1)数组名的命名方法与变量名相同，遵循标识符命名规则;(2)数组是用方括号括起来的常量表达式，不能用圆括号;(3)常量表达式表示数组元素的个数，即数组的长度，数组的下标从0开始，下标的最大值为:常量表达式-1;(4)常量表达式中可以包括常量和符号常量，不能包括变量。可以用赋值语句...
C语言-Day6-数组-一维数组/二维数组
羟基与苯的博客
01-19 147
C语言- 数组-一维数组/二维数组 数组的创建 数组初始化 数组的使用 数组的内存方式
day002 JAVA语法基础-数组加强.doc
08-16
1. **统计字符出现的下标和次数**：通过遍历字符数组，记录第一次出现字符的下标，并计算其出现的总次数。 2. **奇偶数之和**：遍历整型数组，根据数值的奇偶性分别累加，得到奇数和与偶数和。 3. **分段统计分数**...
Java基础复习day03数组
12-11
Java基础复习day03数组 Java数组是一种数据类型，引用类型，用于存放一组数据的数据结构。数组的定义、创建、访问、长度属性、遍历、常用Arrays类、二维数组、方法递归调用经典案例、变量源码教程等。 一、数组的...
java语言基础数组向量字符串PPT教案学习.pptx
09-30
- **一维数组**：一维数组就像一列变量，声明格式如`int[] a`或`int a[]`。声明数组并不分配内存，需要使用`new`来创建数组对象，如`a = new int[5];`。数组下标从0开始，数组长度不可变。 - **数组初始化**：数组...
Java-day-4:1.方法2. 3-D数组3.扩展为语句4.参数
05-02
在Java中，3-D数组通常用于表示三维空间中的数据，如图像处理或棋盘游戏。声明和初始化3-D数组的示例如下： ```java int[][][] threeDArray = new int[2][3][4]; ``` 这创建了一个长度为2的“行”数组，每个行数组...
java第四章数组初识排序
12-26
例如，定义一个2x3的二维数组： ```java int[][] multiDimArray = new int[2][3]; ``` 多维数组的遍历和操作相对复杂，需要考虑每一维度的下标。 总结：数组是Java中处理批量数据的基础工具，了解其概念、定义、...
c语言 一维字符型数组
usstmiracle的博客
03-06 8067
什么是一维字符型数组：char a[5];//这个数组中含有5各元素，每个元素都是一个字符型变量如何定义一字符型维数组：格式： char 数组名[长度]; ex: char a[6];定义了一个含有6个字符型变量的数组a。如何来给一维字符型数组赋初值？1）一维字符型数组从“整体上看”就是一个字符串，但是其中的每一个元素还是一个字符2）关于字符串的结束符号\0 A:\0虽然有2个字符，但是\...
CCF GESP Python编程 五级认证真题 2024年6月
No0d1es的博客
07-25 953
hlmFile = open("红楼梦.txt", "r", encoding = "utf-8") sSet = set(shzFile.read())第 1 题 在Python中，print((c for c in "GESP"))的输出是（ ）。C. 执行 print(count_if(range(-100,10),key = lambda x:x > 5)) 将输出 4。第 7 题 在下面的Python代码中，最后一行用于输出小于0的list，横线处不能填入的代码是( )。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 整数数组按个位数字排序(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
07-24 4万+
给定一个包含多个整数的数组，请按照数组元素十进制最低位数字从小到大进行排序。如果最低位数字相同，则相对位置保持不变。对于负数，十进制最低位等同于去除符号位后对应十进制值最低位。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 项目排期安排(200分) - 三语言AC题解(Python/Java/Cpp)
最新发布
清隆学长的博客
07-25 537
项目组共有 $N$ 个开发人员，项目经理接到了 $M$ 个独立的需求。每个需求的工作量不同，且每个需求只能由一个开发人员独立完成，不能多人合作。假定各个需求之间无任何先后依赖关系，设计算法帮助项目经理进行工作安排，使整个项目能用最少的时间交付。
C语言：字符串函数、内存函数剖析
2301_81454749的博客
07-25 1023
本篇文章将会使你对字符串函数，内存函数有更深的理解，快来和小编一起实现这些函数吧！
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 247
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
2.6基本算法之动态规划6045:开餐馆
Andy_SCP001的博客
07-24 266
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
2.6基本算法之动态规划2989:糖果
Andy_SCP001的博客
07-24 454
糖果公司的N件产品每件都包含数量不同的糖果。Dzx希望他选择的产品包含的糖果总数是K的整数倍，这样他才能平均地将糖果分给帮助他维护世界和平的伙伴们。/*边界条件:dp[i][j]初始化为负无穷,int dp[1005][1005];//dp[i][j]:从i种糖果中选,组成糖果总数量k的倍数。dp[0][0]=0;//dp[0][0]边界条件:0种糖果组成糖果总数量0的倍数是0。另外,必须保证所有的状态是由dp[0][0]转移过来的*/除了dp[0][0]为0,因为我们这里求的是最大值,
c语言二维数组strcpy
08-19
- *2* *3* [Day 24 C语言学习 二维字符数组 练习](https://blog.csdn.net/qq_59947178/article/details/126770876)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值