一篇拿捏十大排序(超详细版)

已于 2023-11-02 14:38:39 修改
阅读量64 收藏
点赞数
文章标签： 排序算法 算法
于 2023-10-27 18:57:11 首次发布

本文转自网络文章，已获取原文作者授权。 原文作者：黑夢

文章目录

排序的概念

**排序：**所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
**稳定性：**假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
内部排序(内存中排序)：数据元素全部放在内存中的排序。
**外部排序(磁盘中排序)：**数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

​ **注意：**此文的八种排序均是内部排序，而归并排序即可以说是内部排序，也可以说是外部排序。

1 插入排序

​ **基本思想：**把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。**例如：**斗地主。

1.1 直接插入排序

​ 当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移。

img

1.2 直接插入排序实现

//直接插入排序
//时间复杂度：O(n^2)  复杂度范围：O(n)-O(n^2)
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 (a[end] > tmp)
			{
				a[end + 1] = a[end];
			}
			else
			{
				break;
			}
			end--;
		}
		a[end + 1] = tmp;
	}
}

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

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

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

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

​ 4. 稳定性：稳定

2 希尔排序

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

​ **预排序(gap>1)：**大的数更快的到后面去，小的数更快到前面，gap越大跳的越快，越不接近有序，gap越小跳的越慢，越接近有序，当gap=1时，完成排序。

img

//希尔排序
//时间复杂度：O(nlogn)  复杂度范围：O(n^1.3)-O(nlogn)
void ShellSort(int* a, int n)
{
	int gap = n;
	while (gap > 1)
	{
		//gap = gap / 2;
		gap = gap / 3 + 1;
		for (int i = 0; i < n - gap; i++)
		{
			int end = i;
			int tmp = a[i + gap];
			while (end >= 0)
			{
				if (a[end] > tmp)
				{
					a[end + gap] = a[end];
				}
				else
				{
					break;
				}
				end -= gap;
			}
			a[gap + end] = tmp;
		}
	}
}

希尔排序的特性总结：

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

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

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

《数据结构-用面相对象方法与C++描述》— 殷人昆

img

因为咋们的gap是按照Knuth提出的方式取值的，而且Knuth进行了大量的试验统计，我们暂时就按照：O(n1.25)到O(1.61.25)来算。

​ 4. 稳定性：不稳定

3 选择排序

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

3.1 直接选择排序

基本思想：

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

img

//直接选择排序
//时间复杂度：O(n^2)  复杂度范围：O(n^2)-O(n^2)
void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
 
void SelectSort(int* a, int n)
{
	int end = n - 1;
	int begin = 0;
	while (end > begin)
	{
		int maxi = begin;
		int mini = begin;
		for (int i = begin + 1; i <= end ; i++)
		{
			if (a[maxi] < a[i])
			{
				maxi = i;
			}
			if (a[mini] > a[i])
			{
				mini = i;
			}
		}
		Swap(&a[maxi], &a[end]);
		if (mini == end)
		{
			mini = maxi;
		}
		Swap(&a[mini], &a[begin]);
 
		end--;
		begin++;
	}
}

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

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

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

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

​ 4. 稳定性：不稳定

4 堆排序

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

img

//堆排序
//时间复杂度：O(nlogn)  复杂度范围：O(nlogn)-O(nlogn)
//向下调整（此时建立大堆）
void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
 
void Adjustdown(int* a, int n, int parent)
{
	int child = (parent * 2) + 1;
	while (child < n)
	{
		if (child + 1 < n && a[child] < a[child + 1])
		{
			child++;
		}
		if (a[parent] < a[child])
		{
			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--)
	{
		Adjustdown(a, n, i);
	}
 
	int end = n;
	while (end > 0)
	{
		Swap(&a[0], &a[end - 1]);
		Adjustdown(a, end - 1, 0);
		end--;
	}
}

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

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

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

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

​ 4. 稳定性：不稳定

5 交换排序

​ **基本思想：**所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

6 冒泡排序

​ 每趟将最大的数排序到范围内最后一个位置，每趟结束后减少一个范围数，第二趟将次大的数排序到倒数第二个位置，当一趟排序没有改变数组顺序，说明排序完成，直接退出循环，否则依次排序完整个数组。

img

//冒泡排序
//时间复杂度：O(n^2)  复杂度范围：O(n)-O(n^2)
void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
 
void BubblingSort(int* a, int n)
{
	for (int i = 0; i < n; i++)
	{
		int change = 0;
		for (int j = 1; j < n - i; j++)
		{
			if (a[j - 1] > a[j])
			{
				Swap(&a[j - 1], &a[j]);
				change = 1;
			}
		}
		if (change == 0)
		{
			break;
		}
	}
}

冒泡排序的特性总结：

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

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

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

​ 4. 稳定性：稳定

7 快速排序

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

7.1 hoare版本

​ 右边节点从右向左，如果节点的值大于或大于基元素(a[right] >= a[key])接着向左移动，否则到左边节点从左向右，如果节点的值小于或大于基元素(a[left] <= a[key])接着向右移动，都停止后，交换当前节点值，循环结束后，再将基元素与左节点交换。然后分治递归解决排序问题。

注意(可能做的过程会遗漏问题)：

​ 1.当前节点与基节点比较要取等于号，否则节点值和基节点值相同时，会死循环；

​ 2.注意节点移动时考虑left < right,否则可能发生数组越界；

问：相遇位置比key小，怎么做到的?
**答：**右边的先走的做到的。
相遇情况分析:
1、R动L不动，去跟L相遇了（相遇位置是L的位置，L和R在上一轮交换过，交换以后L位置的值比key要小）

​ 2、L动R不动，去跟R相遇了（R先走，找大比key小的，停下来了，这时L找大没有找到跟R相遇了，相遇位置比key小）

快速排序优化：

​ 1. 三数取中法选key

​ 2. 递归到小的子区间时，可以考虑使用插入排序

img

//三数取中
int Middle(int* a,int left, int right)
{
	int mid = (left + right) / 2;
	if (a[left] > a[right])
	{
		if (a[left] > a[mid])
		{
			if (a[right] > a[mid])
			{
				return right;
			}
			else
			{
				return mid;
			}
		}
		else
		{
			return left;
		}
	}
	else
	{
		if (a[right] > a[mid])
		{
			if (a[left] > a[mid])
			{
				return left;
			}
			else
			{
				return mid;
			}
		}
		else
		{
			return right;
		}
	}
}
//hoare方法
int Hoare(int* a, int left, int right)
{
	int mid = Middle(a,left, right);
	Swap(&a[left], &a[mid]);
 
	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;
	}
 
	int key = Hoare(a, begin, end);
	QuickSort(a, begin, key - 1);
	QuickSort(a, key + 1, end);
}

快速排序的特性总结：

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

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

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

​ 4. 稳定性：不稳定

7.2 挖坑法

​ 先将第一个元素存放在临时变量front中，形成一个坑位(空),然后重复hoare法的步骤，最终将存放元素与坑位填上。然后分治递归解决排序问题。

//三数取中
int Middle(int* a,int left, int right)
{
	int mid = (left + right) / 2;
	if (a[left] > a[right])
	{
		if (a[left] > a[mid])
		{
			if (a[right] > a[mid])
			{
				return right;
			}
			else
			{
				return mid;
			}
		}
		else
		{
			return left;
		}
	}
	else
	{
		if (a[right] > a[mid])
		{
			if (a[left] > a[mid])
			{
				return left;
			}
			else
			{
				return mid;
			}
		}
		else
		{
			return right;
		}
	}
}
//挖坑法
int Hold(int* a, int left, int right)
{
	int mid = Middle(a, left, right);
	Swap(&a[left], &a[mid]);
 
	int front = a[left];
	int hold = left;
 
	while (left < right)
	{
		while (left < right && a[right] >= front)
		{
			right--;
		}
		a[hold] = a[right];
		hold = right;
 
		while (left < right && a[left] <= front)
		{
			left++;
		}
		a[hold] = a[left];
		hold = left;
	}
	a[hold] = front;
	return hold;
}
 
void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
	{
		return;
	}
 
	int key = Hold(a, begin, end);
	QuickSort(a, begin, key - 1);
	QuickSort(a, key + 1, end);
}

7.3 上下指针法

​ 初始时，prev指针指向序列开头，cur指针指向prev指针的后一个位置，当a[cur] < a[key]且++prev != cur时，交换prev和cur节点，否则cur单独+1；循环结束后，开头与prev节点值交换。然后分治递归解决排序问题。

1cur找小，++prev，交换prev和cur的值
prev的有两种:
1、在cur还没遇到比key大的值时候，prev紧跟着cur
2、在cur还遇到比key大的值时候，prev在比key大的一组值的前面

​ 本质是把一段大于key的区间，推箱子似的往右推，同时小的甩到左边去

//三数取中
int Middle(int* a,int left, int right)
{
	int mid = (left + right) / 2;
	if (a[left] > a[right])
	{
		if (a[left] > a[mid])
		{
			if (a[right] > a[mid])
			{
				return right;
			}
			else
			{
				return mid;
			}
		}
		else
		{
			return left;
		}
	}
	else
	{
		if (a[right] > a[mid])
		{
			if (a[left] > a[mid])
			{
				return left;
			}
			else
			{
				return mid;
			}
		}
		else
		{
			return right;
		}
	}
}
//上下指针法
int Pointer(int* a, int left, int right)
{
	int mid = Middle(a, left, right);
	Swap(&a[left], &a[mid]);
 
	int key = left;
	int prev = left;
	int cur = left + 1;
 
	while (cur <= right)
	{
		if (a[cur] < a[key] && ++prev != cur)
		{
			Swap(&a[prev], &a[cur]);
		}
		cur++;
	}
	Swap(&a[key], &a[prev]);
	return prev;
}
void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
	{
		return;
	}
 
	int key = Pointer(a, begin, end);
	QuickSort(a, begin, key - 1);
	QuickSort(a, key + 1, end);
}

7.4 快速排序非递归实现

int Pointer(int* a, int left, int right)
{
	int mid = Middle(a, left, right);
	Swap(&a[left], &a[mid]);
 
	int key = left;
	int prev = left;
	int cur = left + 1;
 
	while (cur <= right)
	{
		if (a[cur] < a[key] && ++prev != cur)
		{
			Swap(&a[prev], &a[cur]);
		}
		cur++;
	}
	Swap(&a[key], &a[prev]);
	return prev;
}
//快速排序非递归
void QuickSortNonR(int* a, int begin, int end)
{
	SL sl;
	SLInit(&sl);
 
	SLPush(&sl, end);
	SLPush(&sl, begin);
 
	while (!SLEmpty(&sl))
	{
		int left = SLTTop(&sl);
		SLPop(&sl);
 
		int right = SLTTop(&sl);
		SLPop(&sl);
 
		int key = Pointer(a, left, right);
		if (key + 1 < right)
		{
			SLPush(&sl, right);
			SLPush(&sl, key + 1);
		}
		if (left < key - 1)
		{
			SLPush(&sl, key - 1);
			SLPush(&sl, left);
		}
	}
}

7.5 快速排序(优化)

​ 当排序分治递归元素剩余十个的时候，直接插入排序来完成排序(剩余十个时还进行分治递归，多次递归有空间的浪费)。

void QuickSort2(int* a, int begin, int end)
{
	if (begin >= end)
	{
		return;
	}
	//优化：剩余十个时直接插入排序
	if (end - begin + 1 > 10)
	{
		int key = Pointer(a, begin, end);
		QuickSort2(a, begin, key - 1);
		QuickSort2(a, key + 1, end);
	}
	else
	{
		InsertSort(a + begin,end - begin +1);
	}
}

8 归并排序

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

img

//归并排序(递归)
void _MergeSort(int* a,int* tmp,int begin,int end)
{
	if (begin >= end)
	{
		return;
	}
	int mid = (begin + end) / 2;
 
	_MergeSort(a, tmp, begin, mid);
	_MergeSort(a, tmp, mid + 1, end);
 
	int begin1 = begin;
	int end1 = mid;
	int begin2 = mid + 1;
	int end2 = end;
	int cur = begin;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] < a[begin2])
		{
			tmp[cur++] = a[begin1++];
		}
		else
		{
			tmp[cur++] = a[begin2++];
		}
	}
	while (begin1 <= end1)
	{
		tmp[cur++] = a[begin1++];
	}
	while (begin2 <= end2)
	{
		tmp[cur++] = 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 fail");
		return;
	}
 
	_MergeSort(a, tmp, 0, n - 1);
 
	free(tmp);
}

归并排序的特性总结：

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

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

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

​ 4. 稳定性：稳定

8.1 归并排序非递归实现

//归并排序非递归
void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail");
		return;
	}
 
	int gap = 1;
	while (gap < n)
	{
		for (int 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 cur = i;
 
            if (begin2 > n - 1)
			{
				break;
			}
			if (end2 > n - 1)
			{
				end2 = n - 1;
			}
 
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
				{
					tmp[cur++] = a[begin1++];
				}
				else
				{
					tmp[cur++] = a[begin2++];
				}
			}
			while (begin1 <= end1)
			{
				tmp[cur++] = a[begin1++];
			}
			while (begin2 <= end2)
			{
				tmp[cur++] = a[begin2++];
			}
			memcpy(a + i, tmp + i, sizeof(int) * (end2 - i + 1));
		}
		gap *= 2;
	}
	free(tmp);
}

9 非比较排序

​ **基本思想：**计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。

操作步骤：

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

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

10 计数排序

​ 将每个元素有多少个，记录到一个数组中，然后从这个数组中依次遍历打印出来。

//计数排序
void CountSort(int* a, int n)
{
	int max = a[0];
	int min = 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* count = (int*)calloc(range,sizeof(int));
	if (count == NULL)
	{
		perror("ralloc fail");
		return;
	}
 
	for (int i = 0; i < n; i++)
	{
		count[a[i] - min]++;
	}
 
	int j = 0;
	for (int i = 0; i < range; i++)
	{
		while (count[i]--)
		{
			a[j++] = i + min;
		}
	}
}

计数排序的特性总结：

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

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

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

​ 4. 稳定性：稳定

排序算法复杂度及稳定性分析

img

img

稳定性

​ **稳定性：**指的是当未排序前，数组中有相同元素，在排序完成后没有改变相同元素的相对位置的情况下，说明该排序稳定。反之，不稳定。（考试分数相同，先交卷的在前面）

例：

​ **排序前：**2 *5* 9 6 *5* 3 7 1

​ 排序后：1 2 3 *5* *5* 6 7 9 说明此排序算法*稳定***！

​ 反之：排序后：1 2 3 5 5 6 7 9 说明此排序算法****不稳定****！

不稳定分析：

​ **希尔排序：**预排序时，相同的元素分配到不同的组中。

​ 选择排序： 例：3 3 1 1;这种情况第一个3已经被交换位置。

​ **堆排序：**例：9 8 9 6 2；这种情况按大堆排升序，第一个调换到最后以后就不稳定了。

​ **快速排序：**例：5 8 5 4 5；这种因为相同所以没有去交换，到结束时第一个与left交换时不稳定。

扩展

​ *因为以下排序，实用性低，除了考试以外，基本上不会进行考察，工作也基本用不上，就不多描述。*

​ 基数排序：按个，十，百，千位依次进行排序的算法。

​ 桶排序：

img

以上就是个人学习线性表的个人见解和学习的解析，欢迎各位大佬在评论区探讨！
感谢大佬们的一键三连！ 感谢大佬们的一键三连！ 感谢大佬们的一键三连！

原文链接：https://blog.csdn.net/weixin_71964780/article/details/133839719

在这里插入图片描述

指尖动听知识库
关注
数据结构：一篇拿捏十大排序(超详细版)
黑夢的博客
10-19 1085
十大排序：直接插入排序、希尔排序、直接选择排序、堆排序、冒泡排序、快速排序、归并排序、计数排序、基数排序、桶排序，稳定性分析，时间复杂度，空间复杂度。
【秋招Learning_note】| 拿捏排序算法！
m0_63650113的博客
08-05 1046
本文总结了笔试中常遇到的几种排序算法，从原理、实现方式、时间空间复杂度等方面理解每一个算法。
一篇教你拿捏Java8新特性
大叔的博客
03-28 1578
挑战全网最良心的java8新特性，不全来打我
用调试来帮你分析并拿捏折半插入排序算法的流程
微凉秋意的博客
08-12 1229
书接上文，今天带来算法基础中的折半插入排序，一个综合了直接插入排序和二分查找的算法。和以往四篇不同，这篇文章将会加入详细调试的图片，帮助大家理解该算法的流程。本篇文章也将收录在经典算法专栏，此专栏免费且收录经典算法，感兴趣的朋友可订阅以便持续观看。......
超详细八大排序+基数排序（图文并茂+动图演示+C语言代码演示）
总结日常学习内容
04-02 4703
图文详解秒懂各大排序
【数据结构】 拿捏二叉树堆排序与遍历
weixin_73961973的博客
10-02 210
二叉树的存储结构 二叉树的堆排序 堆的概念 堆向上调整算法 堆向下调整算法 堆排序应用之TopK问题 二叉树的遍历 链式二叉树 创建二叉树 二叉树的遍历 前序遍历 中序遍历 后续遍历 层序遍历
一篇文章轻松拿捏Java基础之集合那些事儿~
小黄同学的博客
11-29 145
一篇文章轻松拿捏Java基础之集合那些事儿~
万字长文|十大基本排序，一次搞定！
三分恶的博客
09-05 2208
十大基本排序可以说是必知必会的算法，万字+五十图+动图演示，这一次，十大排序彻底搞定！
项目管理论文十大领域各一篇
weixin_44113772的博客
07-19 2322
第 1 篇 论信息系统项目的整体管理 【摘要】 2016 年 7 月，我参加了╳╳市物价局发起的“智慧物价”信息综合管理平台系统的建设工作，担任承建方项目经理，该信息综合管理平台系统的主要功能有括价格监测预警、价格应急监测、价格监督检查、商品价格管理、价格认证管理、成本信息管理、价格信息发布、价格行政审批、价格调节基金监管、12358 投诉举报联动、价格信息互动服务、收费管理、协同办公平台及物价门户网站等 14个业务管理模块，建设费用 780 万元，系统上线之前用单一系统来进行信息管理与业务处理，信息孤立、
十大排序算法深度解析与实现
资源摘要信息:"数据结构：一篇拿捏十大排序(超详细版)"详细介绍了数据结构领域中排序算法的相关知识点。排序算法是计算机科学中用于将一系列元素按照特定顺序排列的算法，其目的是便于查询和管理数据。常见的排序...
面试超爱问的TopK问题，这篇彻底搞明白
bigsai
12-16 4591
文章首发公众号：bigsai 首发博客csdn 收录在github算法仓库 前言 hello，大家好，我是bigsai哥哥，好久不见，甚是想念哇????！ 今天给大家分享一个TOPK问题，不过我这里不考虑特别大分布式的解决方案，普通的一道算法题。 首先搞清楚，什么是topK问题？ topK问题，就是找出序列中前k大(或小)的数，topK问题和第K大(或小)的解题思路其实大致一致的。 TopK问题是一个非常经典的问题，在笔试和面试中出现的频率都非常非常高(从不说假话)。下面，从小小白的出发点,认为to
飞链云版图安全食用指南 AI绘画超详细保姆级新手教程
feilianyun的博客
03-08 1022
非常感谢Jacky为飞链云版图编写的第一篇用户新手教程——飞链云官方！前言：在接触飞链云版图（以下简称飞链云AI）之前，笔者曾使用过 sd(stable diffusion)各版本、 wAIfu diffusion、novel AI等各主流AI绘画工具来跑图。但苦于无论是sd还是novel AI都难以轻易达到要求，只能通过反复调试各项参数去追求心目中最好的质量，直到飞链云AI的推出。简约的ui交互，优秀的模型资源，预设稳定的模型参数，强劲的算力，让笔者能够精准出图，高效出货，辅助笔者真正意义上实现“心想图成
《Java 实现快速排序：原理剖析与代码详解》
qq_69304031的博客
11-03 823
排序算法在数据处理和计算机编程领域中占据着举足轻重的地位，它们能够将无序的数据按照特定的规则整理成有序的序列，方便后续的分析与操作。在我们给出的代码中，选取的是数组的第一个元素作为基准值。在完成一次划分操作后，基准值就处于它在排序后应该所处的大致位置（即左边的元素都比它小，右边的元素都比它大）。将数组划分为两部分，使得左边部分的所有元素都小于等于基准值，右边部分的所有元素都大于等于基准值。来交换它们所指向的元素，使得数组的左边部分逐渐出现小于等于基准值的元素，右边部分逐渐出现大于等于基准值的元素。
Radix Sorts
shymoy的博客
11-08 200
顺序比较算法的时间复杂度的下界只要是顺序比较最坏情况下时间复杂度不可能比这个更好因为要确定N个的关系，至少要lgN！次比较数学上，lgN！又近似NlogN。
【算法-插入排序】基础知识，代码示例和应用场景
最新发布
m0_63141213的博客
11-08 490
插入排序是一种逐步构建有序列表的算法。它将数组分成“已排序部分”和“未排序部分”，然后从未排序部分中挑选元素插入到已排序部分的合适位置。想象打扑克牌时，一张张将牌放在手中按照大小排好，就是插入排序的过程。插入排序是一种操作简单、适合初学者学习的排序算法。它的特点是在小规模数据或基本有序的情况下性能较好，且插入时不需要额外空间。虽然插入排序的效率不如高级排序算法，但在某些应用场景中仍然具有实际价值。希望通过本章的学习，能够帮助大家更好地理解插入排序的基本原理、适用场景和代码实现。
插入排序和希尔排序
b123321888的博客
11-04 553
定义：插入排序是一种简单且直观的排序算法，适用于小规模数据的排序。基本思想：通过构建有序序列，对于未排序的数据，在已排序序列中从后向前扫描，找到相应位置并插入。实现特点：使用双层循环，外层循环遍历每个元素，内层循环负责将当前元素插入到正确的位置。定义：希尔排序是一种基于插入排序的排序算法，但它通过将原始列表分割成多个子列表来改进性能，每个子列表使用插入排序进行排序。基本思想：通过比较相距一定间隔的元素来进行排序，逐步减少间隔，直到间隔为1，此时整个列表基本有序，最后进行一次插入排序。
时间复杂度和空间复杂度
Stewie Lee的博客
11-06 1063
时间复杂度是计算机科学中的一个概念，用于描述算法的运行时间相对于输入大小的增长关系。它是衡量算法效率的重要指标之一。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值