十大排序（C++版）

深思沉浮

已于 2023-03-05 17:48:13 修改

阅读量559

点赞数 2

分类专栏：算法文章标签： c++ 算法排序算法

于 2023-03-04 19:46:26 首次发布

本文链接：https://blog.csdn.net/weixin_50202509/article/details/129338252

版权

算法专栏收录该内容

5 篇文章 0 订阅

订阅专栏

文章介绍了LeetCode中涉及到的几种排序算法，包括冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序和基数排序。每种排序算法都提供了C++实现，并分析了它们的时间复杂度和空间复杂度，以及在某些情况下的性能问题，如可能会导致超时的情况。

摘要由CSDN通过智能技术生成

测试排序的题目：

912. 排序数组 - 力扣（LeetCode）

在这里插入图片描述

堕落的做法：

class Solution 
{
public:
    vector<int> sortArray(vector<int>& nums) 
    {
        sort(nums.begin(),nums.end());
        return nums;
    }
};

视频推荐：

91.基数排序的原理_哔哩哔哩_bilibili

排序算法	时间复杂度(平均)	时间复杂度(最好)	时间复杂度(最坏)	空间复杂度	稳定性
冒泡排序	O(n^2)	O(n)	O(n^2)	O(1)	稳定
选择排序	O(n^2)	O(n^2)	O(n^2)	O(1)	不稳定
插入排序	O(n^2)	O(n^2)	O(n^2)	O(1)	稳定
希尔排序	O(n^1.5)	O(n)	O(n^2)	O(1)	不稳定
归并排序	O(nlogn)	O(nlogn)	O(nlogn)	O(n)	稳定
快速排序	O(nlogn)	O(nlogn)	O(n^2)	O(logn)	不稳定
堆排序	O(nlogn)	O(nlogn)	O(nlogn)	O(1)	不稳定
计数排序	O(n+k)	O(n+k)	O(n+k)	O(k)	稳定
桶排序	O(n+k)	O(n+k)	O(n^2)	O(n+k)	稳定
基数排序	O(n*k)	O(n*k)	O(n*k)	O(n+k)	稳定

冒泡排序

在这里插入图片描述

算法步骤：
1. 比较相邻的元素：若第一个比第二个大，则交换；
2. 遍历开始第一对到结尾最后一对，执行步骤1；
3. 重复步骤1~2，直到排序完成。

class Solution 
{
public:
    vector<int> sortArray(vector<int>& nums) 
    {
        int n = nums.size();
        for (int i = 0; i < n - 1; ++i) 
        {
            bool flag = false;
            for (int j = 0; j < n - 1 - i; ++j) 
            {
                if (nums[j] > nums[j + 1]) 
                {
                    swap(nums[j], nums[j + 1]);
                    flag = true;
                }                 
            }
            if (flag == false) break; //优化点：无交换代表已经排好序了
        }
        return nums;
    }
};

注意：本题中使用冒泡排序过不去，会超时

选择排序

在这里插入图片描述

算法步骤：
1. 初始状态：无序序列为R[0,n−1]，长度n，有序区为空；
2. 第i=1,…,n−1趟排序从当前无序区R[i−1,n−1]中选出最小的元素R[k]，并将它与无序区的第1个记录R[i−1]交换，则R[0,i−1]变为元素个数增加1的新有序区，R[i,n−1]变为元素个数减少1的新无序区；
3. n−1趟选择交换后结束。

class Solution 
{
public:
	vector<int> sortArray(vector<int>& nums)
	{
		int n = nums.size();
		for (int i = 0; i < n; i++)
		{
			int minindex = i;
			for (int j = i + 1; j < n; j++)
			{
				if (nums[j] < nums[minindex]) minindex = j;
			}
			swap(nums[i], nums[minindex]);
		}
		return nums;
	}
};

注意：本题中使用选择排序过不去，会超时

插入排序

算法步骤：
1. 从第一个元素开始，该元素认为已经被排序；
2. 取下一个元素，在已经排序的元素序列中从后向前扫描；
3. 如果已排序元素大于新元素，将已排序元素移到下一位置；
4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
5. 将新元素插入到该位置后；
6. 重复步骤2~5。

普通版本：

class Solution 
{
public:
	vector<int> sortArray(vector<int>& nums)
	{
		int n = nums.size();
		for (int i = 1; i < n; i++)
		{
			int currnumber = nums[i];
			int j = i - 1;
			for (; j >= 0; j--)
			{
				if (nums[j] >= currnumber) swap(nums[j], nums[j + 1]);
				else break;
			}
			swap(currnumber, nums[j + 1]);
		}
		return nums;
	}
};

时间复杂度：最好O(n)最坏O(n^2)

空间复杂度：O(1)

希尔排序、

算法步骤：
1. 选择一个增量序列T1，T2，… ，Tk，其中Ti>Tj，Tk=1，i>j；
2. 每趟排序，根据对应的增量Ti，将待排序列分割成若干子序列，分别对各子序列进行直接插入排序；
3. 按增量序列个数k，对序列进行k趟排序。

class Solution 
{
public:
	vector<int> sortArray(vector<int>& nums) 
	{
		int n = nums.size();
		// 分组，最开始时，间隔T为数组的一半
		for (int T = n / 2; T >= 1; T /= 2) 
		{
			//对分组进行插入排序
			for (int i = T; i < n; ++i)
			{
				shellSort(nums, T, i);
			}
		}
		return nums;
	}
    void shellSort(vector<int>& nums, int T, int i) 
	{
		int j, tmp = nums[i];
		for (j = i - T; j >= 0 && tmp < nums[j]; j -= T) 
		{
			nums[j + T] = nums[j];
		}
		nums[j + T] = tmp;
	}
};

第一个通过的排序

归并排序

算法步骤：
1. 把长度为n的输入序列分成两个长度为n/2的子序列；
2. 对这两个子序列分别采用归并排序；
3. 将两个排序好的子序列合并成一个最终的排序序列。

class Solution 
{
public:
	vector<int> sortArray(vector<int>& nums)
	{
		res.resize(nums.size(), 0);
		MerageSort(nums, 0, nums.size() - 1);
		return nums;
	}
	void MerageSort(vector<int>& nums, int left, int right)
	{
		if (left >= right) return;
		int mid = (left + right) / 2;
		MerageSort(nums, left, mid);
		MerageSort(nums, mid + 1, right);
		int l = left, r = mid + 1, i = left;
		while (l <= mid && r <= right)
		{
			if (nums[l] < nums[r]) res[i++] = nums[l++];
			else res[i++] = nums[r++];
		}
		while (l <= mid) res[i++] = nums[l++];
		while (r <= right) res[i++] = nums[r++];
		for (int i = left; i <= right; i++) nums[i] = res[i];
	}
private:
	vector<int> res;
};

归并排序最好情况下：O（nlogn），最坏情况下 O（nlogn）,归并排序的空间复杂度 O（n），如果使用的是堆上空间，则操作时间可能更长（分配销毁时间太长）

快速排序

算法步骤：

从数列中挑出一个元素，称为基准pivot；
分区partition操作：比基准值小的元素放在左边，比基准值大的元素放在右边；
递归recursive：把小于基准值元素的子数列和大于基准值元素的子数列分别递归排序。

普通的快排(选取中间点)：

class Solution 
{
public:
	vector<int> sortArray(vector<int>& nums)
	{
		QuickSort(nums, 0, nums.size() - 1);
		return nums;
	}
	void QuickSort(vector<int>& nums, int left, int right)
	{
		if (left >= right) return;

		int x = nums[(left + right) / 2], l = left - 1, r = right + 1;

		while (l < r)
		{
			do l++; while (nums[l] < x);
			do r--; while (nums[r] > x);
			if (l < r)	swap(nums[l], nums[r]);
		}
		QuickSort(nums, left, r);
		QuickSort(nums, r + 1, right);
	}
};

优化后的快排(随机选点)

class Solution 
{
public:
	vector<int> sortArray(vector<int>& nums)
	{
		QuickSort(nums, 0, nums.size() - 1);
		return nums;
	}
	void QuickSort(vector<int>& nums, int left, int right)
	{
		if (left >= right) return;

		int x = nums[rand() % (right - left + 1) + left], l = left - 1, r = right + 1;

		while (l < r)
		{
			do l++; while (nums[l] < x);
			do r--; while (nums[r] > x);
			if (l < r)	swap(nums[l], nums[r]);
		}
		QuickSort(nums, left, r);
		QuickSort(nums, r + 1, right);
	}
};

**rand() % (b-a+1)+ a ** 就表示 a~b 之间的一个随机整数。

快速排序最好情况下：O（nlogn），最坏情况下退化为选择排序（例如每次选择的都是最大值，之后遍历左边的 n -1 序列）：O（n^2）

堆排序

算法步骤：
1. 将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
2. 将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn)，且满足R[1,2…n-1]<=R[n]；
3. 由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

class Solution 
{
public:
	vector<int> sortArray(vector<int>& nums) 
	{
		// heapSort 堆排序
		int n = nums.size();
		// 将数组整理成大根堆
		buildMaxHeap(nums);
		for (int i = n - 1; i >= 1; --i) 
		{
			// 依次弹出最大元素，放到数组最后，当前排序对应数组大小 - 1
			swap(nums[0], nums[i]);
			--n;
			maxHeapify(nums, 0, n);
		}
		return nums;
	}
	void buildMaxHeap(vector<int>& nums)
	{
		int n = nums.size();
		for (int i = (n - 1) / 2; i >= 0; --i)//从最后一个节点的父节点开始进行堆排序
		{
			maxHeapify(nums, i, n);
		}
	}

	void maxHeapify(vector<int>& nums, int i, int n)
	{
		while (i * 2 + 1 < n)
		{
			// 代表当前 i 节点的左右儿子；
			// 超出数组大小则代表当前 i 节点为叶子节点，不需要移位
			int lSon = 2 * i + 1;
			int rSon = 2 * i + 2;
			int large = i;
			if (lSon < n && nums[lSon] > nums[i]) large = lSon;
			if (rSon < n && nums[rSon] > nums[large]) large = rSon;

			if (large != i)
			{
				swap(nums[i], nums[large]);
				// 迭代判断对应子节点及其儿子节点的大小关系
				i = large;
			}
			else//若当前根节点和左右节点和维持大根堆则跳出循环
			{
				break;
			}
		}
	}
};

什么是堆？堆有哪些特征？

堆是一个可以被看做一棵树的数组对象，它的形状特征是完全二叉树且是顺序存储，数值特征：根总是优于左孩子和右孩子。

堆中的父结点和孩子结点的下标有什么特征

若 pos 是父亲节点下标（其节点编号是 pos + 1），左孩子的下标就是 2pos +1，右孩子是 2pos + 2

简述堆排序的流程：

1、对N个无序元素的数组简历大根堆

从最后一个父亲节点开始，向前循环

先比较左右孩子，再用胜者与父亲比较，如果孩子胜利，交换父亲和孩子，再重复检查交换后原父亲的稳定性。

2、交换堆顶和末尾元素，缩小堆的规模，从新的根节点出发，重建堆。

3、循环步骤2，堆的规模从n到2.

计数排序

算法步骤：
1. 找出待排序的数组中最大和最小的元素；
2. 统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
3. 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
4. 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。

class Solution {
public:
	vector<int> sortArray(vector<int>& nums) 
	{
		// CountSort 计数排序
		int n = nums.size();
		int minNum = INT_MAX, maxNum = INT_MIN;
		// 找到数组中的最小和最大元素 这里面最小的那个可能为负数
		for (int i = 0; i < n; ++i) 
		{
			if (nums[i] < minNum) minNum = nums[i];
			if (nums[i] > maxNum) maxNum = nums[i];
		}
		// 构造计数数组
		vector<int> counts(maxNum - minNum + 1, 0);
		for (int i = 0; i < n; ++i) 
		{
			++counts[nums[i] - minNum];
		}
		// 计数排序
		int index = 0;
		for (int i = 0; i < counts.size(); ++i) 
		{
			while (counts[i] != 0) 
			{
				nums[index++] = i + minNum;
				counts[i]--;
			}
		}
		return nums;
	}
};

桶排序

算法步骤：
1. 设置一个定量的数组当作空桶；
2. 遍历输入数据，并且把数据一个一个放到对应的桶里去；
3. 对每个不是空的桶进行排序；
4. 从不是空的桶里把排好序的数据拼接起来。

class Solution 
{
public:
	vector<int> sortArray(vector<int>& nums) 
	{
		// BucketSort 桶排序
		int n = nums.size();
		// 获取数组的最小值和最大值
		int maxNum = nums[0], minNum = nums[0];
		for (int i = 1; i < n; ++i) 
		{
			if (nums[i] > maxNum) maxNum = nums[i];
			if (nums[i] < minNum) minNum = nums[i];
		}
		// 初始化桶
		int bucketNum = 5, bucketSize = (maxNum - minNum) / bucketNum + 1;
		vector<vector<int>> buckets(bucketNum, vector<int>(0));
		// 小至大分桶
		for (int num : nums) 
		{
			int bucketIndex = (num - minNum) / bucketSize;
			buckets[bucketIndex].emplace_back(num);
		}
		// 桶内排序
		for (int i = 0; i < buckets.size(); ++i) 
		{
			sort(buckets[i].begin(), buckets[i].end());
		}
		// 从桶中依次取数
		int index = 0;
		for (auto& bucket : buckets) 
		{
			for (int num : bucket) 
			{
				nums[index++] = num;
			}
		}

		return nums;
	}
};

基数排序

算法步骤：
1. 取得数组中的最大数，并取得位数；
2. arr为原始数组，从最低位开始取每个位组成radix数组；
3. 对radix进行计数排序（利用计数排序适用于小范围数的特点）；

class Solution {
	
public:
	vector<int> sortArray(vector<int>& nums) 
	{
		// RadixSort 基数排序
		int n = nums.size();
		// 预处理，让所有的数都大于等于0
		for (int i = 0; i < n; ++i) 
		{
			nums[i] += 50000; // 50000为最小可能的数组大小
		}
		// 找出最大的数字，并获得其最大位数
		int maxNum = nums[0];
		for (int i = 0; i < n; ++i) 
		{
			if (nums[i] > maxNum) maxNum = nums[i];
		}
		int num = maxNum, maxLen = 0;
		while (num) 
		{
			++maxLen;
			num /= 10;
		}
		// 基数排序，低位优先
		int divisor = 1;
		for (int i = 0; i < maxLen; ++i) 
		{
			radixSort(nums, divisor);
			divisor *= 10;
		}
		// 减去预处理量
		for (int i = 0; i < n; ++i) 
		{
			nums[i] -= 50000;
		}
		return nums;
	}
	void radixSort(vector<int>& nums, int divisor)//divisor 目标位
	{
		vector<vector<int>> bucket(10, vector<int>(0, 0));//桶
		for (int i = 0; i < nums.size(); i++)//根据目标位的大小依次放入桶中
		{
			int number = nums[i] / divisor % 10;
			bucket[number].push_back(nums[i]);
		}
		for (int i = 0, index = 0; i < bucket.size(); i++)//从桶中取出并放入到nums中
		{
			for (int j = 0; j < bucket[i].size(); j++)
			{
				nums[index++] = bucket[i][j];
			}
		}
	}
};