浅析常用排序算法

最新推荐文章于 2024-07-20 22:53:12 发布

djh512

最新推荐文章于 2024-07-20 22:53:12 发布

阅读量732

点赞数

本文链接：https://blog.youkuaiyun.com/djh512/article/details/8988369

版权

1.排序算法的评价

涉及到时间复杂度(最差、平均、最好)

空间复杂度（需要额外的内存空间）

稳定性（两个相等键值R和S，原串R在S前，排序后R还在S前，称为稳定）

2.涉及到的排序算法

插入排序、冒泡排序、选择排序、快速排序、堆排序、归并排序、基数排序、希尔排序。

3.插入排序

源数据集： 64 5 7 89 5 24 32 18 40

初始化： {64} 5 7 89 5 24 32 18 40

第一次排序： {5 64} 7 89 5 24 32 18 40

第二次排序 {5 7 64} 89 5 24 32 18 40

第三次排序 {5 7 64 89} 5 24 32 18 40

第四次排序 {5 5 7 64 89} 24 32 18 40

第五次排序 {5 5 7 24 64 89} 32 18 40

第六次排序 {5 5 7 24 32 64 89} 18 40

第七次排序 {5 5 7 18 24 32 64 89} 40

第八次排序 {5 5 7 18 24 32 64 89 40}

函数代码

template<class T>
void InsertSort(T arr[], int len)
{
	for (int i = 0; i < len - 1; i++)
	{
		int j = i;
		T temp = arr[i+1];
		while (temp < arr[j] && j >= 0)
		{
			arr[j+1] = arr[j];
			j--;
		}
		arr[j+1] = temp;
	}
}

时间复杂度：最好情况 O(n) 最坏情况O(n*n) 平均情况O(n*n)

稳定性：稳定

空间复杂度：O(1)

4. 冒泡排序

源数据集： 64 5 7 89 5 24 32 18 40

第一次排序： 5 7 64 5 24 32 18 40 89

第二次排序 5 7 5 24 32 18 40 64 89

第三次排序 5 5 7 24 18 32 40 64 89

第四次排序 5 5 7 18 24 32 40 64 89

第五次排序 5 5 7 18 24 32 40 64 89

函数代码

template<class T>
void BubbleSort(T arr[], int len)
{
	bool cmpFlag = true;
	for (int i = 0; i < len - 1 && cmpFlag; i++)
	{
		cmpFlag = false;
		for (int j = 0; j < len - i - 1; j++)
		{
			if (arr[j] > arr[j+1])
			{
				Swap(arr[j], arr[j+1]);
				cmpFlag = true;
			}
		}
	}
}

时间复杂度：最好情况O(n) 最坏情况O(n*n) 平均情况O(n*n)

稳定性：稳定

空间复杂度：O(1)

5.选择排序

源数据集： 5 7 89 5 24 32 2 40

第一次排序： 2 7 89 5 24 32 5 40 //不稳定的例子

第二次排序 2 5 89 7 24 32 5 40

第三次排序 2 5 5 7 24 32 89 40

第四次排序 2 5 5 7 24 32 89 40

第五次排序 2 5 5 7 24 32 89 40

第六次排序 2 5 5 7 24 32 89 40

第七次排序 2 5 5 7 24 32 40 89

函数代码

template<class T>
void SelectSort(T arr[], int len)
{
	for (int i = 0; i < len - 1; i++)
	{
		T min = arr[i];
		int index = i;
		for (int j = i; j < len; j++)
		{
			if (min > arr[j])
			{
				min = arr[j];
				index = j;
			}
		}

		if (index != i)
			Swap(arr[i], arr[index]);
	}
}

时间复杂度：最好情况 O(n*n) 最坏情况O(n*n) 平均情况O(n*n)

稳定性：不稳定

空间复杂度：O(1)

6.快速排序

源数据集： 64 5 7 89 5 24 32 18 40

第一次快排： 40 5 7 89 5 24 32 18 64

40 5 7 64 5 24 32 18 89

40 5 7 18 5 24 32 64 89

.....................

函数代码

template<class T>
void QuickSort(T arr[], int len)
{
	QuickSort(arr, 0, len-1);
}

template<class T>
void QuickSort(T arr[], int low, int high)
{
	if (low >= high)
		return;

	T key = arr[(low+high)/2];
	int i = low, j = high;

	while (i < j)
	{
		while (i < j && arr[j] > key)
			j--;
		while (i < j && arr[i] < key)
			i++;

		if (i < j)
		{
			Swap(arr[i], arr[j]);
			i++;
			j--;
		}

		if (i >= j)
			break;
	}

	QuickSort(arr, low, j);
	QuickSort(arr, j+1, high);
}

时间复杂度：最好情况O(nlog2n) 最坏情况O(n*n) 平均情况O(nlog2n)

稳定性：不稳定

空间复杂度：平均O(log2n)

7.堆排序

函数代码

template<class T>
void CreateHeap(T arr[], int n, int h)
{
	int i = h;
	int j = 2 * i + 1;
	T temp = arr[i];
	bool flag = true;

	while (j < n && flag)
	{
		if (j < n - 1 && arr[j] < arr[j+1])
			j++;

		if (temp > arr[j])
		{
			flag = false;
		}
		else
		{
			arr[i] = arr[j];
			i = j;
			j = 2 * i + 1;
		}
	}

	arr[i] = temp;
}

template<class T>
void InitCreateHeap(T arr[], int len)
{
	for (int i = (len - 1) / 2; i >=0; i--)
		CreateHeap(arr, len,i);
}

template<class T>
void HeapSort(T arr[], int len)
{
	InitCreateHeap(arr, len);

	for (int i = len - 1; i > 0; i--)
	{
		T temp = arr[0];
		arr[0] = arr[i];
		arr[i] = temp;

		CreateHeap(arr, i, 0);
	}
}

时间复杂度：最好情况 O(nlog2n) 最坏情况O(nlog2n) 平均O(nlog2n)

稳定性: 不稳定

空间复杂度: O(1)