C语言中的数组

一维数组

数据类型
数组名[] = { };

在标准C语言环境下,数组大小只能用常量

int array[1000]={};
    for (int i =0 ; i < 1000; i++) {
         printf("%d ", array[i]);
    }
    //打印出来是随机数,只是大部分是0

第一种:直接初始化赋值:

    int array[10]={1,2,3,4};
    for (int i = 0; i < 10; i ++) {
        printf("%d ", array[i]);
    }

运行结果:(后面没定义的都补0,直到达到数组的长度)

1 2 3 4 0 0 0 0 0 0 

直接给所有值赋值0

    int array[10]={0};

第二种:先声明后赋值:

   int array[10];
    //取值:数组名[下标] 下标 :0 - (n - 1)
    //输入数,填满数组
    for (int i = 0; i < 10; i ++) {
        printf("第%d个:", i+1);
        scanf("%d",&array[i]);
    }
    //打印数组
    for (int i = 0; i < 10 ;i ++ ){
        printf("%d ", array[i]);
    }

运行结果:(需要手动输入的,我这里输入了。)

1个:2

2个:1

3个:1

4个:1

5个:23

6个:123

17个:2321

8个:21

9个:12

10个:12

2 1 1 1 23 123 12321 21 12 12 

Program ended with exit code: 0

举例1:找出数组中最大的值

    int array[10]={5,20,15,23,10};
    int max=array[0];
    for (int i =0 ; i < 5 ; i ++) {
        if (max<array[i]) {
            max=array[i];
        }
    }
    printf("%d",max);

运行结果:

23

Program ended with exit code: 0

举例2:初始化一个数组,元素为60 85.5 90 56 100 67,求和以及平均值

因为有小数,就用了float,其中sizeof是我对数组大小的访问,对结果没有任何影响

float array[]={60,85.5,90,56,100,67};
    float sum=0,pi;
    for (int i = 0 ; i < 6 ; i ++) {
        sum+=array[i];
    }
    pi=sum/6;
    printf("%lu\n",sizeof(double));
    printf("%lu\n",sizeof(float));
    printf("%lu\n",sizeof(array));
    printf("sum=%.2f,pi=%.2f", sum,pi);

运行结果:

8

4

24

sum=458.50,pi=76.42

Program ended with exit code: 0

数组的排序

冒泡排序,最简单的排序

    int array[5]={1,10,9,16,2};
    //思路:相邻的两个书比较,从小到大的话,小的排到相邻的那个的前面,一轮一轮的比较,数据比较少的话可以用这种方法
    //第一次:1 9 10 2 16; 比较次数:4
    //第二次:1 9 2 10 16; 比较次数:3
    //第三次:1 2 9 10 16; 比较次数:2
    //第三次:1 2 9 10 16; 比较次数:1
    for (int i = 0 ;  i < 5 ; i ++) {
        for (int j = 0 ; j < 5-i-1 ; j ++) {
            if (array[j] > array[j+1]) {
                //要用j而不是i(相邻的两个数互换)
                int temp = array[j];
                array[j] = array[j+1];
                array[j+1] =  temp;
            }
        }
    }
    for (int i = 0; i < 5; i ++) {
        printf("%d ",array[i]);
    }

运行结果:

1 2 9 10 16 

Program ended with exit code: 0

简便版的选择排序

   for (int i = 0; i< 5; i ++) {
        for (int j = i; j< 5; j ++) {
            if (array[i] > array[j]  ) {
                int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }
               printf("%d ",array[i]);
    }

运行结果:

1 2 9 10 16 

Program ended with exit code: 0

二维数组

二维数组一般这样定义:

<pre name="code" class="objc"> int sz[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};

其中,3和4是可以改变的,3是有多少行,4是有对少列,写成这样可能比较好理解:

 int sz[3][4] = { {1, 2, 3, 4},
<span style="white-space:pre">		</span>  {5, 6, 7, 8},
<span style="white-space:pre">		</span>  {9,10,11,12}};

这里就通过举例来看它吧

同样是找出数组中的最大值

    int array[][4] ={1,2,3,4,5,6,7,8,9};
//    //最好给max赋值就是数组里面的值避免错误
    int max=array[0][0];
    for (int i = 0 ; i < 3; i ++) {
        for (int j = 0; j < 4; j ++) {
            if(max < array[i][j]){
                max = array[i][j];
            }
        }

    }
        printf("max=%d",max);

运行结果:

max=9

Program ended with exit code: 0

上面是一种方式,我们现在用一个循环打印出数组中的值,并得到最大的那个数

    int array[][4] ={1,2,3,4,5,6,7,8,9};
//    //最好给max赋值就是数组里面的值避免错误
    int max=array[0][0];

    //用二维数组用一维数组的方式打印出来,直接把二维转成一维的方式去打印就行了,一行一列打出所有数据
    for(int i =0 ;i<12;i++){
        //变成一维打
        printf("%d  ",array[0][i]);
        if (max<array[0][i]) {
            max=array[0][i];
        }
//        printf("%d ",array[0][0]);

    }
    printf("\n");
   printf("max=%d",max);

运行结果:

1  2  3  4  5  6  7  8  9  0  0  0  

max=9

Program ended with exit code: 0

字符数组

字符数组就是个字符串

可以用几种方式定义:

    char string[] = "hello";
    char string1[6] = {'h','e','l','l','o'};

我们下面举例说明一下:(比较字符串是否相同,就是比较它里面的字符是否相同)

至于string1里面为什么是6呢,因为字符串后面都有一个‘\0‘,要占一个字符,如果小于6的话前面的照样输出,后面的会出现乱码

    char string1[6] = {'h','e','l','l','o'};
    char string3[] = "wrold";
    //max不能接受字符串
    char max;
    for(int i = 0;i < 5 ;i ++){
        if (string1[i]>string3[i]) {
            printf("大");
        }else if(string1[i]<string3[i]){
            printf("小");
        }else{
            printf("中");
        }
    }

运行结果:

小小小中大

Program ended with exit code: 0

在C语言中也有专门的字符串的运算方法

    //strcmp(<#const char *#>, <#const char *#>) 比较大小
    //strcpy(<#char *#>, <#const char *#>) 复制
    //strlen(<#const char *#>) 获取字符串长度
    //strcat(<#char *#>, <#const char *#>) 链接

这里就不一一举例了

时间: 2024-10-02 12:53:47

C语言中的数组的相关文章

《C语言中动态数组的创建及引用》

C语言中动态数组的创建及引用 动态数组是相对于静态数组而言的,静态数组的长度是预定义好的,在整个程序中,一旦给定了数组大小后就无法改变,,而动态数组则不然,它可以根据程序需要重新指定数组的大小.动态数组的内存空间是由堆动态分配的,通过执行代码为其分配储存空间,只有程序执行到分配语句时,才为其分配储存空间. 对于动态数组,其创建比静态数组更麻烦一些,使用完必须由程序员自己释放,否则将引起内存泄漏,但是其使用非常灵活,能根据程序需要动态分配大小,因此相对于静态数组来说,使用动态数组的自由度更大. 对

【示例】C语言中利用数组存放函数指针

C语言中利用数组存放函数指针,增加函数使用的灵活性.使用时只需提供数组索引,即可调用不同函数. 预备知识: 1.指向函数的指针 一个函数在编译时被分配一个入口地址,这个地址就被称为函数的指针. 例如: int max(int,int); // 声明函数,比较两数大小 int (*p)(); //声明指向函数的指针变量 p=max; //将函数max的入口地址赋给指针变量p int c=(*p)(a,b); //调用函数 2.函数指针作为函数参数 该例子中每次给process函数不同实参(函数名)

C语言中字符数组和字符串指针分析

这几天搞Unix上的C程序,里面用到了很多字符数组和字符串指针,我记得在学完C语言后相当一段时间里,对指针这个东西还是模模糊糊,后来工作也没怎么 用到过C,虽然网上这类的文章也有很多,还是决定自己在这做个小总结,也算加深下自己的印象,写了下面的测试程序: #include <stdio.h> int main(int argc, char *argv[]){ char day[15] = "abcdefghijklmn";  char* strTmp = "opq

c语言中的数组名代表的意义

数组名是数组的首地址,就是数组中的第一个元素的地址,是常量.常量是不能值在=的左边的.数组和指针的区别在于,指针是变量,是用来存储指向数据的地址的变量,而数组名是常量.一般情况下申明一个数组,比如char  a[10]; 之后  数组名a都是数组的首地址,是一个地址常量.但是在函数申明的形参列表中除外,比如: int  fo(char []); 在这种情况下的申明与 int  fo(char a[]); int  fo(char *a); 是等价的,就是说在这种情况下,就算你写的是数组的形式,编

Java语言中的----数组

day07  Java语言中的--数组 一.数组的概述: 什么是数组?数组是干什么用的?为啥要学数组?这些都是疑问.再你学完数组以后就知道了,数组是存储在相邻内存位置的单一数据类型的元素集合.什么是单一数据类型?就是在你定义数组的时候的数据类型,就只能存储这一个类型的数组.那么我们访问他的时候就直接通过指定数组的名字和下标就可以直接访问数组元素了. 二.数组: 1.定义数组         数据类型 数组名[] = new  数据类型[内存数据大小]         int a[] = new 

Java语言中学习数组、运算符、流程控制的一些理解

一.数组 1.数组的概念及作用 数组是相同数据类型的元素的集合:   数组本身是引用数据类型,即对象.但是数组可以存储基本数据类型,也可以存储引用数据类型. 例如: int [] a = new int [] {1,2,3,4,5,6,}; String [] s = new String [] {"小兔","小小兔","小小小兔",} : Employee [] e = Employee [10];(Employee是自定义类). 2.数组的声

C语言中的数组调用——混乱的内存管理

在C语言中想要创建数组只能自己malloc或者calloc,数组复制则是memcpy. 这样创建出来的数组在调用时是不会检测数组边界的,即你声明了一个长度为5的数组,却可以访问第6个位置……也可以给第7个位置赋值……不知道这算不算内存泄露,可否通过这种方法偷取内存中的情报呢? 例: int main(){ int *list=(int*)malloc(5*sizeof(int)); for(int i=0;i<5;++i){ list[i]=i; } for(int i=0;i<15;++i)

Go语言中的数组与数组切片

Go中的数组与C的数组一样,只是定义方法不同 c: int a[10][10] Go [10][10]int 定义并初始化 array1 := [5]int{1,2,3,4,5} 变量名 := [index]类型{也可不加} 1.元素访问:1.跟C语言一样通过数组来访问 2.通过关键字range来访问 如:for i,v :=range array{ fmt.Printlb(*Array element[",i,"]=*,v) }第一个表示下标从0到len(array)-1 2.值类型

C语言中对数组名取地址

在C/C++中,数组名相当于一个指针,指向数组的首地址.这里"相当于"不代表等于,数组名和指针还是有很多区别的,这个在<C陷阱与缺陷>里有详尽的讲述.而这里要说的是对于数组名取地址的这么一个操作. 如果声明有如下数组: int arr[5]; 那么,&arr这个操作得到了什么值呢? 如果简单的认为arr就是一个指向数组首地址的指针的话,那么很自然会想到&arr得到的是一个指向存放arr这个指针的指针,也就是一个二级指针,然而事实却并不是这样. 观察以下代码: