C基础(二)数组和字符串的使用

一、一维数组

数组在内存中就是一段连续的空间，每个元素的类型是一样的

1.1 数组的定义

数组下标从0开始,数组的名字是一个常量，如果直接输出数组的名字得到的结果就是数组中第一个元素的地址

int array[10];//定义一个一维数组，名字叫array,一共有10个元素，每个元素都是int类型的

array[0] = 20;
array[1] = 30;
array[9] = 80;

//array[10] = 100;//错误，没有 array[10]这个元素
//array = 10 //报错 , 因为数组的名字是一个常量, 是不能赋值的. 只能改变数组元素的值

注意:如果定义的数组没有给元素赋值，那么默认的值是随机的。

#include<stdio.h>
int main()
{
	int arr[10];
	int i;
	for(i=0;i<10;i++)
	{
        //输出未赋值的数组元素
		printf("%d\n",arr[i]);
	}

   //打印内存地址
	printf("%p,%p\n",arr,&arr[0]);

	return 0;
}

结果:

1.2 数组的初始化

数组初始化时可以使用花括号来初始化,如下所示:

int array[10] = { 100, 1, 5, 3, 4, 5, 6, 7, 8, 0 };//定义数组的同时为数组的成员初始化值
int array[10] = { 3, 7, 9 };//将数组的前三个元素赋值，其余元素置为0
int array[10] = { 0 };//将数组所有的元素都置为0 ,Java的写法是:int a[] = new int[10]; 
int array []= {0,1,3,4,5}; // 直接定义5个元素的数组
int i;
for (i = 0; i < 10; i++)
{
    array[i] = 0;//通过循环遍历数组的每个元素，将元素的值置为0
}

1.3 获取数组的长度

先通过sizeof先获取数组的大小,然后再除以单个元素的大小得到的就是数组的长度了

#include<stdio.h>
int main()
{
	int arr[] = {0,2,4,5,6,10,9};
	// 得到数组的长度 = 总字节数/单个元素所占的字节数
	int size = sizeof(arr)/sizeof(arr[0]); 
	int i;
	for(i=0;i<size;i++){
		printf("arr[%d]=%d\n",i,arr[i]);
	}
	return 0;
}

结果:

1.4 案例-查找数组最大值

#include<stdio.h>
int main()
{
	int arr[] = {90,12,10,36,42,20,15,6};
	int max=arr[0]; //最大值
	int size = sizeof(arr)/sizeof(arr[0]);
	int i;
	for(i=1;i<size;i++)
	{
		if(max<arr[i])
		{
			max = arr[i];//更新最大值
		}
	}
	printf("max=%d\n",max);
	return 0;
}

结果:

1.5 案例-查找数组第二大元素

#include<stdio.h>
int main()
{
	int arr[] = {90,12,10,36,42,20,15,6};
	int max=arr[0];//最大值
	int smax = arr[1];//第二大值
	int size = sizeof(arr)/sizeof(arr[0]);
	int i;

	if(max<smax)
	{
		max = arr[1];
		smax = arr[0];
	}
	for(i=2;i<size;i++)
	{
		if(max<arr[i])
		{
			max = arr[i]; //更新最大值
			smax = max;//更新第二大值
		}
		else if(arr[i]<max && arr[i]>smax)
		{
			//如果介于最大和第二大之间,那么更新第二大值
			smax =arr[i];
		}
	}
	printf("max=%d,smax=%d\n",max,smax);
	return 0;
}

1.6 数组逆置

#include<stdio.h>
int main()
{
	int arr[] ={100,20,1,3,6,23,79,56,42};
	//实现倒序
	int start,end;
	int size = sizeof(arr)/sizeof(arr[0]);
	for(start=0,end=size-1;start<end;start++,end--)
	{
		int temp = arr[start];
		arr[start] = arr[end];
		arr[end] = temp;
	}
 //下面是用while循环的方式
//	end = size-1;
//	while(start<end)
//	{
//
//		int temp = arr[start];
//		arr[start] = arr[end];
//		arr[end] = temp;
//		start++;
//		end--;
//	}
	int i;
	for(i = 0 ; i < size; i++ )
	{
		printf("%d ",arr[i]);
	}
	printf("\n");
	return 0;
}

1. 7 冒泡排序

将一个无序的数组排序成一个有序的数组,遍历一个数组,将最大的成员放到最后一个, 思路就是2个相邻的元素比较,把大的放到小的后面.下次循环只需要将剩下的元素进行冒泡即可.

#include<stdio.h>
int main()
{
	int arr[] = {1,100,20,12,34,50,14};
	//冒泡排序,相邻2个元素比较,大的放后面

	int i,j;
	int size = sizeof(arr)/sizeof(arr[0]);
	for(i = 0 ; i < size - 1 ; i++)//外循环控制次数
	{
		for(j = 0; j < size - i -1 ; j++)//内循环进行比较,-i是因为每次循环减少一个元素,-1是避免越界
		{			
			if(arr[j] > arr[j+1])
			{
                //交互位置
				int temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}
			
		}
	}
    //打印结果
	int x ;
	for(x = 0 ;x < size; x++)
	{
		printf("%d ",arr[x]);
	}
	printf("\n");
	return 0;
}

二、二维数组

二维数组可以理解为一维数组的嵌套, 例如: int arr[10][10] ;表示有100个元素。

2.1 二维数组的定义

二维数组的定义需要使用2对中括号来表示，前一对中括号表示二维数组所包含的一维数组数量，后一个中括号表示每个包含的一维数组内可以存放多少个元素。

int array[2][3];//定义了一个二维数组，每个一维数组又包含3个一维数组,相当于又2*3=6个元素

注意: arr[0] 和arr[0][0] 是不一样的, 前着取出来的是一维数组, 后者取出来的是元素 , 数组的特点就是不能给数组名赋值,因为数组名是一个常量, 也就是说对于二维数组arr , arr[0]其实也是数组, 是不能赋值的.

2.2 二维数组的初始化和取值

常用的初始化方式有这几种：

int a[3][4] = {{1,2,3,4},{5,6,7,8},{,9,10,11,12}};//包含3个一维数组，每个一维数组内有4个元素
int a[3][4] = {{1,2,3,4},{5,6}}; //显示初始化了2个一维数组，其他会初始化为0
int a[3][4] = {0}; //将所有成员初始化为0
int a[][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}} // 第一个中括号可以不写值，这样表示有3组以为数组

取值方式如下：

#include<stdio.h>
int main()
{
    // 定义并初始化值
    // sizeof(arr)=3*3*4=36, 因为每个元素都是int类型,占用4个字节,所以总字节就是36BYTE
	int arr[3][3] = {{0,1,2},{3,4,5},{6,7,8}}; 
    // 二维数组的内的一维数组个数  
	int out_size = sizeof(arr)/sizeof(arr[0]);
    // 二维数组内的一维数组的元素个数
	int inner_size = sizeof(arr[0]) / sizeof(arr[0][0]);

	int i,j;
	for(i=0;i<out_size;i++)
	{
		for(j=0;j<inner_size;j++)
		{
			printf("arr[%d][%d]=%d\n",i,j,arr[i][j]);
		}
	}
	return 0;
}

结果:

三、三维数组

三维数组可以这样定义
int a[2][4][10];
表示的意思是这个3维数组包含2个二维数组, 数组名分别是a[0]和a[1], 而这2个二维数组又各自包含4个一维数组, 分别是:

a[0][0] ~a[0][3] 
a[1][0] ~a[1][3]

然后上面每个一维数组又各自包含10个元素,分别是:

a[0][0][0] ~a[0][3][9]
a[1][0][0] ~a[1][3][9]

同样的还可以有四维…多维等等.

3.1 三维数组的取值

#include<stdio.h>
int main()
{
     //定义一个3维数组,3维数组内有2个二维数组, 每个二维数组内有3个一维数组,每个一维数组内有4个元素
	int arr[2][3][4] = {
		{{1,2,3,4},{5,6,7,8},{9,10,11,12}},
		{{13,14,15,16},{17,18,19,20},{21,22,23,24}}
	};
     // 上面定义的三维数组的字节数是 2*3*4*4BYTE
	int size1 = sizeof(arr)/sizeof(arr[0]); //三维数组的size
	int size2 = sizeof(arr[0]) / sizeof(arr[0][0]); //二维数组的size
	int size3 = sizeof(arr[0][0]) /sizeof(arr[0][0][0]); //一维数组的size

	printf("size1=%d,size2=%d,size3=%d\n",size1,size2,size3);

	int x,y,z;
	for(x=0;x<size1;x++)
	{
		for(y=0;y<size2;y++)
		{
			for(z=0;z<size3;z++)
			{
				printf("arr[%d][%d][%d]=%d\t",x,y,z,arr[x][y][z]);
			}
			printf("\n");
		}
		printf("\n");
	}
	return 0;
}

结果:

3.2 三维数组排序

使用的技巧是先将三维数组内的所有元素保存到一个一维数组内，然后对该一维数组进行排序，排完之后在保存到三维数组内

#include<stdio.h>
int main()
{
	int arr[2][3][4] = {
		{{12,21,13,45},{15,62,17,81},{19,10,11,212}},
		{{3,14,15,16},{17,168,19,20},{1,212,213,254}}
	};

	int size1 = sizeof(arr)/sizeof(arr[0]);
	int size2 = sizeof(arr[0]) / sizeof(arr[0][0]);
	int size3 = sizeof(arr[0][0]) /sizeof(arr[0][0][0]);

	//先用一个一维数组变量来保存三维数组的所有元素
	int temp[size1*size2*size3];
	int index=0;

	int x,y,z;
	for(x=0;x<size1;x++)
	{
		for(y=0;y<size2;y++)
		{
			for(z=0;z<size3;z++)
			{
				temp[index++] = arr[x][y][z]; 
			}
		}
	}

	//排序一维数组，这里使用冒泡排序
	int size = sizeof(temp)/sizeof(temp[0]);
	int i,j;
	for(i=0;i<size;i++)
	{
		for(j=0;j<size-i-1;j++)
		{
			if(temp[j]>temp[j+1])
			{
				int t = temp[j];
				temp[j] = temp[j+1];
				temp[j+1] = t;
			}
		}
	}
	//重新填到三维数组中
	index = 0;
	for(x=0;x<size1;x++)
	{
		for(y=0;y<size2;y++)
		{
			for(z=0;z<size3;z++)
			{
				arr[x][y][z] = temp[index++];
			}
		}
	}

	//输出结果

	for(x=0;x<size1;x++)
	{
		for(y=0;y<size2;y++)
		{
			for(z=0;z<size3;z++)
			{
				printf("arr[%d][%d][%d]=%d\t",x,y,z,arr[x][y][z]);
			}
			printf("\n");
		}
		printf("\n");
	}
	
	return 0;
}

结果:

四、char数组与字符串

4.1 char数组的定义和初始化

字符数组的定义
char array[100];

字符数组的初始化

char array[100] = {'a', 'b', 'c','d'}; //其它的会用空白字符代替
char array[100] = "abcd"; //其它的会用空白字符代替
char array[] = "abcd"; //注意,这里其实是有5个字符,因为abcd是一个字符串常量,末尾是以'/0'结尾的
char array[100] = { 0 }; //全部用0填充

4.2 char数组与字符串区别

char的数组也是连续的空间,一个char占一个BYTE的大小.
字符串是内存中一段连续的char空间, 以’\0’结尾(数字0和字符’\0’等价). . 由于C语言中没有字符串这种数据类型, 只能用char数组来替代, 以’\0’结尾的char数组就是字符串,否则就是char数组.

4.3 char数组转字符串

只需要在字符数组末尾加一个’\0’;例如:

#include<stdio.h>
int main()
{
	char a[10];
	a[0] = 'a';
	a[1] = 'b';
	a[2] = 'c';
	a[3] = '\0';  //在字符数组末尾加一个0就会变成字符串
     
     //上面的赋值 等效与 char a[] ={'a','b','c','\0'}; 
 
	printf("%s\n",a); //输出的是一个字符串,结果是abc
	return 0;
}

结果:

思考下面打印结果为什么不一样?

#include <stdio.h>
#include <string.h>

int main()
{
    char str[] = "hello";
    printf("%s\n", str); // 1. hello
    printf("sizeof=%ld\n", sizeof str); // 2. sizeof=6
    printf("strlen=%ld\n", strlen(str)); // 3. strlen=5
    return 0;
}

注释1.可以正确输出字符串是因为字符数组以字符串方式初始化的话,编译器会默认在字符串的末尾添加’\0’.
注释2.sizeof = 6 是因为它会把字符串的’\0’的长度算上
注释3.strlen = 5, 它是计算有效字符的长度,不包括’\0’

4.4 字符串转char数组

转换后，char数组末尾会多一个’/0’;例如

#include<stdio.h>
int main()
{
	char a[] = "abc"; // 定义一个字符串a
	int size = sizeof(a);
	printf("size=%d\n",size); //字符数组长度是4,因为字符串变成字符串数组,最后以为是'/0'字符
	
	int i;
	for(i=0;i<size;i++)
	{
		printf("a[%d]=%d\n",i,a[i]);  //输出字符的ASCII码, '/0'的ASCII码就是数字0 ,而0的ASCII码是48
	}

	return 0;
}

结果:

注意:当char数组当做字符串输出的时候,如果char数组末尾不是0,那么会乱码(windows上)
同样,如果char数组中出现了0,那么当做字符串输出的时候,会被截断.(windows上)

4.5 案例-去除字符串结尾多余的空格

#include<stdio.h>
int main()
{
	// 定义一个字符串a
	char a[100] = "hello world         ";
	int size = sizeof(a);

	// 先获取有效位数,避免无效的操作
	int index =0;
	while(a[index]) // 如果a[index]!=0 则会进入循环体，这里利用了非0为true的特性
	{
		printf("index=%d, value=%c, ascii=%d\n",index,a[index],a[index]);
		index++;
	}
	
	int i = index-1;
	for(;i>=0;i--)
	{
		//从后往前遍历第一个不是空格的字符
		if(a[i] !=' ')
		{
			a[i+1] = '\0'; //在最后一个有效字符后面加一个0,变成字符串
			break;
		}
	}
	printf("(%s)\n",a);
}

结果: