1. Toy模板网首页
  2. > Toy博客

数据结构排序：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序

9月前 作者：学习中的新生凯尔希 分类：Toy博客 阅读(83) 违法举报

这篇具有很好参考价值的文章主要介绍了数据结构排序：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

插入排序

  1. 基本思想： 直接插入排序是一种简单的插入排序法，其基本思想是： 把待排序的值按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。
  2. 直接插入排序： 当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与 array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移

​数据结构排序：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序,数据结构​

‍

实现：

//插入排序
void InsertSort(int* a,int n) {

	for (int i = 0; i < n - 1;i++) {
		int end = i;
		int tmp = a[end + 1];
		while (end >= 0) {
			if (tmp < a[end]) {
				a[end + 1] = a[end];
				--end;
			}
			else {
				break;
			}
		}
		a[end + 1] = tmp;
	}

}

直接插入排序的特性总结：

  1. 元素集合越接近有序，直接插入排序算法的时间效率越高

  2. 时间复杂度：O(N^2)

  3. 空间复杂度：O(1)，它是一种稳定的排序算法

  4. 稳定性：稳定

‍

希尔排序

希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数gap，把待排序文件中所有记录按gap分成若干个组，所有距离为gap的记录分在同一组内，并对每一组内的记录进行排序。然后缩小gap的值，重复上述分组和排序的工作。当到达gap=1时，所有记录在统一组内排好序（当gap=1时其实就是直接插入排序）。

注：希尔排序就是先对待排数组进行一次预排序，将数组变的尽量接近有序，再使用直接插入排序进行最终排序

​数据结构排序：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序,数据结构​

实现：

//希尔排序
void ShellSort(int* a,int n) {
	int gap = n;

	while (gap > 1) {

		gap = gap / 3 + 1;
		for (int i = 0; i < n - gap; i++) {
			int end = i;
			int tmp = a[end + gap];
			while (end >= 0) {
				if (a[end] > tmp) {
					a[end + gap] = a[end];
					end -= gap;
				}
				else {
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}

}

希尔排序的特性总结：

  1. 希尔排序是对直接插入排序的优化。

  2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。

  3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的 希尔排序的时间复杂度都不固定

  4. 稳定性：不稳定文章来源地址https://www.toymoban.com/news/detail-828946.html

选择排序

直接选择排序:

  • 在元素集合array[i]–array[n-1]中选择关键码最大和最小的数据元素
  • 若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换
  • 在剩余的array[i]–array[n-2]（array[i+1]–array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素

​数据结构排序：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序,数据结构实现：

//选择排序
void SelectSort(int* a,int n) {

	int min = 0;
	int max = n - 1;
	while (min <= max) {
		int min1 = min;
		int max1 = max;
		for (int i = min; i <= max;i++) {
			if (a[min1] > a[i]) {
				min1 = i;
			}
			if (a[max1] < a[i]) {
				max1 = i;
			}
		}
		Swap(&a[min],&a[min1]);
		if (max1 == min) {
			Swap(&a[max],&a[min1]);
		}
		Swap(&a[max],&a[max1]);
		min++;
		max--;
	}

}

直接选择排序的特性总结：

  1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用

  2. 时间复杂度：O(N^2)

  3. 空间复杂度：O(1)

  4. 稳定性：不稳定

冒泡排序

左边大于右边交换一趟排下来最大的在右边

实现：

void Swap(int* a,int* b) {
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

//冒泡排序
void BubbleSort(int* a,int n) {

	for (int i = n; i > 0;i--) {
		for (int j = 0; j < i - 1; j++) {
			if (a[j] > a[j + 1]) {
				Swap(&a[j],&a[j +1 ]);
			}
		}
	}

}

‍

冒泡排序的特性总结：

  1. 冒泡排序是一种非常容易理解的排序

  2. 时间复杂度：O(N^2)

  3. 空间复杂度：O(1)

  4. 稳定性：稳定

堆排序

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。

先使用数据进行建堆，在升序排列中，建立一个大堆，建好后最大的数据在最上面，然后将最上面的数据a[0]，与最后位置的数据a[n-1]进行调换，这样a[n-1]位置的数据就是最大的了，最大数据就在了最后面；在对剩下的位置的数据进行调整，再调整为一个大堆，再将a[0]（现在是第二大的数据）与a[n-2]的数据进行调换，这样第二大的数据就砸倒数第二个位置上；后面以次类推，直到堆中仅剩一个数据，排序完成。

需要注意的是排升序要建大堆，排降序建小堆。

对于堆不了解的可以去看我的树与二叉树这一篇文章

实现：

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--;
	}
}

堆排序的特性总结：

  1. 堆排序使用堆来选数，效率就高了很多。

  2. 时间复杂度：O(N*logN)

  3. 空间复杂度：O(1)

  4. 稳定性：不稳定

快速排序

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，

其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

// 假设按照升序对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);
}

上述为快速排序递归实现的主框架，发现与二叉树前序遍历规则非常像，同学们在写递归框架时可想想二叉 树前序遍历规则即可快速写出来，后序只需分析如何按照基准值来对区间中数据进行划分的方式即可。

实现：

//快排
void QuickSort(int* a,int begin,int end) {
	if (begin >= end) {
		return;
	}
	int mid = GetMid(a, begin, end);
	Swap(&a[begin], &a[mid]);

	int left = begin, right = end;
	int key = begin;
	while (left < right) {
		//右边找小值
		while (left < right && a[right] >= a[left]) {
			right--;
		}
		//左边找大值
		while (left < right && a[left] <= a[key]) {
			left++;
		}
		//如果数组有序，找不到位置，那么此时就会左右相等，不进行交换
		Swap(&a[left], &a[right]);
	}
	Swap(&a[left],&a[key]);
	key = left;

	QuickSort(a,begin,key-1);
	QuickSort(a,key+1,end);
}

改进版：

void Swap(int* a,int* b) {
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

int GetMid(int* a, int begin, int end) {
	int mid = (end - begin) / 2;
	if (a[begin] < a[mid])
	{
		if (a[mid] < a[end])
			return mid;
		else if (a[begin] > a[end])
			return begin;
		else
			return end;
	}
	else 
	{
		if (a[mid] > a[end])
			return mid;
		else if (a[begin] < a[end])
			return begin;
		else
			return end;
	}
}

int PartSort1(int* a, int begin, int end)
{
	int mid = GetMid(a, begin, end);
	Swap(&a[mid], &a[begin]);

	int left = begin, right = end;
	int keyi = begin;

	if (end - begin + 1 < 10) {
		InsertSort(a+begin,end - begin + 1);
	}

	while (left < right)
	{
		// 右边找小
		while (left < right && a[right] >= a[keyi])
		{
			--right;
		}

		// 左边找大
		while (left < right && a[left] <= a[keyi])
		{
			++left;
		}

		Swap(&a[left], &a[right]);
	}

	Swap(&a[left], &a[keyi]);

	return left;
}

挖坑法：

void Swap(int* a,int* b) {
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

int GetMid(int* a, int begin, int end) {
	int mid = (end - begin) / 2;
	if (a[begin] < a[mid])
	{
		if (a[mid] < a[end])
			return mid;
		else if (a[begin] > a[end])
			return begin;
		else
			return end;
	}
	else 
	{
		if (a[mid] > a[end])
			return mid;
		else if (a[begin] < a[end])
			return begin;
		else
			return end;
	}
}

//挖坑法块排
int PartSort2(int* a,int begin,int end) {
	int mid = GetMid(a, begin, end);
	Swap(&a[begin], &a[mid]);

	int key = a[begin];
	int hole = begin;
	while (begin < end) {
		//右边找小值
		while (begin < end && a[end] >= key) {
			end--;
		}
		a[hole] = a[end];
		hole = end;
		//左边找大值
		while (begin < end && a[begin] <= key) {
			begin++;
		}
		a[hole] = a[begin];
		hole = begin;
	}

	a[hole] = key;
	return hole;
}

前后指针法：

void Swap(int* a,int* b) {
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

int GetMid(int* a, int begin, int end) {
	int mid = (end - begin) / 2;
	if (a[begin] < a[mid])
	{
		if (a[mid] < a[end])
			return mid;
		else if (a[begin] > a[end])
			return begin;
		else
			return end;
	}
	else 
	{
		if (a[mid] > a[end])
			return mid;
		else if (a[begin] < a[end])
			return begin;
		else
			return end;
	}
}

//前后指针
int PartSort3(int* a, int begin, int end) {
	int mid = GetMid(a, begin, end);
	Swap(&a[begin], &a[mid]);

	int pre = begin, cur = begin + 1;
	int key = begin;
	while (cur <= end) {
		//cur找小值
		if (a[cur] <= a[key] && ++pre != cur) {
			Swap(&a[pre], &a[cur]);
		}
		cur++;

	}
	Swap(&a[pre], &a[key]);

	return pre;
}

快速排序的特性总结：

  1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序

  2. 时间复杂度：O(N*logN)

  3. 空间复杂度：O(logN)

  4. 稳定性：不稳定

到了这里，关于数据结构排序：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包