当前位置:   article > 正文

C语言数组练习——数组置换、数组逆序、冒泡排序(两种方法+图解)_用c语言实现数组的置换

用c语言实现数组的置换

内容

1.数组知识点
2.数组置换
3.数组逆序
4.冒泡排序


*1.数组知识点

数组创建:
type_t arr_name [const_n];
//type_t 是指数组的元素类型
//const_n 必须是一个常量表达式,用来指定数组的大小

int arr1[] = {1,2,3,4};
int arr2[5] = {12345};
int arr3[2]={1};  //不完全初始化
int len = sizeof(arr1) / sizeof(arr1[0]);  //计算数组元素个数,4
  • 1
  • 2
  • 3
  • 4

一维数组数组名的使用:

  • 计算一维数组元素个数: * sizeof(数组名) / sizeof(数组名[0])
  • 获取数组中一个元素的地址: printf("%p\n", &arr1[3]); //%p 打印格式为指针型 ,指向该数组元素的地址.
  • 可以统计整个数组在内存中所占的长度; // sizeof(数组名) 数组存储在内存中分配的是一段连续的内存空间
  • printf(“一维数组arr1的首地址为:%p\n”, arr1);
  • 数组名是常量,不能进行赋值操作(表达式是不可修改的左值);

注意:
(1) 如果创建数组时,不想直接指定元素个数,就得进行初始化.如果明确了数组元素个数,未进行初始化的元素默认为0; 数组元素下标从0~len-1;
(2) 使用printf()函数打印输出时, %d-格式为整型; %p-格式为指针型,用于打印变量地址; %s-表示打印为字符型;%f-表示打印为浮点型…

char str[]="hello";
char arr[]={'h','e','l','l','o'};
  • 1
  • 2
  • sizeof(str)=6 ; 一个字符串数组,在内存中字符串后面隐式包含’ \0’,一个字符占一个字节;
  • strlen(str)=5; arr数组表示含有字符型变量5个单字符的数组;
  • strlen(arr);结果是一个随机数,strlen函数遍历字符串遇到’\0’才会停之;arr数组元素检测完还会继续向后检测,直到遇到’\0’是才终止,因此答案为不确定;

二维数组的创建同理,相当于两个一维数组,多了一维:

int arr1[][2]={0};
int arr2[2][2]={{1,2},{3,4}};
  • 1
  • 2

注意:二维数组在创建时不可省略第二维元素个数,也就是不可省略列向量的个数.

  • 计算二维数组行数: sizeof(数组名) / sizeof(数组名[0])
  • 计算二维数组列数: sizeof(数组名[0]) / sizeof(数组名[0][0])
  • 计算二维数组所占内存大小: sizeof(数组名)
  • 计算二维数组第2行所占内存大小: sizeof(数组名[2])
  • 计算二维数组第一行第二列元素地址: &数组名[0][1]
#include<stdio.h>
#include<stdlib.h>

int main() {
	int arr1[] = { 3,4,2,6 };
	int arr2[] = { 9,8,0,1 };
	printf("一维数组arr1的首地址为:%p\n", arr1);
	printf("一维数组arr1[0]元素的地址:%p\n", &arr1[0]);
	printf("一维数组arr1[1]元素的地址:%p\n", &arr1[1]);
	int len1 = sizeof(arr1) / sizeof(arr1[0]);
	int len2 = sizeof(arr2) / sizeof(arr2[0]);
	printf("一维数组arr1的长度为:%d\n", len1);
	printf("一维数组占内存大小:%d\n", sizeof(arr1));
	
	int arr[][3] = { 1,2,3,4,5,6 };
	int row = sizeof(arr) / sizeof(arr[0]);
	int col = sizeof(arr[0]) / sizeof(arr[0][0]);
	printf("二维数组行数%d\n", row);
	printf("二维数组列数%d\n", col);
	printf("二维数组占内存大小:%d\n", sizeof(arr));
	printf("二维数组第一行大小:%d\n", sizeof(arr[0]));
	printf("二维数组第一行地址:%p\n", &arr[0]);
	printf("二维数组第二行第一个元素地址:%p\n", &arr[1][0]);
	
	system("pause");
	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

测试结果为:
在这里插入图片描述

*2.数组置换

要求: 将两个相同长度的数组进行元素交换.
(1) 创建两个数组;
(2) 判断两个数组长度是否相等;
(3) 创建一个置换函数,进行数组元素交换.

注意: 数组作为函数参数时,只要传入的实参为数组,实际上传入时,数组名可以隐式转换为指向首元素的指针.所以不管形参是指针型还是数组型,给形参的都是一个指向数组首地址的指针.进行的都是地址传递.

代码实现:

#include<stdio.h>
#include<stdlib.h>

//打印数组序列函数
void printA(int Arr[], int len) {
	for (int i = 0; i < len; i++) {
		printf(" %d ", Arr[i]);
	}
	printf("\n");
}
//交换数组函数:实现两个等长的数组交换
void exchange(int* Arr1, int* Arr2,int len) {
	for (int i = 0; i < len; i++) {
		int temp = Arr1[i];  //老套路,设置中间变量进行交换
		Arr1[i] = Arr2[i];
		Arr2[i] = temp;
	}
}

int main() {
	int arr1[] = { 3,4,2,6 };
	int arr2[] = { 9,8,0,1 };
	int len1 = sizeof(arr1) / sizeof(arr1[0]);
	int len2 = sizeof(arr2) / sizeof(arr2[0]);
	printf("置换前数组arr1的序列为:");
	printA(arr1, len1);
	printf("置换前数组arr2的序列为:");
	printA(arr2, len2);
	if (len1 = len2) {
		exchange(arr1,arr2,len1);
		printf("数组已完成交换\n");
	}
	else {
		printf("数组长度不相同,不能进行交换");
	}
	printf("置换后数组arr1的序列为:");
	printA(arr1,len1);
	printf("置换后数组arr2的序列为:");
	printA(arr2, len2);

	system("pause");
	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43

结果显示:
在这里插入图片描述

*3.数组逆序

要求:
(1) 创建一个一维数组
(2)通过一个函数令数组改编为原数组的逆序数组
思路: 快速首尾交换,向中间操作
代码实现:

#include<stdio.h>
#include<stdlib.h>

//打印函数:实现对数组元素的打印输出
void print(int Arr[], int len) {
	printf("数组的元素序列为: ");
	for (int i = 0; i < len; i++) {
		printf("%d ", Arr[i]);
	}
	printf("\n");
}
//数组逆序函数:实现对数组元素逆序操作
void reverse(int Arr[], int len) {
	int left = 0;
	int right = len - 1;
	while (left < right) {
		int temp = Arr[left];
		Arr[left] = Arr[right];
		Arr[right] = temp;
		left++;
		right--;
	}
}

int main() {
	int arr2[] = { 1,4,7,8,3,6 };
	int len = sizeof(arr2) / sizeof(arr2[0]);
	printf("逆序前的");
	print(arr2, len);
	reverse(arr2, len);
	printf("逆序后的");
	print(arr2, len);

	system("pause");
	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36

结果:
在这里插入图片描述

*4.冒泡排序

作用: 做常用的排序算法,对元素内数组进行排序
(1) 实现升序的第一种冒泡排序形式: 每次比较交换,每一轮总是把该轮比较的最大值放在比较的最右边

  • 总是从数组第一位开始往后比较
    在这里插入图片描述
  • 冒泡排序轮数 i :len-1
  • 冒泡排序每轮排序次数 j : len-第 i 轮-1

图解法:
在这里插入图片描述
注意 : 由于数组下标都是从0开始的 故轮数 i 和 比较字数 j 都是从0开始.

代码实现:

#include<stdio.h>
#include<stdlib.h>

//冒泡排序函数:实现对数组升序排列,总是把最大的数放在比较的最右边
void bubbleSort(int str[], int len) {
	for (int i = 0; i < len - 1; i++) {
		for (int j = 0; j < len - i - 1; j++) {
			if (str[j] > str[j + 1]) {
				int temp = str[j];
				str[j] = str[j + 1];
				str[j + 1] = temp;
			}
		}
	}
}
//打印排序后数组的函数
void printS(int str[], int len) {
	printf("数组序列为:");
	for (int i = 0; i < len; i++) {
		printf("%d ", str[i]);
	}
	printf("\n");
}

int main() {
	int s[] = { 2,5,9,7,1,8,3,4 };
	int len = sizeof(s) / sizeof(s[0]);
	printf("升序冒泡排序前的");
	printS(s, len);
	bubbleSort(s,len);
	printf("升序冒泡排序后的");
	printS(s,len);

	system("pause");
	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36

结果:
在这里插入图片描述
(2) 实现升序的第二种冒泡排序形式: 每次比较交换,每一轮总是把该轮比较的最大值放在比较的最右边

算法描述:

  • 总是从数组最后一位开始往前比较
  • 1 .比较相邻两个数,前者大于后者,则两个数进行交换
  • 2 .每相邻两个数做同样的工作, 执行结束后,找到第一个最小数
  • 3 .重复以上步骤,每次比较范围boune+1(向后移一位),直到升序完成范围,不需要比较

设置初始的比较范围 bound 为[0,size-1], 当前值 数组[current] 初始总是为数组最后一个元素. 换言之就是:下标为current的数组元素两两相邻比较交换,比较的范围总是在数组下标为bound的范围内.

图解法:
在这里插入图片描述
代码实现:

#include<stdio.h>
#include<stdlib.h>

//冒泡排序函数:实现对数组升序排列
void bubbleSort(int str[], int len) {
	int bound = 0;
	for (; bound < len; bound++) {
		for (int cur = len - 1; cur > bound; cur--) {
			if (str[cur - 1] > str[cur]) {
				int temp = str[cur - 1];
				str[cur - 1] = str[cur];
				str[cur] = temp;
			}
		}
	}
}
//打印排序后数组的函数
void printS(int str[], int len) {
	printf("数组序列为:");
	for (int i = 0; i < len; i++) {
		printf("%d ", str[i]);
	}
	printf("\n");
}

int main() {
	int s[] = { 2,5,9,7,1,8,3,4 };
	int len = sizeof(s) / sizeof(s[0]);
	printf("升序冒泡排序前的");
	printS(s, len);
	bubbleSort(s,len);
	printf("升序冒泡排序后的");
	printS(s,len);

	system("pause");
	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37

结果:
在这里插入图片描述
不同: 两种方法都实现冒泡升序排序,第一种总先找到最大数,第二种总先找到最小数.

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/程序语言诗人/article/detail/63006
推荐阅读
相关标签
  

闽ICP备14008679号