八大排序（二）堆排序，快速排序，归并排序，计数排序

已于 2024-06-21 16:24:24 修改
阅读量132 收藏 11
点赞数 14
分类专栏： 数据结构 文章标签： 数据结构 算法 c语言
于 2023-11-21 19:44:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_75172965/article/details/134536815
版权

目录

一.堆排序

（1）原理：

（2）代码实现

（3）时间空间复杂度与算法稳定性

时间复杂度

空间复杂度

算法稳定性

二.快速排序

（1）原理

（2）不同版本快速排序

1.hoare版本

2.挖坑法

3.前后指针

4.非递归

（3）时间空间复杂度与算法稳定性

三.归并排序

（1）原理：

（2）代码实现

（3）非递归下的归并排序

（4）时间空间复杂度及算法稳定性

时间复杂度

空间复杂度

算法稳定性

四.计数排序

（1）原理

（2）代码实现

（3）时间空间复杂度及算法稳定性

​编辑

一.堆排序

（1）原理：

在了解原理之前，我们先来了解什么是堆？

堆是一个数组。它满足两个特点：

1.完全二叉树

2.任一结点的值都是其子树所有结点的最大值①或最小值②

情况①：为最大堆

ab1cb8cb12144f1d81006f4688c6870f.png

②为最小堆

6e03b781faac49a797ed0a7ebe5d34e7.png

原理：

堆排序其实就是利用堆的第二个特点：任一结点的值都是其子树所有结点的最大值或最小值。

只要将需要排序的数组建立成堆，然后每次取出根结点，就把剩下的结点调整成堆；再取出根结点，如此下去，最后便能得到排好序的数据。

6d76fe72cf71421f8aac79a82b6ca705.gif

（2）代码实现

堆排序主体代码如下：

void AdjustDown(int* hph, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && hph[child + 1] > hph[child])
		{
			++child;
		}
		if (hph[child] > hph[parent])
		{
			swap(&hph[child], &hph[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
void Heapsort(int* a, int n)
{
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}
	int end = n - 1;
	while (end > 0)
	{
		swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}

（3）时间空间复杂度与算法稳定性

时间复杂度

时间复杂度：堆排序包括建堆和排序两个操作，建堆过程的时间复杂度是O(n) ，排序过程的时间复杂度是O(nlogn)，所以，堆排序整体的时间复杂度是 O(nlogn)。

空间复杂度

空间复杂度： 因为堆排序是就地排序，空间复杂度为常数：O(1)

算法稳定性

稳定性：不稳定。因为在堆的调整过程中，元素进行比较和交换所走的是该结点到叶子结点的一条路径，因此对于相同的元素就可能出现排在后面的元素被交换到前面来的情况。

二.快速排序

（1）原理

快速排序采用的是分治思想，即在一个无序的序列中选取一个任意的基准元素pivot，利用pivot将待排序的序列分成两部分，前面部分元素均小于或等于基准元素，后面部分均大于或等于基准元素，然后采用递归的方法分别对前后两部分重复上述操作，直到将无序序列排列成有序序列。

（2）不同版本快速排序

快速排序的主框架为：

// 假设按照升序对array数组中[left, right)区间中的元素进行排序

void QuickSort(int array[], int left, int right)
{
 if(right - left <= 1)
 return;
 
 // 按照基准值对array数组的 [left, right)区间中的元素进行划分

 int div = partion(array, left, right);
 
 // 划分成功后以div为边界形成了左右两部分 [left, div) 和 [div+1, right)

 // 递归排[left, div)

 QuickSort(array, left, div);
 
 // 递归排[div+1, right)

 QuickSort(array, div+1, right);
}

我们下面来介绍不同版本的快速排序：

将区间按照基准值划分为左右两半部分的常见方式有：

1.hoare版本

f0387b78a97e4a7197698378a623542d.webp

hoare版本主体代码为：

int GetMidi(int* a, int left, int right)//避免大量重复数据带来的负面影响
{
	int mid = (left + right) / 2;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[mid] > a[right])
		{
			if (a[left] < a[right])
			{
				return left;
			}
			else
				return right;
		}
	}
	if (a[left] > a[mid])
	{
		if (a[left] < a[right])
		{
			return left;
		}
		else if (a[left] > a[right])
		{
			if (a[right] > a[mid])
			{
				return right;
			}
			else
				return mid;
		}
	}
}
int partsort1(int* a, int left, int right)
{
	int midi = GetMidi(a, left, right);
	swap(&a[left], &a[midi]);
	int key = left;
	while (left < right)
	{
		//找小
		while (left < right && a[right] >= a[key])
		{
			right--;
		}
		while (left < right && a[left] <= a[key])
		{
			left++;
		}
		swap(&a[left], &a[right]);
	}
	swap(&a[key], &a[left]);
	return left;
}
void Quicksort(int* a, int begin, int end)
{
	if (begin >= end)
		return;
	if ((end - begin + 1) > 10)
	{
		int keyi = partsort1(a, begin, end);
		Quicksort(a, begin, keyi - 1);
		Quicksort(a, keyi + 1, end);
	}
	else
	{
		Insertsort(a + begin, end - begin + 1);
	}
}

2.挖坑法

5b6f4dbe5737490a8fa6b1fe37917515.gif

挖坑法版本主体代码为：

int GetMidi(int* a, int left, int right)
{
	int mid = (left + right) / 2;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[mid] > a[right])
		{
			if (a[left] < a[right])
			{
				return left;
			}
			else
				return right;
		}
	}
	if (a[left] > a[mid])
	{
		if (a[left] < a[right])
		{
			return left;
		}
		else if (a[left] > a[right])
		{
			if (a[right] > a[mid])
			{
				return right;
			}
			else
				return mid;
		}
	}
}
//挖坑法
int partsort2(int* a, int left, int right)
{
	int midi = GetMidi(a, left, right);
	swap(&a[left], &a[midi]);
	int key = a[left];
	int hole = left;
	while (left < right)
	{
		while (left < right && a[right] >= key)
		{
			right--;
		}
		a[hole] = a[right];
		hole = right;
		while (left < right && a[left] <= key)
		{
			left++;
		}
		a[hole] = a[left];
		hole = left;
	}
	a[hole] = key;
	return hole;
}
void Quicksort(int* a, int begin, int end)
{
	if (begin >= end)
		return;
	if ((end - begin + 1) > 10)
	{
		int keyi = partsort3(a, begin, end);
		Quicksort(a, begin, keyi - 1);
		Quicksort(a, keyi + 1, end);
	}
	else
	{
		Insertsort(a + begin, end - begin + 1);
	}
}

3.前后指针

55b567f0468343428a3f463d62116707.gif

前后指针版本主体代码为：

int GetMidi(int* a, int left, int right)
{
	int mid = (left + right) / 2;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[mid] > a[right])
		{
			if (a[left] < a[right])
			{
				return left;
			}
			else
				return right;
		}
	}
	if (a[left] > a[mid])
	{
		if (a[left] < a[right])
		{
			return left;
		}
		else if (a[left] > a[right])
		{
			if (a[right] > a[mid])
			{
				return right;
			}
			else
				return mid;
		}
	}
}
//前后指针
int partsort3(int* a, int left, int right)
{
	int prev = left;
	int cur = prev+1;
	int key = left;
	while (cur<=right)
	{
		while (a[prev + 1] < a[key])
		{
			cur++;
			prev++;
		}
		while (cur<=right&&a[cur] > a[key])
		{
			cur++;
		}
		if(cur<=right)
		{
			swap(&a[++prev], &a[cur]);
		}
	}
	swap(&a[key], &a[prev]);
	return prev;
}
void Quicksort(int* a, int begin, int end)
{
	if (begin >= end)
		return;
	if ((end - begin + 1) > 10)
	{
		int keyi = partsort3(a, begin, end);
		Quicksort(a, begin, keyi - 1);
		Quicksort(a, keyi + 1, end);
	}
	else
	{
		Insertsort(a + begin, end - begin + 1);
	}
}

4.非递归

非递归版本的主体代码为：

void STInit(ST* ps)
{
	assert(ps);
	ps->a= NULL;
	ps->top = 0;
	ps->capacity = 0;
}
void STPush(ST* ps, STdatatype x)
{
	assert(ps);
	if(ps->top==ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STdatatype* st = (STdatatype*)realloc(ps->a,sizeof(STdatatype)*newcapacity);
		if (st == NULL)
		{
			perror("relloc failed");
			exit(-1);
		}
		ps->a = st;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
void STPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);
	ps->top--;
}
STdatatype STTop(ST* ps)
{
	assert(ps);
	return ps->a[ps->top-1];
}
int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
bool STEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}
void QuicksortNonr(int* a, int begin, int end)
{
	ST st;
	STInit(&st);
	STPush(&st, end);
	STPush(&st, begin);
	while (!STEmpty(&st))
	{
		int left=STTop(&st);
		STPop(&st);
		int right = STTop(&st);
		STPop(&st);
		int key = partsort1(a, left,right);
		if (key + 1 < right)
		{
			STPush(&st, right);
			STPush(&st, key + 1);
		}
		if (key - 1 > left)
		{
			STPush(&st, key - 1);
			STPush(&st, left);
		}
	}
	STDestory(&st);
}

（3）时间空间复杂度与算法稳定性

5678f382fb5e48a485928429bc93beb5.png

三.归并排序

（1）原理：

归并排序的原理是：

归并排序算法有两个基本的操作，一个是分，也就是把原数组划分成两个子数组的过程。另一个是治，它将两个有序数组合并成一个更大的有序数组。

（1）将待排序的线性表不断地切分成若干个子表，直到每个子表只包含一个元素，这时，可以认为只包含一个元素的子表是有序表。
（2）将子表两两合并，每合并一次，就会产生一个新的且更长的有序表，重复这一步骤，直到最后只剩下一个子表，这个子表就是排好序的线性表。

3cff349d73ed4d878935b43bb77bb6b7.gif

（2）代码实现

归并排序的主体代码为：

void _Mergesort(int* a, int* tmp, int begin, int end)
{
	if(end<=begin)
	{
		return;
	}
	int mid = (begin + end) / 2;
	_Mergesort(a, tmp, begin, mid);
	_Mergesort(a, tmp, mid + 1, end);
	//归并再拷贝回去
	//[begin,mid]  [mid+1,end]
	int begin1 = begin, end1 = mid;
	int begin2 = mid + 1, end2 = end;
	int index = begin;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if(a[begin1] < a[begin2])
		{
			tmp[index++] = a[begin1++];
		}
		else
		{
			tmp[index++] = a[begin2++];
		}
	}
	while (begin1 <= end1)
	{
		tmp[index++] = a[begin1++];
	}
	while (begin2 <= end2)
	{
		tmp[index++] = a[begin2++];
	}
	memcpy(a + begin, tmp + begin, (end - begin + 1) * sizeof(int));
}
void Mergesort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc failed");
		exit(-1);
	}
	_Mergesort(a, tmp, 0, n - 1);
	free(tmp);
}

（3）非递归下的归并排序

非递归归并排序的主体代码为：

void MergesortNonr(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc failed");
		exit(-1);
	}
	int gap = 1;
	while (gap < n)
	{
		for (int i = 0; i < n; i += 2 * gap)
		{
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2 * gap-1;
			int index =i;
			if (begin2 >= n)
			{
				break;
			}
			if (end2 >= n)
			{
				end2 = n - 1;
			}
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
				{
					tmp[index++] = a[begin1++];
				}
				else
				{
					tmp[index++] = a[begin2++];
				}
			}
			while (begin1 <= end1)
			{
				tmp[index++] = a[begin1++];
			}
			while (begin2 <= end2)
			{
				tmp[index++] = a[begin2++];
			}
			memcpy(a + i, tmp + i, (end2-i+1) * sizeof(int));
		}
		gap *= 2;
	}
	free(tmp);
}

（4）时间空间复杂度及算法稳定性

时间复杂度

36bd8f65370748c2a6a2a24628e63c8c.png

空间复杂度

fdb8c710c3da481582bae946876e3bcd.png

算法稳定性

bf4b9159bc4f4d4e9c1eb8b49e0b7d05.png

四.计数排序

（1）原理

84aeac6005ca46b8b4399caf300812a0.png

62bf737e01a3496d83fffda7df76fe5c.gif

（2）代码实现

计数排序的主体代码如下：

void Countsort(int* a, int n)
{
	int min = a[0], max = a[0];
	for (int i = 0; i < n; i++)
	{
		if (a[i] > max)
		{
			max = a[i];
		}
		if (a[i] < min)
		{
			min = a[i];
		}
	}
	int range = max - min + 1;
	int* tmp = (int*)malloc(sizeof(int) * range);
	if (tmp == NULL)
	{
		perror("malloc failed");
		exit(-1);
	}
	memset(tmp, 0, range * sizeof(int));
	for (int i = 0; i < n; i++)
	{
		tmp[a[i] - min]++;
	}
	int j = 0;
	for (int i = 0; i < range; i++)
	{
		while (tmp[i]--)
		{
			a[j++] = i + min;
		}
	}
	free(tmp);
}

（3）时间空间复杂度及算法稳定性

87e7211ecd3344b9956b878c5c4612cb.png

小灵蛇
关注
  • 14
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
黄海安-八大排序算法总结
03-31
**八大排序算法详解** 在计算机科学中，排序算法是用于对一组数据进行排列的算法，它们在编程中扮演着至关重要的角色。以下是黄海安总结的八大经典排序算法的详细介绍： 1. **冒泡排序（Bubble Sort）** 冒泡排序...
常见的八大排序算法及其JAVA实现
04-26
这八大排序算法包括冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序以及计数排序。 1. 冒泡排序（Bubble Sort）： 冒泡排序是最简单的排序算法之一，通过不断地交换相邻两个元素的位置，使较...
归并排序、快速排序、堆排序
dl674756321的博客
12-11 307
归并排序，任何情况下都是O(nlogn)，在合并两个有序数组为一个有序数组时，需要借助额外的存储空间，n/2，n/4，…，1 ，所以空间复杂度为 O(n)。稳定。 public void mergeSort(int[] a) { int n = a.length; if (n <= 1) { return; } ...
排序算法之快速排序、堆排序
花&败
05-17 1426
堆排序是指利用堆这种数据结构所设计的一种排序算法。堆（Heap）是一个近似完全二叉树的结构，并同时满足堆的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。一般情况，将堆顶元素为最大值的叫做“大顶堆”（Max Heap），堆顶为最小值的叫做“小顶堆”。算法简单来说，就是构建一个大顶堆，取堆顶元素作为当前最大值，然后删掉堆顶元素、将最后一个元素换到堆顶位置，进而不断调整大顶堆、继续寻找下一个最大值。
快速排序、归并排序、堆排序的理解及各自应用场景
郝同学的博客
02-21 2671
快速排序、归并排序、堆排序的理解及各自应用场景
计数排序 是最快的排序算法
qq_38314385的博客
04-18 556
计数排序 计数排序是一个非基于比较的排序算法，该算法于1954年由 Harold H. Seward 提出。它的优势在于在对一定范围内的整数排序时， 它的复杂度为Ο(n+k)（其中k是整数的范围），快于任何比较排序算法。 [1] 当然这是一种牺牲空间换取时间的做法，而且当O(k)>O(nlog(n))的时候其效率反而不如基于比较的排序 （基于比较的排序的时间复杂度在理论上的下限是O(nlog(n)), 如归并排序，堆排序） 算法思想 计数排序对输入的数据有附加的限制条件： 1、输入的线性表的元素属于
堆排序，快速排序，归并排序
weixin_44790716的博客
05-17 1503
☆堆排序：效率高，时间复杂度O（N*log2N），空间复杂度O（1），稳定性：不稳定。 //堆排序 //作用：将下标为start-end之间的最大值放在start下标位置 public static void adjust(int[] array,int start,int end){ int tmp=array[start]; for(int i=2*st...
八大排序算法（C语言实现）
热门推荐
2021dragon的博客
05-16 8万+
文章目录插入排序插入排序希尔排序选择排序选择排序堆排序交换排序冒泡排序快速排序并归排序并归排序 插入排序 插入排序 希尔排序 选择排序 选择排序 堆排序 交换排序 冒泡排序 快速排序 并归排序 并归排序 ...
八大排序：直接插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序、计数排序
weixin_62976968的博客
05-30 1454
挑战全网最详细、最直观、最能让你学会的八大排序算法详解过程，我感觉我又行了！
C++实现排序 - 02 归并排序、快速排序和堆排序
Newin2020的博客
06-28 1622
数据结构与算法专栏 —— C++实现归并排序采用了分治法的思想，不断将两个有序的序列进行合并从而最终得到整个有序的序列，算法步骤如下：直接上图：我们先对序列进行划分操作：然后对各个子序列进行回溯：通过合并操作，得到最终的子序列。 快速排序 快速排序也是利用了递归思想，算法步骤如下：直接上图：第一步：选取第一个数作为基准数。第二步：从后往前找一个比基准数小的数放到前面。第三步：从前往后找到一个比基准数大的树放到后面。第四步：继续从后往前查找，发现 first 和 last 重合，本次遍历结束，并将基准数放到指
C/C++实现八大排序算法汇总
09-01
【C/C++实现八大排序算法汇总】 排序算法是计算机科学中的重要组成部分，它们用于组织和优化数据，使得数据按照特定顺序排列。这篇文章主要探讨了在C/C++编程语言中实现的八种不同的内部排序算法，这些算法适用于在...
java实现的八大排序算法 用例 有备注解释
04-11
以下是对Java实现的八大排序算法的详细解释： 1. **冒泡排序（Bubble Sort）**： 冒泡排序是最简单的排序方法之一，它通过重复遍历数组，比较相邻元素并交换位置来完成排序。如果某次遍历没有发生交换，说明已经...
Java实现八大排序算法
09-18
在这里，我们将深入探讨Java实现的八大排序算法，包括冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、堆排序以及计数排序。 1. **冒泡排序（Bubble Sort）**：冒泡排序是一种简单直观的排序算法，...
c语言（7.23）
fhgfyrsg的博客
07-23 416
【代码】c语言（7.23）
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 773
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
数据结构之判断完全二叉树详解与示例（C，C++）
qq_35320456的博客
07-23 388
通过上述C和C++的实现示例，我们可以看到判断一个二叉树是否为完全二叉树的基本方法是使用层序遍历。在遍历过程中，我们通过设置一个标记来区分节点是否应该为叶子节点，从而判断二叉树是否满足完全二叉树的条件。这种方法的时间复杂度为O(n)，其中n是二叉树中节点的数量，因为每个节点最多只会被访问一次。在实际应用中，完全二叉树由于其特殊的结构，常用于堆的实现，因为它可以在数组中有效地表示，同时保持堆的操作效率。理解并掌握判断完全二叉树的方法，对于深入理解二叉树结构和相关算法有重要意义。
数据结构（特殊二叉树－线索二叉树）
weixin_65029285的博客
07-22 361
链式二叉树中有很多的空指针，可以让这些空指针指向前一个节点\后一个节点，从而在有序遍历（中序遍历）二叉树时，不需要使用递归而通过循环即可以完成，并且效率要比递归快得多。首先需要有一颗搜索二叉树，然后通过中序遍历并生成线索，通过检查右子树是否为空来决定是否生成线索，让右子树指向下一个节点。bool lflag;// 左子树是否是线索 为真时，左子树是线索 指向前一个节点。bool rflag;// 右子树是否是线索 为真时，右子树是线索 指向下一个节点。
数据结构——单链表OJ题（下）
最新发布
2301_81888634的博客
07-25 585
链表既然包括单链表，就还有其他种类啦~敬请期待“双向链表”~
数据结构（特殊二叉树-平衡二叉树）
weixin_65029285的博客
07-23 951
待删除节点左右子树非空，则根据左右子树的高度，选择高的一边子树，如果是左子树高，选择左子树中的最大节点赋值给待删除节点，然后再左子树中继续删除该最大节点，相当于继续处理情况1或情况2；由于节点的位置要受到相互之间值的影响，并且在往平衡二叉树中添加节点或者删除节点前，二叉树本身是平衡的，所以只可能在最后操作的节点附近不满足平衡条件，因此需要在该过程中对该节点进行判断并调整。如果一个搜索二叉树呈现或接近单支状，它的查找效率很低，很接近链表，因此如果能让它平衡时，查找效率最高。待删除的节点是叶子节点，直接删除。
C语言必知的八大排序算法详解及示例
本文档详细介绍了C语言中的八大排序算法，这些算法对于理解和实现高效的排序操作至关重要。排序算法在计算机科学中扮演着核心角色，因为它们能够帮助我们组织和处理大量数据，确保其按特定顺序排列。 首先，让我们...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值