C++实现六种排序算法详解及应用-优快云博客

本文链接：https://blog.youkuaiyun.com/Dedication_/article/details/119638987

一、六大排序

1. 选择排序

//平均时间复杂度O(n2) 最好时间复杂度O(n2) 空间复杂度O(1)
//选择排序，每次选择最值进行交换
void Select_sort(vector<int>& nums) {
	//！注意j从i+1开始  每次挑选最小值
	for (int i = 0; i < nums.size(); ++i) {
		int min_index = i;
		for (int j = i + 1; j < nums.size(); ++j)
			if (nums[j] < nums[min_index])
				min_index = j;
		int tmp = nums[i];
		nums[i] = nums[min_index];
		nums[min_index] = tmp;
	}
}

2. 插入排序

//平均时间复杂度O(n2) 最好时间复杂度O(n) 空间复杂度O(1)
//插入排序,待插入元素从数组后往前扫描找到合适位置插入
void Insert_sort(vector<int>& nums) {
	for (int i = 1; i < nums.size(); ++i) {
		int cur = nums[i];
		int preindex = i - 1;
		//！注意插入位置后的元素集体后移
		while (preindex >= 0 && nums[preindex] > cur) {
			nums[preindex + 1] = nums[preindex];
			--preindex;
		}
		//！插在第一个不满足要求的元素后面
		nums[preindex+1] = cur;
	}
}

3. 冒泡排序

//平均时间复杂度O(n2) 最好时间复杂度O(n) 空间复杂度O(1)
//冒泡排序，遇到逆序对就交换，保证位置的最值性
void Bubble_sort(vector<int> &nums) {
	//！注意j从i+1开始
	for(int i=0;i<nums.size();++i)
		for(int j=i+1;j<nums.size();++j)
			if (nums[i] > nums[j]) {
				int tmp = nums[i];
				nums[i] = nums[j];
				nums[j] = tmp;
			}
}

4. 归并排序

//平均时间复杂度O(nlogn) 最坏时间复杂度O(nlogn) 空间复杂度O(n)
//归并排序，递归结束条件，二分数组，数组归并
void M_sort(vector<int> &nums, vector<int>& tmp,int left,int right) {
	//1、递归结束条件
	if (left >= right)
		return;
	//2、数组划分，递归
	int mid = (left + right) / 2;
	M_sort(nums, tmp, left, mid);
	M_sort(nums, tmp, mid + 1, right);
	//3、数组合并
	int one_p = left, two_p = mid + 1,len = left;
	//3.1 原数组复制
	for (int k = left; k <= right; k++)
		tmp[k] = nums[k];
	//3.2 数组交替更新
	while (one_p <= mid && two_p <= right) {
		if (nums[one_p] < nums[two_p])
			nums[len++] = tmp[one_p++];
		else
			nums[len++] = tmp[two_p++];
	}
	//3.3 数组单方更新
	while (one_p <= mid)
		nums[len++] = tmp[one_p++];
	while (two_p <= right)
		nums[len++] = tmp[two_p++];
}

5. 快排

//平均时间复杂度O(nlogn) 最坏时间复杂度O(n2) 空间复杂度O(1)
//快速排序，确定中枢，进行左右的大小交换
int Partition(vector<int>& arr, int low, int high)
{	
	//1、选择第一个元素为中枢
	int p = arr[low];
	while (low < high) {
		//2、找到右边第一个小于中枢的值,进行交换
		while (low < high && arr[high] >= p)    high--;
		arr[low] = arr[high];
		//3、找到左边第一个大于中枢的值，进行交换
		while (low < high && arr[low] <= p)     low++;
		arr[high] = arr[low];
	}
	//4、将中枢放入最终low位置
	arr[low] = p;
	//5、返回枢轴位置
	return low;
}
void Q_sort(vector<int>& arr, int low, int high)//递归
{
	//0、递归终止条件
	if (low < high) {
		//1、确定中枢位置
		int p = Partition(arr, low, high);
		//2、根据中枢进行二分
		//！！！注意中枢不再参与排序，位置已经确定
		Q_sort(arr, low, p - 1);
		Q_sort(arr, p + 1, high);
	}
}

6. 堆排

//平均时间复杂度O(nlogn) 最坏时间复杂度O(nlogn) 空间复杂度O(1)
//堆排序，不断调整树的状态
void max_heapify(vector<int>& arr, int begin, int end) {
    int dad = begin;
    int son = dad * 2 + 1;
    while (son <= end) {
        if (son+1 <= end && arr[son] < arr[son+1])//挑选出较大的儿子
            son++;
        if (arr[dad] < arr[son]) {//看儿子是否大于老爸
            swap(arr[dad], arr[son]);
            dad = son;
            son = dad * 2 + 1;
        }
        else
            return;
    }
}
void heap_sort(vector<int>&arr, int begin, int end) {
    //构建大根堆
    for (int i = arr.size() / 2 - 1; i >= 0; i--)
        max_heapify(arr, i, end);
    //调整大根堆
    for (int i = end; i>=0; i--) {
        swap(arr[0], arr[i]);
        max_heapify(arr,0, i - 1);
    }
}