【八大排序算法总结】超详解

于 2022-07-13 12:21:18 发布
阅读量914 收藏 16
点赞数 8
分类专栏： 笔记 数据结构 文章标签： 排序算法 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52882232/article/details/125761249
版权

八大排序

一.插入排序

1.插入排序的基本思想：

​ **把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为
止，得到一个新的有序序列 。 **

2.例子：

4,5,6,3,2,1

将首元素4作为一个有序区间，将后面的第一个元素5，插入到4这个有序区间里，依次往前比较直到插入到前面的数比5小，后面的数比5大为止。然后将后面的数依次插入到前面的有序区间里，这就是插入排序。

3.插入排序源码

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

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

4.插入排序总结：

  1. 元素集合越接近有序，直接插入排序算法的时间效率越高
  2. 时间复杂度：O(N^2)
  3. 空间复杂度：O(1)，它是一种稳定的排序算法
  4. 稳定性：稳定

二.希尔排序

1.希尔排序的思想：

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

2.例子：

希尔排序是对插入排序的优化，在对数据进行插入排序之前进行了预排序（也就是gap>1的情况），当gap向1趋近，数据也自然向有序趋近，gap == 1的时候就是对数据进行插入排序。元素集合越接近有序，直接插入排序算法的时间效率越高,所以通过预排序使得插入排序的效率有了显著的提高

3.希尔排序源码：

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

	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 (tmp < a[end])
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}
}

4.希尔排序总结：

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

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

  3. 希尔排序的时间复杂度 ：由于gap的取值方法是不固定的，所以时间复杂度也是不固定的，本文的希尔排序采用的是Knuth提出的gap取值方法，因此时间复杂度是O(N^1.25) ~O(1.65*N^1.25)。

  4. 稳定性：不稳定 （例子：5 8 5 2 9）

三.选择排序

1.选择排序的思想：

每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的
数据元素排完 。

2.例子（升序排序）:

5,4,3,2,1,6

第一趟选出最小1，和首元素进行交换，第二趟选出除首元素外最小的2，和第二个元素进行交换，依次进行，直到元素集合整体变为升序区间。

3.直接排序源码：

我们还可以在选择排序的基础上进行优化，每趟排序选出最小值和最大值，将最小值放到最左边，最大值放到最右边，类似二分法，这样就减少了循环的次数。但当maxi和begin重合时，我们先进行的是mini和begin交换，所以交换完begin是最小值，而不是最大值了（最大值已经换到mini），所以我们要进行调整，将maxi的下标改为mini

void Swap(int* e1, int* e2)
{
	int tmp = *e1;
	*e1 = *e2;
	*e2 = tmp;
}

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

	int begin = 0;
	int end = n - 1;
	while (begin < end)
	{
		int mini = begin;
		int maxi = begin;
		for (int i = begin + 1;i < end;i++)
		{
			if (a[i] < a[mini])
				mini = i;
			if (a[i] > a[maxi])
				maxi = i;
		}

		Swap(&a[begin], &a[mini]);

		// 如果begin和maxi重叠，那么要修正一下maxi的位置
		if (begin == maxi)
		{
			maxi = mini;
		}

		Swap(&a[end], &a[maxi]);
		++begin;
		--end;
	}
}

4.选择排序总结

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

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

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

  4. 稳定性：不稳定 （例子：5 8 5 2 9）

四.堆排序

1.堆排序思想：

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

2.例子：

3.堆排序源码：

void AdjustDwon(int* a, int size, int parent)
{
	int child = parent * 2 + 1;
	while (child < size)
	{
		if (child+1 <size && a[child + 1]>a[child])
		{
			++child;
		}

		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[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--)
	{
		AdjustDwon(a, n, i);
	}

	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDwon(a, end, 0);
		--end;
	}
}

4.堆排序总结：

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

  2. 时间复杂度：O(N*logN)建堆的时间复杂度就是O(N)

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

  4. 稳定性：不稳定 （例子：1 2 3 2）

五.冒泡排序

1.冒泡排序的思想：

冒泡排序的英文Bubble Sort，是一种最基础的交换排序。之所以叫做冒泡排序，因为每一个元素都可以像小气泡一样，根据自身大小一点一点向数组的一侧移动。

2.例子：

4,5,6,3,2,1

img

3.冒泡排序源码：

在原来的冒泡中加入交换定义变量exchange，避免了重复的交换，提高了冒泡排序的效率

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

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

4.冒泡排序总结：

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

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

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

  4. 稳定性：稳定 （例子：5 8 5 2 9）

六.快速排序

1.快速排序思想：

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中
的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右
子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

2.例子：

6 1 2 7 9 3 4 5 10 8

hore版本

依次对左右区间进行排序，每趟排序完后使得基准值的左边都比它小，右边都比它大，直到区间无法再分

img

挖坑法

将最左边的第一个值作为基准值，也作为坑位，从右边递减向左找到一个比基准值小的数，然后交换，并将该位置作为新的坑位，再从左边递增向右寻找比基准值大的数，然后交换，并将该位置作为新的坑位，依次进行，直到元素集合有序。

img

前后指针法：

在数组a的begin，mid，end位置的值中，找到一个中间值，cur为前指针，prev为后指针，只要cur的值比key小且cur != prev ，就交换prev和cur，prev++，循环完之后，交换prev和keyi，使prev的值为新的key，直到元素集合有序。

img

递归改非递归

初始化一个stack，将end，begin入栈，只要stack不为空，就取出栈的两个元素作为left和right，用上诉三种方法其中的一种进行排序，如果keyi+1< right，就把right和keyi+1入栈，如果left < keyi，就把keyi和left入栈。

3.快速排序源码：

int PartSort1(int* a, int begin, int end)
{
	int left = begin;
	int right = end;
	int keyi = left;
	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]);
	keyi = left;
	return keyi;
}

//挖坑法
int PartSort2(int* a, int begin, int end)
{
	int key = a[begin];
	int piti = begin;//坑

	while (begin < end)
	{
		while (begin < end && a[end] >= key)
		{
			--end;
		}
		a[piti] = a[end];
		piti = end;

		while (begin < end && a[begin] <= key)
		{
			++begin;
		}
		a[piti] = a[begin];
		piti = begin;
	}
	a[piti] = key;
	return piti;
}

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

int PartSort3(int* a, int begin, int end)
{
	int prev = begin;
	int cur = begin + 1;
	int keyi = begin;

	int mid = GetMidIndex(a, begin, end);
	Swap(&a[keyi], &a[mid]);

	while (cur <= end)
	{
		if (a[cur] < a[keyi] && ++prev != cur)
			Swap(&a[cur], &a[prev]);
		++cur;
	}
	Swap(&a[keyi], &a[prev]);
	keyi = prev;
	return keyi;
}

// 快速排序
void QuickSort(int* a, int begin, int end)
{
	assert(a);

	if (begin >= end)
	{
		return;
	}

	if (end - begin > 10)
	{
		int keyi = PartSort3(a,begin,end);
		QuickSort(a, begin, keyi - 1);
		QuickSort(a, keyi + 1, end);
	}
	else
	{
		InsertSort(a+begin, end - begin + 1);
	}
}

// 快速排序（非递归）
void QuickSortNonR(int* a, int begin, int end)
{
	ST st;
	StackInit(&st);
	StackPush(&st, end);
	StackPush(&st, begin);

	while (!StackEmpty(&st))
	{
		int left = StackTop(&st);
		StackPop(&st);

		int right = StackTop(&st);
		StackPop(&st);

		int keyi = PartSort1(a, left, right);

		if (keyi + 1 < right)
		{
			StackPush(&st, right);
			StackPush(&st, keyi+1);
		}

		if (keyi - 1 > left)
		{
			StackPush(&st, keyi-1);
			StackPush(&st, left);
		}
	}
	StackDestroy(&st);
}

4.快速排序总结：

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

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

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

  4. 稳定性：不稳定 (6 8 5 5 2 7 9)

七.归并排序

1.归并排序思想：

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and
Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有
序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

2.例子：

image-20220713113509230

3.归并排序源码：

1.递归

申请一个额外的数组tmp，将元素集合分为大小相等的两个区间（分到不可再分为止），依次将两个（有序）区间中较小的数放到tmp中，再将两个区间中剩余的一个数放到tmp中，在把（end-begin+1）中的数据cp回原数组，最后将申请的额外数组空间释放。

2.非递归

利用gap2来控制分治的两个区间的大小，先判断gap2是否越界，如果越界对其进行修正，然后进行排序（和递归的思想一样），直到gap比n大。

void _MergeSort(int* a, int begin, int end, int* tmp)
{
	if (begin > end)
	{
		return;
	}

	int mid = (begin + end) / 2;

	_MergeSort(a, begin, mid, tmp);
	_MergeSort(a, mid + 1, end, tmp);

	int begin1 = begin;
	int end1 = mid;
	int begin2 = mid + 1;
	int end2 = end;
	int i = begin;

	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] < a[begin2])
		{
			tmp[i++] = a[begin1++];
		}
		else
		{
			tmp[i++] = a[begin2++];
		}
	}

	while (begin1 <= end1)
	{
		tmp[i++] = a[begin1];
	}

	while (begin2 <= end2)
	{
		tmp[i++] = a[begin2];
	}

	memcpy(a+begin,tmp+begin,(end-begin+1)*sizeof(int));
}


void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(a) * n);
	if (tmp == NULL)
	{
		printf("开辟空间失败\n");
		exit(-1);
	}

	_MergeSort(a, 0, n - 1, tmp);

	free(tmp);
}


void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(a) * n);
	if (tmp == NULL)
	{
		printf("开辟空间失败\n");
		exit(-1);
	}

	int gap = 1;
	while (gap < n)
	{
		int i = 0;
		for (i = 0;i < n;i += 2 * gap)
		{
			int begin1 = i;
			int end1 = i + gap - 1;
			int begin2 = i + gap;
			int end2 = i + 2 * gap - 1;
			int j = 0;

			if (begin1 >= n || begin2 >= n)
			{
				break;
			}
			else if (end2 >= n)
			{
				end2 = n - 1;
			}

			int m = end2 - begin1 + 1;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
				{
					tmp[j++] = a[begin1++];
				}
				else
				{
					tmp[j++] = a[begin2++];
				}
			}

			while (begin1 <= end1)
			{
				tmp[j++] = a[begin1];
			}

			while (begin2 <= end2)
			{
				tmp[j++] = a[begin2];
			}
			memcpy(a + i, tmp + i, sizeof(int) * m);
		}
		gap *= 2;
	}
	
	free(tmp);
}

4.归并排序总结：

  1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。

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

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

  4. 稳定性：稳定 （例子：5 8 5 2 9）

八.计数排序（非比较排序）

1.计数排序思想：

  1. 统计相同元素出现次数

  2. 根据统计的结果将序列回收到原来的序列中

2.例子：

3.计数排序源码：

void CountSort(int* a, int n)
{
	int min = a[0];
	int max = a[n - 1];

	int i = 0;
	for (i = 0;i < n;i++)
	{
		if (a[i] < min)
		{
			min = a[i];
		}

		if (a[i] > max)
		{
			max = a[i];
		}
	}

	int range = max - min + 1;

	int* count = (int*)malloc(sizeof(int) * range);
	if (count == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}

	memset(count, 0, sizeof(int));

	for (i = 0;i < n;i++)
	{
		count[a[i] - min]++;
	}

	int j = 0;

	for (i = 0;i < range;i++)
	{
		while (count[i]--)
		{
			a[j++] = i + min;
		}
	}
}

4.计数排序总结：

  1. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。

  2. 时间复杂度：O(MAX(N,范围))

  3. 空间复杂度：O(范围)

九.排序总结：

稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。

1.排序算法对比

2.内外部排序：

img

十.排序算法性能测试：

申请大额数据空间，使用rand产生随机数，利用时间函数clock来计算排序算法的运行时长，通过比较运行的时间大小，来比较排序算法的性能优劣，最后再把申请的空间释放。

void TestOP()
{
	srand(time(0));
	const int N = 1000000;
	int* a1 = (int*)malloc(sizeof(int) * N);
	int* a2 = (int*)malloc(sizeof(int) * N);
	int* a3 = (int*)malloc(sizeof(int) * N);
	int* a4 = (int*)malloc(sizeof(int) * N);
	int* a5 = (int*)malloc(sizeof(int) * N);
	int* a6 = (int*)malloc(sizeof(int) * N);
	int* a7 = (int*)malloc(sizeof(int) * N);


	for (int i = 0; i < N; ++i)
	{
		a1[i] = rand();
		a2[i] = a1[i];
		a3[i] = a1[i];
		a4[i] = a1[i];
		a5[i] = a1[i];
		a6[i] = a1[i];
		a7[i] = a1[i];
	}

	//ShellSort(a1, N);

	int begin1 = clock();
	//InsertSort(a1, N);
	int end1 = clock();

	int begin2 = clock();
	//ShellSort(a3, N);
	int end2 = clock();

	int begin3 = clock();
	//SelectSort(a3, N);
	int end3 = clock();

	int begin4 = clock();
	HeapSort(a4, N);
	int end4 = clock();

	int begin5 = clock();
	QuickSort(a4, 0, N - 1);
	int end5 = clock();

	int begin6 = clock();
	//MergeSort(a6, N);
	int end6 = clock();

	int begin7 = clock();
	//BubbleSort(a7, N);
	int end7 = clock();

	printf("InsertSort:%d\n", end1 - begin1);
	printf("ShellSort:%d\n", end2 - begin2);
	printf("SelectSort:%d\n", end3 - begin3);
	printf("HeapSort:%d\n", end4 - begin4);
	printf("QuickSort:%d\n", end5 - begin5);
	printf("MergeSort:%d\n", end6 - begin6);
	printf("BubbleSort:%d\n", end7 - begin7);

	//printf("callCount:%d\n", callCount);
	//printf("%p\n", &callCount);

	free(a1);
	free(a2);
	free(a3);
	free(a4);
	free(a5);
	free(a6);
	free(a7);
}
贩梦先生007
关注
  • 8
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
万字总结八大排序算法（图文详解）
oorik的博客
11-26 6977
文章目录 1.冒泡排序 2.选择排序 3.插入排序 4.归并排序 5.快速排序 一、冒泡排序 基本思想： 在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。每一趟排序后的效果都是讲没有沉下去的元素给沉下去。 主要思路: 1.比较相邻的元素。如果第一个比第二个大，...
八大经典排序算法
weixin_43164548的博客
03-01 1万+
详细讲解了经典的排序算法的思路和实现过程
八大排序算法
weixin_57023347的博客
10-07 1751
目录 前言： 一.排序概念 二.常见的排序算法 2.1 插入排序 2.1.1 直接插入排序 2.1.2 希尔排序 2.2 选择排序 2.2.1 直接选择排序 2.2.2 堆排序 2.3 交换排序 2.3.1 冒泡排序 2.3.2 快速排序 2.4归并排序 2.5 计数排序 前言： ...
八大排序算法总结与Java实现
11-03 3181
原文：https://itimetraveler.github.io/2017/07/18/%E5%85%AB%E5%A4%A7%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95%E6%80%BB%E7%BB%93%E4%B8%8Ejava%E5%AE%9E%E7%8E%B0/ 概述 因为健忘，加上对各种排序算法理解不深刻，过段时间面对排序就蒙了。
八大排序算法总结八大排序算法总结
06-23
八大排序算法总八大排序算法总八大排序算法总八大排序算法总结
黄海安-八大排序算法总结
03-31
**八大排序算法详解** 在计算机科学中，排序算法是用于对一组数据进行排列的算法，它们在编程中扮演着至关重要的角色。以下是黄海安总结的八大经典排序算法的详细介绍： 1. **冒泡排序（Bubble Sort）** 冒泡排序...
关于八大排序的算法详解
04-02
本文将深入探讨八大排序算法，包括冒泡排序和选择排序，以及它们的原理和实现。 【冒泡排序】 冒泡排序是一种简单的排序算法，其核心思想是通过重复遍历数组，比较相邻元素并根据需要交换位置来逐步排序。算法名称...
八大排序算法详解Java实现.md
06-17
八大排序详解 java实现
八大排序方法和总结
10-23
排序算法详解 在计算机科学中，排序算法是非常重要的一类算法，它们广泛应用于各种领域，例如数据处理、信息检索、科学计算等。在本文中，我们将详细介绍八大排序方法，包括直接插入排序、希尔排序、简单选择排序、...
java八大排序算法
01-07
【Java八大排序算法详解】 排序算法是计算机科学中基础且重要的算法之一，它们在处理大量数据时起到关键作用。在Java编程中，了解并掌握不同的排序算法有助于优化代码性能，提高程序效率。以下是对Java八大排序算法...
八大排序算法总结（含Java实现源代码）
08-06
总结了常用的八大排序算法：（交换式：1、冒泡，2、快排； 选择式：3、选择， 4、堆排； 插入式：5、插入， 6、希尔； 其他：7、归并， 8、基数排序）。 并包含了Java实现的源代码。
八大排序算法总结以及python实现
风雪夜归子
10-17 1万+
一、概述         排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。         我们这里说说八大排序就是内部排序。          当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。    快速排序
八大排序算法总结
大猪的博客
10-14 251
排序是计算机程序设计中的一种重要操作，其功能是对一个数据元素集合或序列重新排列成一个按数据元素某个相知有序的序列。 可将排序方法分为两大类: 一类是内部排序, 指的是待排序记录存放在计算机存储器中进行的排序过程；另一类是外部排序, 指的是待排序记录的数量很大，以至于内存一次不能容纳全部记录，在排序过程中尚需对外存进行访问的排序过程。 而内部排序又为： 其中快速排序是目前排序方法中
八大排序算法总结及Java实现
一萍之春的博客
01-21 426
                                            八大排序算法总结及Java实现   常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。   插入排序 算法步骤： 1）将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。 2）从头到尾依次扫描未排序序列，将...
八大排序 - (详解)
向未来❀去探索 的博客
04-04 2490
八大排序
超详细的八大排序算法的各项比较以及各自的特点
热门推荐
柯南的博客
08-09 7万+
一、八大排序算法的总体比较 二、算法各自的特点（具体实现见后面博客） 1.快排 （1）算法思想 选择一个基准元素，将比基准元素小的元素放在其前面，比基准元素大的元素放在其后面，然后在将小于基准值元素的子数列和大于基准元素的子数列按原来的方法排序，直到整个序列有序; （2）优缺点 优点：极快数据移动少； 缺点：不稳定； （3）效率分析 此排序算法的效率在序列越乱的时候，效率越高...
网络编程-TCP与UDP
微微一笑
02-27 5500
1.定义区别TCP (Transmission Control Protocol)和UDP(User Datagram Protocol)协议属于传输层协议。其中TCP提供IP环境下的数据可靠传输，它提供的服务包括数据流传送、可靠性、有效流控、全双工操作和多路复用。通过面向连接、端到端和可靠的数据包发送。通俗说，它是事先为所发送的数据开辟出连接好的通道，然后再进行数据发送；UDP则不为IP提供可靠...
数据结构八大排序算法c++
最新发布
01-01
数据结构中的八大排序算法，是指常见的八种用于对数据进行排序的算法。这八种算法分别是冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序和基数排序。 冒泡排序是一种简单的排序算法，通过不断比较和交换相邻元素的位置，使得最大（或最小）的元素逐渐往后（或往前）移动。 选择排序是一种简单直观的排序算法，每次选择未排序序列中最小（或最大）的元素，放到已排序序列的末尾。 插入排序是一种简单直观的排序算法，将一个待排序的元素插入到已部分排序的数列中的合适位置。 希尔排序是一种改进的插入排序算法，通过将待排序数列分组，并对每个分组进行插入排序，然后逐渐减小分组规模，最后进行一次插入排序。 归并排序是一种分治思想的排序算法，将待排序数列不断分割成较小的数列，然后再将这些较小的数列按照顺序进行合并。 快速排序是一种分治思想的排序算法，通过选择一个中间的基准元素，将数列分割成两部分，然后分别对这两部分进行排序。 堆排序是一种利用堆这种数据结构的排序算法，通过将待排序数列构建成一个大（或小）顶堆，然后逐步将堆顶元素与最后一个元素交换，并调整堆结构。 计数排序是一种非比较型的排序算法，通过统计待排序数列中每个元素出现的次数，然后依次输出即可。 基数排序是一种非比较型的排序算法，通过对待排序数列的每个位进行排序，依次从低位到高位进行。 这里简单介绍了八大排序算法的基本思想和实现方法。在实际应用中，不同的排序算法适用于不同的场景和要求，我们需要根据具体情况选择合适的算法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

贩梦先生007

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值