[C语言]数组和字符串

目录

数组和字符串::

                数组

                  1.数组的概述

                  2.一维数组的创建和初始化

                  3.一维数组的使用

                  4.一维数组在内存中的存储

                  5.二维数组的创建和初始化

                  6.二维数组的使用

                  7.二维数组在内存中的存储

                  8.数组越界

                  9.冒泡排序与数组名

                字符串

                  1.字符数组与字符串区别

                  2.字符串的初始化

                  3.字符串的输入输出

                C语言编程训练

                  1.递归实现字符串逆序

                  2.递归实现一个数的每位之和

                  3.递归实现n的k次方

                  4.交换数组

                  5.a.实现函数init初始化数组为全0

                     b.实现函数print打印数组的每一个元素

                     c.实现函数reverse完成数组元素的逆置                                           


数组和字符串::

数组

1.数组的概述

在程序设计中,为了方便处理数据,把具有相同类型的若干变量按有序形式组织起来——称为数组。数组就是内存中连续的相同类型的变量空间,同一个数组所有的成员都是相同的数据类型,同时所有的成员在内存中的地址是连续的。

数组属于构造数据类型:

(1)一个数组可以分解为多个数组元素:这些数组元素可以是基本数据类型或构造类型。

int arr[10];
struct Stu boy[10];

(2)按数组元素类型的不同,数组可分为:数值数组、字符数组、指针数组、结构数组等类别。

char ch[10];
char* p[10];

通常情况下,数组元素下标的个数称为维数,根据维数的不同,可将数组分为一维数组、二维数组、三维数组等。我们将二维数组以上的数组称为多维数组。

2.一维数组的创建和初始化

一维数组的定义和使用

(1)数组名字标识符的书写规定(数字,字母,下划线)

(2)数组名不能与其他变量名相同,同一作用域内是唯一的

(3)方括号[ ]中常量表达式表示数组元素的个数

(4)定义数组时最好是常量,使用数组时方括号[ ]内既可是常量也可以是变量

//int arr[3]表示数组a有3个元素
//其下标从0开始计算,因此3个元素分别为arr[0],arr[1],arr[2]
#include <stdio.h>

int main()
{
	int arr[10];//定义了一个数组,名字叫arr,有10个成员,每个成员都是int类型
	//arr[0]…… arr[9],没有arr[10]
	//没有arr这个变量,arr是数组的名字,但不是变量名,它是常量
	arr[0] = 0;
	//……
	arr[9] = 9;

	int i = 0;
	for (i = 0; i < 10; i++)
	{
		arr[i] = i; //给数组赋值
	}

	//遍历数组,并输出每个成员的值
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");

	return 0;
}
//注:7[arr]定义时不可以,访问时可以这么用

一维数组的初始化

在定义数组的同时进行赋值,称为初始化,全局数组若不初始化,编译器将其初始化为0,局部数组若不初始化,内容为随机值。数组的类型:去掉数组名剩下的就是它的类型。如int arr[4]的类型是int [4]。

int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };//定义一个数组,同时初始化所有成员变量
int arr[10] = { 1, 2, 3 };//初始化前三个成员,后面所有元素都设置为0
int arr[10] = { 0 };//所有的成员都设置为0
//[]中不定义元素个数,定义时必须初始化
int arr[] = { 1, 2, 3, 4, 5 };//定义了一个数组,有5个成员
	

3.一维数组的使用

#include <stdio.h>

int main()
{
	int arr[] = {  1, -2, 3,- 4, 5, -6, 7, -8, -9, 10 };//定义一个数组,同时初始化所有成员变量

	int i = 0;
	int max = arr[0];
	for (i = 1; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		if (arr[i] > max)
		{
			max = arr[i];
		}
    }
        printf("数组中最大值为:%d\n", max);

	    return 0;
}
int main()
{
	int arr[] = {  1, -2, 3,- 4, 5, -6, 7, -8, -9, 10 };//定义一个数组,同时初始化所有成员变量

	int i = 0;
	int j = sizeof(arr) / sizeof(arr[0]) -1;
	int tmp = 0;

	while (i < j)
	{
		tmp = arr[i];
		arr[i] = arr[j];
		arr[j] = tmp;
		i++;
		j--;
	}

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

	return 0;
}

 

4.一维数组在内存中的存储

#include<stdio.h>
int main()
{
	int arr[10] = { 0 };
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < sz; i++)
	{
		printf("&arr[%d] = %p\n", i, &arr[i]);
	}
	return 0;
}

仔细观察输出的结果,我们知道,随着数组下标的增长,元素的地址,也在有规律的递增。由此可以得出结论,数组在内存中是连续存放的。

补:一维数组的打印

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

 

5.二维数组的创建和初始化 

二维数组的定义和使用

二维数组定义的一般格式是:

类型说明符  数组名  [常量表达式1][常量表达式2]

其中常量表达式1表示第一维度下标的长度,常量表达式2表示第二维度下标的长度。

二维数组a是按行按列进行存放的,先存放a[0]行,再存发a[1]行、a[2]行,并且每行有四个元素,也是依次存放的。

二维数组在概念上是二维的:其下标在两个方向上变化,对其访问一般需要两个下标。

在内存中并不存在二维数组,二维数组实际的硬件存储器是连续编址的,也就是说内存中只有一维数组,即放完一行之后顺次放入第二行,和一维数组存放方式是一样的。

#include <stdio.h>

int main()
{
	//定义了一个二维数组,名字叫arr
	//由3个一维数组组成,这个一维数组是int [4]
	//这3个一维数组的数组名分别为arr[0],arr[1],arr[2]
	int arr[3][4];

	//arr[0][0] = 0;
	//……
	//arr[2][3] = 12;

	//给数组每个元素赋值
	int i = 0;
	int j = 0;
	int num = 0;
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 4; j++)
		{
			arr[i][j] = num++;
		}
	}

	//遍历数组,并输出每个成员的值
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 4; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

 

二维数组的初始化

    //分段赋值
 	int a[3][4] = {{ 1, 2, 3, 4 },{ 5, 6, 7, 8 },{ 9, 10, 11, 12 }};
	int a[3][4] = 
	{ 
		{ 1, 2, 3, 4 },
		{ 5, 6, 7, 8, },
		{ 9, 10, 11, 12 }
	};

	//连续赋值
	int a[3][4] = { 1, 2, 3, 4 , 5, 6, 7, 8, 9, 10, 11, 12  };

	//可以只给部分元素赋初值,未初始化则为0
	int a[3][4] = { 1, 2, 3, 4  };

	//所有的成员都设置为0
	int a[3][4] = {0};

	//[]中不定义元素个数,定义时必须初始化
	int a[][4] = { 1, 2, 3, 4, 5, 6, 7, 8};

6.二维数组的使用

#include <stdio.h>
int main()
{
     int arr[3][4] = {0};
     int i = 0;
     for(i = 0; i < 3; i++)
     {
         int j = 0;
         for(j = 0; j < 4; j++)
         {
             arr[i][j] = i*4+j;
         }
     }
     for(i = 0; i < 3; i++)
     {
         int j = 0;
         for(j = 0; j < 4; j++)
         {
             printf("%d ", arr[i][j]);
         }
     }
     return 0; 
}

7.二维数组在内存中的存储

#include<stdio.h>
int main()
{
	int arr[3][4] = { 0 };
	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;
}

通过结果,我们可以分析到其实二维数组在内存中也是连续存储的。

补:二维数组的打印

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

8.数组越界

数组的下标是有范围限制的。下标规定是从0开始的,如果有n个元素,最后一个元素的下标是n-1,所以数组的下标如果小于0或者大于n-1,就是数组越界访问了,超出了数组合法空间的访问。C语言本身是不做数组下标的越界检查的,编译器也不一定报错,但是编译器不报错,并不意味着程序就是对的。所以程序员写代码时,最好自己做越界的检查。当然二维数组的行和列也可能存在越界。

#include <stdio.h>
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    int i = 0;
    for(i=0; i<=10; i++)
    {
        printf("%d ", arr[i]);//当i等于10的时候,越界访问了
    }
    return 0;
}

 

9.冒泡排序与数组名

#include <stdio.h>
void bubble_sort(int arr[],int sz)
{
    int i = 0;
     for(i=0; i<sz-1; i++)
     {
        int j = 0;
        for(j=0; j<sz-i-1; j++)
       {
            if(arr[j] > arr[j+1])
           {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
           }
       }
     }
}
int main()
{
    int arr[] = {3,1,7,5,8,9,0,2,4,6};
    int sz = sizeof(arr)/sizeof(arr[0]);
	int i = 0;
    bubble_sort(arr, sz);
    for(i=0; i<sz; i++)
    {
         printf("%d ", arr[i]);
    }
    return 0; 
}

 

往往在我们写代码的时候,会将数组作为参数传递给函数,比如我们要实现一个冒泡排序。

//1.sizeof(数组名)计算整个数组的大小,sizeof内部单独放一个数组名,数组名表示整个数组。
//2. &数组名,取出的是数组的地址。&数组名,数组名表示整个数组。

除1,2两种情况外,所有数组名都表示首元素地址。

一维数组的数组名

一维数组的数组名是一个常量,代表首元素的地址

#include <stdio.h>
int main()
{
	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };//定义一个数组,同时初始化所有成员变量

	printf("arr = %p\n", arr);
	printf("&arr[0] = %p\n", &arr[0]);

	int n = sizeof(arr); //数组占用内存的大小,10个int类型,10 * 4  = 40
	int n0 = sizeof(arr[0]);//数组第0个元素占用内存大小,第0个元素为int,4

	int i = 0;
	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");

	return 0;
}

 

二维数组的数组名

二维数组的数组名也是一个地址常量,代表二维数组第一行的地址

#include <stdio.h>
int main()
{
	//定义了一个二维数组,名字叫arr
	//二维数组的本质上还是一维数组,此一维数组有3个元素
    //每个元素又是一个一维数组int[4]
	int arr[3][4] = { 1, 2, 3, 4 , 5, 6, 7, 8, 9, 10, 11, 12 };

	//数组名为数组首元素地址,二维数组的第0个元素为一维数组
	//第0个一维数组的数组名为a[0]
	printf("arr = %p\n", arr);
	printf("arr[0] = %p\n", arr[0]);
	
	//测二维数组所占内存空间,有3个一维数组,每个一维数组的空间为4*4
	//sizeof(arr) = 3 * 4 * 4 = 48
	printf("sizeof(arr) = %d\n", sizeof(arr));

	//测第0个元素所占内存空间,a[0]为第0个一维数组int[4]的数组名,4*4=16
	printf("sizeof(arr[0]) = %d\n", sizeof(arr[0]) );

	//测第0行0列元素所占内存空间,第0行0列元素为一个int类型,4字节
	printf("sizeof(arr[0][0]) = %d\n", sizeof(arr[0][0]));

	//求二维数组行数
	printf("i = %d\n", sizeof(arr) / sizeof(arr[0]));

	//求二维数组列数
	printf("j = %d\n", sizeof(arr[0]) / sizeof(arr[0][0]));

	//求二维数组行*列总数
	printf("n = %d\n", sizeof(arr) / sizeof(arr[0][0]));

	return 0;
}

 

字符串

1.字符数组与字符串区别

C语言中没有字符串这种数据类型,可以通过char的数组来替代,字符串一定是一个char的数组,但char的数组未必是字符串;数字0(或’\0‘)结尾的char数组就是一个字符串,但如果char数组没有以数字0结尾,那么就不是一个字符串,只是普通的字符数组,所以字符串是一种特殊的char的数组。

#include <stdio.h>

int main()
{
	char c1[] = { 'c', 'a', 'p', 'r', 'o', 'g' }; //普通字符数组
	printf("c1 = %s\n", c1); //乱码,因为没有’\0’结束符

	//以‘\0’(‘\0’就是数字0)结尾的字符数组是字符串
	char c2[] = { 'c', ' ', 'p', 'r', 'o', 'g', '\0'}; 
	printf("c2 = %s\n", c2);

	//字符串处理以‘\0’(数字0)作为结束符,后面的'h', 'l', 'l', 'e', 'o'不会输出
	char c3[] = { 'c', ' ', 'p', 'r', 'o', 'g', '\0', 'h', 'l', 'l', 'e', 'o', '\0'};
	printf("c3 = %s\n", c3);

	return 0;
}

2.字符串的初始化

#include <stdio.h>

//C语言没有字符串类型,通过字符数组模拟
//C语言字符串,以字符‘\0’, 数字0
int main()
{
	//不指定长度, 没有0结束符,有多少个元素就有多长
	char buf[] = { 'a', 'b', 'c' };
	printf("buf = %s\n", buf);	//乱码

	//指定长度,后面没有赋值的元素,自动补0
	char buf2[100] = { 'a', 'b', 'c' };
    char buf[1000]=“hello”;
	printf("buf2 = %s\n", buf2);

	//所有元素赋值为0
	char buf3[100] = { 0 };

	//char buf4[2] = { '1', '2', '3' };数组越界

	char buf5[50] = { '1', 'a', 'b', '0', '7' };
	printf("buf5 = %s\n", buf5);

	char buf6[50] = { '1', 'a', 'b', 0, '7' };
	printf("buf6 = %s\n", buf6);

	char buf7[50] = { '1', 'a', 'b', '\0', '7' };
	printf("buf7 = %s\n", buf7);

	//使用字符串初始化,编译器自动在后面补0
	char buf8[] = "agjdslgjlsdjg";

	//'\0'后面最好不要连着数字,有可能几个数字连起来刚好是一个转义字符
	//'\ddd'八进制字义字符,'\xdd'十六进制转移字符
	//\012相当于\n
	char str[] = "\012abc";
	printf("str == %s\n", str);
	return 0;
}

3.字符串的输入输出

由于字符串采用了'\0'标志,字符串的输入输出也就变得很简单方便。

#include <stdio.h>

int main()
{
	char str[100]; 
	printf("input string1 : \n");
	scanf("%s", str);//scanf(“%s”,str)默认以空格分隔
	printf("output:%s\n", str);
	return 0;
}

(1)gets()

  gets(str)与scanf("%s",str)的区别:

1.gets(str)允许输入的字符串含有空格

2.scanf(“%s”,str)不允许含有空格

注意:由于scanf()和gets()无法知道字符串s大小,必须遇到换行符或读到文件结尾为止才接收输入,因此容易导致字符数组越界(缓冲区溢出)的情况。

#include <stdio.h>
char* gets(char* s);
//功能:从标准输入读入字符,并保存到s指定的内存空间,直到出现换行符或读到文件结尾为止。
char str[100];
printf("请输入str: ");
gets(str);
printf("str = %s\n", str);

(2)fgets()

fgets()在读取一个用户通过键盘输入的字符串的时候,同时把用户输入的回车也做为字符串的一部分。通过scanf和gets输入一个字符串的时候,不包含结尾的“\n”,但通过fgets结尾多了“\n”。fgets()函数是安全的,不存在缓冲区溢出的问题。

#include <stdio.h>
char* fgets(char* s, int size, FILE *stream);
//功能:从stream指定的文件内读入字符,保存到s所指定的内存空间,直到出现换行字符、读到文件结尾
//或是已读了size - 1个字符为止,最后会自动加上字符 '\0' 作为字符串结束。
//参数:
//	s:字符串
//	size:指定最大读取字符串的长度(size - 1)
//	stream:文件指针,如果读键盘输入的字符串,固定写为stdin
char str[100];
printf("请输入str: ");
fgets(str, sizeof(str), stdin);
printf("str = \"%s\"\n", str);

(3)puts()

#include <stdio.h>
int puts(const char *s);
//功能:标准设备输出s字符串,在输出完成后自动输出一个'\n'。
int main()
{
	printf("hello world");
	puts("hello world");
	return 0;
}

(4)fputs()

#include <stdio.h>
int fputs(const char * str, FILE * stream);
//功能:将str所指定的字符串写入到stream指定的文件中, 字符串结束符 '\0'  不写入文件。 
//参数:
//	str:字符串
//	stream:文件指针,如果把字符串输出到屏幕,固定写为stdout
//fputs()是puts()的文件操作版本
printf("hello world");
puts("hello world");
fputs("hello world", stdout);

C语言编程训练

1.递归实现字符串逆序

#include<stdio.h>
#include<string.h>
//方法一
int main()
{
	char arr[] = "abcdef";
	int sz = strlen(arr);
	int left = 0;
	int right = sz - 1;
	while (left < right)
	{

		char temp = arr[left];
		arr[left] = arr[right];
		arr[right] = temp;
		left++;
		right--;
	}
	printf("%s\n", arr);
	
	return 0;
}
//方法二:函数版
void reverse(char arr[])
{
	int left = 0;
	int right = strlen(arr) - 1;
	while (left < right)
	{
		char temp = arr[left];
		arr[left] = arr[right];
		arr[right] = temp;
		left++;
		right--;
	}
}
int main()
{
	char arr[] = "abcdef";
	reverse(arr);
	printf("%s\n", arr);
	return 0;
}
//方法三:递归单参数
int my_strlen(char* str)
{
	int count = 0;
	while (*str)
	{
		count++;
		str++;
	}
	return count;
}
void reverse(char* str)
{
	char temp = *str;
	int len = my_strlen(str);
	*str = *(str + len - 1);
	*(str + len - 1) = '\0';
	if (my_strlen(str + 1) >= 2)
		reverse(str + 1);
	*(str + len - 1) = temp;
}
int main()
{
	char arr[] = "abcdefg";
	reverse(arr);
	printf("%s\n", arr);
	return 0;
}
//方法四:递归多参数
void reverse(char arr[], int left, int right)
{

	
	char tmp = arr[left];
	arr[left] = arr[right];
	arr[right] = tmp;
	if (left < right)
	{
		reverse(arr, left + 1, right - 1);
	}
}
int main()
{
	char arr[] = "abcdefg";
	int left = 0;
	int right = my_strlen(arr) - 1;
	reverse(arr, left, right);
	printf("%s\n", arr);
	return 0;
}

2.递归实现一个数的每位之和

#include<stdio.h>
int DigitSum(unsigned int n)
{
	if (n > 9)
		return DigitSum(n / 10) + n % 10;
	else
		return n;
}
int main()
{
	unsigned int n = 0;
	scanf("%u", &n);
	int sum = DigitSum(n);
	printf("%d\n", sum);

}

3.递归实现n的k次方

include<stdio.h>
double Pow(int n, int k)
{
	if (k > 0)
		return n * Pow(n, k - 1);
	else if (k == 0)
		return 1;
	else
		return 1.0 / Pow(n, -k);
}
int main()
{
	int n = 0;
	int k = 0;
	scanf("%d %d", &n, &k);
	double ret = Pow(n, k);
	printf("%.2lf", ret);
	return 0;
}

4.交换数组

#include<stdio.h>
int main()
{
	int arr1[] = { 1,3,5,7,9 };
	int arr2[] = { 2,4,6,8,0 };
	int i = 0;
	int sz = sizeof(arr1) / sizeof(arr1[0]);
	for (i = 0; i < sz; i++)
	{
		int temp = arr1[i];
		arr1[i] = arr2[i];
		arr2[i] = temp;
	}
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr1[i]);
	}
	printf("\n");
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr2[i]);
	}
	printf("\n");
	return 0;
}

5.a.实现函数init初始化数组为全0

   b.实现函数print打印数组的每一个元素

   c.实现函数reverse完成数组元素的逆置 

#include<stdio.h>
void init(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		arr[i] = 0;
	}
}
void print(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
void reverse(int arr[],int sz)
{
	int left = 0;
	int right = sz - 1;
	while (left < right)
	{
		int temp = arr[left];
		arr[left] = arr[right];
		arr[right] = temp;
		left++;
		right--;
	}
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	print(arr, sz);
	reverse(arr, sz);
	print(arr, sz);
	init(arr, sz);
	print(arr, sz);
	return 0;
}

                                          

  • 50
    点赞
  • 65
    收藏
    觉得还不错? 一键收藏
  • 21
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值