【0基础学习C++】第4节 C++study_04

本节内容：一维数组、冒泡排序算法

#include <iostream>
using namespace std;

//数组，本节含有冒泡排序算法

/*
一维数组定义的三种方式：
1. 数据类型  数组名[ 数组长度 ]; 
2. 数据类型  数组名[ 数组长度 ] = { 值1，值2 ...};
3. 数据类型  数组名[ ] = { 值1，值2 ...};
*/

int main()
{
	//1. 数据类型  数组名[ 数组长度 ];
	int arr[5];
	arr[0] = 10;
	arr[1] = 20;
	arr[2] = 30;
	arr[3] = 40;
	arr[4] = 50;

	cout << arr[0] << endl;
	cout << arr[1] << endl;
	cout << arr[2] << endl;
	cout << arr[3] << endl;
	cout << arr[4] << endl;

	//2. 数据类型  数组名[ 数组长度 ] = { 值1，值2 ...};
	int arr2[5] = { 10, 20, 30 }; //这种方式如果没把数组全部初始化，会自动用0补全
	cout << arr2[0] << endl;
	cout << arr2[1] << endl;
	cout << arr2[2] << endl;
	cout << arr2[3] << endl;
	cout << arr2[4] << endl;

	//用循环输出数组中的元素
	for (int i = 0; i < 5; i++)
	{
		cout << arr2[i] << endl;
	}

	//3. 数据类型  数组名[ ] = { 值1，值2 ...}
	int arr3[] = {90, 80, 70, 60, 50, 40, 30, 20, 10};
	for (int i = 0; i < 9; i++)
	{
		cout << arr3[i] << endl;
	}

	/*
		一维数组名称的**用途**：
		1. 可以统计整个数组在内存中的长度
		2. 可以获取数组在内存中的首地址
	*/

	//1. 可以统计整个数组在内存中的长度
	int arr4[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	cout << "整个数组空间占用内存空间为：" << sizeof(arr4) << endl;
	cout << "每个元素占用内存空间为：" << sizeof(arr4[0]) << endl;
	cout << "数组中元素的个数是：" << sizeof(arr4) / sizeof(arr4[0]) << endl;

	//2. 可以获取数组在内存中的首地址
	cout << "arr4数组的首地址为：" << (int)arr4 << endl;
	cout << "arr4的第一个元素的地址是：" << (int) & arr4[0] << endl;
	cout << "arr4的第二个元素的地址是：" << (int) & arr4[1] << endl;

	//数组名是常量，不可以进行赋值操作
	//arr = 100; 这是错误的写法

	//一维数组案例
	/*
		练习案例1：五只小猪称体重
		案例描述：
		在一个数组中记录了五只小猪的体重，
		如：int arr[5] = {300,350,200,400,250};
		找出并打印最重的小猪体重。
	*/

	//其实就是n个数用n-1次就能找到最大数
	int arr5[5] = { 300,350,200,400,250 };
	
	for (int j = 0; j < 4; j++)
	{
		if (arr5[j] > arr5[j + 1])
		{
			int temp = arr5[j + 1];
			arr5[j + 1] = arr5[j];
			arr5[j] = temp;
		}
	}
	cout << "最重的小猪的体重是：" << arr5[4] << endl;

	//上面的程序是冒泡排序的一次内层循环，不太符合题意
	//下面是老师的思路，更新最大值法
	int max = 0;
	for (int i = 0; i < 5; i++)
	{
		if (arr5[i] > max)
		{
			max = arr5[i];
		}
	}
	cout << "最重的小猪的体重是：" << max << endl;

	/*
		练习案例2：数组元素逆置
		案例描述：请声明一个5个元素的数组，
		并且将元素逆置.
		(如原数组元素为：1,3,2,5,4;
		逆置后输出结果为:4,5,2,3,1);
	*/

	//对称交换法：无论一共有奇数个还是偶数个元素n，交换n/2次即可逆序
	int arr6[5] = {1, 3, 2, 5, 4};
	int arr_len = sizeof(arr6) / sizeof(arr6[0]); //获取数组长度，这是一种很重要的思想，假如该数组是其他函数传进来的，这样写可以避免手动输入循环的判断条件
	for (int i = 0; i < arr_len / 2; i++)
	{
		int temp = arr6[i];
		arr6[i] = arr6[arr_len - 1 - i];
		arr6[arr_len - 1 - i] = temp;
	}
	cout << "arr6逆序输出为：";
	for (int i = 0; i < arr_len; i++)
	{
		cout << arr6[i];
	}
	cout << endl;

	//此案例老师的方法是设置始终下标，向中间移动的方法，大同小异
	int arr6_1[5] = { 1, 3, 2, 5, 4 };
	int start = 0; //起始下标
	int end = sizeof(arr6_1) / sizeof(arr6_1[0]) - 1; //结束下标
	while (start < end)
	{
		//元素互换
		int temp = arr6_1[start];
		arr6_1[start] = arr6_1[end];
		arr6_1[end] = temp;

		//下标更新
		start++;
		end--;
	}
	cout << "arr6逆序输出为：";
	for (int i = 0; i < 5; i++)
	{
		cout << arr6_1[i];
	}
	cout << endl;




	//冒泡排序
	/*
		作用：最常用的排序算法，对数组内元素进行排序
		1. 比较相邻的元素。如果第一个比第二个大，
		就交换他们两个。
		2. 对每一对相邻元素做同样的工作，
		执行完毕后，找到第一个最大值。
		3. 重复以上的步骤，每次比较次数-1，
		直到不需要比较
	*/

	//示例:将数组 { 4,2,8,0,5,7,1,3,9 } 进行升序排序

	int arr7[9] = { 4,2,8,0,5,7,1,3,9 };
	for (int i = 0; i < 9 - 1; i++) 
	{
		for (int j = 0; j < 9 - 1 - i; j++)
		{
			if (arr7[j] > arr7[j + 1])
			{
				int temp = arr7[j + 1];
				arr7[j + 1] = arr7[j];
				arr7[j] = temp;
			}
		}
	}
	cout << "arr7升序输出为：";
	for (int i = 0; i < 9; i++)
	{
		cout << arr7[i] << " ";
	}
	cout << endl;



	system("pause");
	return 0;
}

一节一篇代码，简单粗暴，适合快速学习/复习C++基础知识。

上一节：【0基础学习C++】第3节 C++study_03-CSDN博客 

下一节：【0基础学习C++】第5节 C++study_05-CSDN博客