c++三种排序学习图文笔记（冒泡，插入，快速）

1.冒泡排序

       思路：直白的说就是进行多次比较筛选出最大值，重复上述操作直到排序完成。

假设一个数组中有N个元素，在第一轮想筛选出最大值（两两比较，见下图）则需要比较N-1次；

---

 因为上一轮筛选出的元素已经是最大值了，所以就不用参与下一步循环啦。

故而，第二次循环共有N-1个元素参与，需两两对比（N-1)-1=N-2次。

好，思路分析结束，上代码：

 

int* bubble_sort(int arr[], int len)//这里打算返回排列后数组的首地址int len指数组含元素数量
	{
		for (int i = 0;i < len;i++)//这里的“i”用来纪录循环次数；i<len是因为我们只需要重复
		{                          //0~len-1，即len次筛选出最大值的操作（总共才len个元素.....）
 
			for (int j = 0;j < len - i-1;j++)//len-i表示需要两两对比多少次。如在第一轮比较（i==0）两两对比len-1次
			{                                //第二轮（i==1），对比len-2次，第三轮比较（i==2）,对比len-3次.....................
				                             //所以在第i+1论比较中，需要对比len-i-1次；
 
				if (arr[j] > arr[j + 1])//判断相邻元素大小
				{
					int temp = arr[j];
					arr[j] = arr[j + 1];//如果前一个元素大于后一个元素则进行换位
					arr[j + 1] = temp;
				}
			}
		}
		return arr;//最后返回排序后数组的首地址
	}

(注释比代码还多QAQ....)

2.插入排序

           思路：以第一个元素为起点与第二个元素比较大小，决定“插入”到哪里，然后第一个元素和第二个元素组成一个“新数组”，第三个元素从“新数组”的第一个元素开始比较，决定“插入”的位置，然后它们再组成一个“新数组”，第四个元素再重复上述操作.........以此类推，直到所以元素全部2插入。

（表达不好QAQ...还是上图吧！）

好，又到了上代码时间——码来！！！！ 

int* insert_sort(int arr[], int len)//len表示数组中元素个数....
	{
		cout << "insert_sort运行" << endl;

		for (int i = 1;i < len;i++)//这个循环表示需要插入的次数len-1（第一个元素不用插入）
		{                          //同时i表示当前需要插入元素的下标

			int temp = arr[i], idx = i-1;//temp记录插入数据，在之后的后移操作中arr[i]处的元素会被覆盖掉
			for (;idx >= 0 && temp < arr[idx];idx--)//如果待插入数据小于数组中某元素
				arr[idx+1] = arr[idx];              //就把arr[idx}后移一位（该操作会覆盖掉后一位数据的值）
			
			arr[idx+1] = temp;//插入
		}
		return arr;//最后返回排序后数组的首地址
	}

3.快速排序

          思路：呃......有点像是二分法。大概就是认定数组中一个元素为“基数”，以这个基数为界，大于这个基数的元素放该基数右边，小于这个基数的元素放该基数左边，见下图：

###我图嘞？？？？

void quick_sort(int arr[], int len)
	{
		cout << "quick_sort运行" << endl;

		int left = 0, right = len - 1;//确定数组索引的上下界

		int pivot = arr[right], l = left, r = right, temp;//pivot为认定的基数（这个不定，可以自由决定）
                                                          //temp仍然是互换的中间量

		while(l<r)
		{
			temp = arr[l]; arr[l] = arr[r];arr[r] = temp;//然后交换这两个找到的元素

			while (l<r && arr[r]>pivot)--r;//从右往左遍历数组寻找一个小于基数的元素，找到后退出当前循环，r记录该元素的下标
			while (l < r && arr[l] <= pivot)++l;//从左往右遍历寻找一个大于基数的元素，找到后退出当前循环，l记录该元素的下标

		}//l==r退出循环，第一次数组二分结束：以pivot为界在其左边元素全是小于pivot的元素（无序），其右全是大于pivot的元素（无序）


		//之后更新基准和上下界，以递归的方式重复循环上述操作，直到分无可分，排序结束
		temp = arr[left]; arr[left] = arr[r];arr[r] = temp;
		if (left < r)quick_sort(&arr[left], l - left);
		if (r < right)quick_sort(&arr[r + 1], right - r);
	}

附上全部代码：

#include<iostream>
using namespace std;

class Sort
{
public:

	int* bubble_sort(int arr[], int len)//这里打算返回排列后数组的首地址int len指数组含元素数量
	{
		cout << "bubble_sort运行" << endl;
		for (int i = 1;i < len;i++)//这里的“i”用来纪录循环次数；i<len是因为我们只需要重复
		{                          //0~len-1，即len次筛选出最大值的操作（总共才len个元素.....）

			for (int j = 0;j < len - i;j++)//len-i表示需要两两对比多少次。如在第一轮比较（i==1）两两对比len-1次
			{                                //第二轮（i==2），对比len-2次，第三轮比较（i==3）,对比len-3次.....................
				                             //所以在第i论比较中，需要对比len-i次；

				if (arr[j] > arr[j + 1])//判断相邻元素大小
				{
					int temp = arr[j];
					arr[j] = arr[j + 1];//如果前一个元素大于后一个元素则进行换位
					arr[j + 1] = temp;
				}
			}
		}
		return arr;//最后返回排序后数组的首地址
	}

	int* insert_sort(int arr[], int len)//len表示数组中元素个数....
	{
		cout << "insert_sort运行" << endl;

		for (int i = 1;i < len;i++)//这个循环表示需要插入的次数len-1（第一个元素不用插入）
		{                          //同时i表示当前需要插入元素的下标

			int temp = arr[i], idx = i-1;//temp记录插入数据，在之后的后移操作中arr[i]处的元素会被覆盖掉
			for (;idx >= 0 && temp < arr[idx];idx--)//如果待插入数据小于数组中某元素
				arr[idx+1] = arr[idx];              //就把arr[idx}后移一位（该操作会覆盖掉后一位数据的值）
			
			arr[idx+1] = temp;//插入
		}
		return arr;//最后返回排序后数组的首地址
	}

	void quick_sort(int arr[], int len)
	{
		cout << "quick_sort运行" << endl;

		int left = 0, right = len - 1;//确定数组索引的上下界

		int pivot = arr[right], l = left, r = right, temp;//pivot为认定的基数（这个不定，可以自由决定）
                                                          //temp仍然是互换的中间量

		while(l<r)
		{
			temp = arr[l]; arr[l] = arr[r];arr[r] = temp;//然后交换这两个找到的元素

			while (l<r && arr[r]>pivot)--r;//从右往左遍历数组寻找一个小于基数的元素，找到后退出当前循环，r记录该元素的下标
			while (l < r && arr[l] <= pivot)++l;//从左往右遍历寻找一个大于基数的元素，找到后退出当前循环，l记录该元素的下标

		}//l==r退出循环，第一次数组二分结束：以pivot为界在其左边元素全是小于pivot的元素（无序），其右全是大于pivot的元素（无序）


		//之后更新基准和上下界，以递归的方式重复循环上述操作，直到分无可分，排序结束
		temp = arr[left]; arr[left] = arr[r];arr[r] = temp;
		if (left < r)quick_sort(&arr[left], l - left);
		if (r < right)quick_sort(&arr[r + 1], right - r);
	}

};
void Cout(int* p, int len)
{
	for (int i = 0;i < len;i++)
	{
		cout << *p << ",";
		p++;
	}
	cout << endl;
}

int main()
{
	//测试
	int arr1[] = { 2,1,5,3,6,4,9,5,34,3,5,3,5 };
	Sort s;
	//
	int*p1=s.bubble_sort(arr1, 13);
	Cout(p1, 13);
	//
	int arr2[] = { 2,1,5,3,6,4,9,5,34,3,5,3,5 };
	int* p2 = s.insert_sort(arr2, 13);
	Cout(p2, 13);
	//
	int arr3[] = { 2,1,5,3,6,4,9,5,34,3,5,3,5 };
   	s.quick_sort(arr3,13);
	Cout(arr3, 13);
	 
	return 0;
}

结果如图：

欧克，至此c++入门三大排序🆗啦！