数据结构之排序

已于 2022-12-20 22:15:56 修改
阅读量400 收藏 1
点赞数
文章标签： 数据结构 排序算法 算法
于 2022-12-19 17:25:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_58330935/article/details/128364056
版权
本文详细介绍了排序算法，包括插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序和计数排序。其中，详细讨论了每种排序算法的实现细节、时间复杂度和空间复杂度，帮助读者深入理解各种排序算法的原理和应用场景。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

 排序的概念：

1、插入排序

 2、希尔排序

 3、选择排序

4、堆排序

5、冒泡排序

6、快速排序

7、归并排序

8、计数排序

 排序的概念：

所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
常见的排序算法：

1、插入排序

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

 

 具体代码如下：

void InsertSort(int* a, int n)
{
	assert(a);
	int i = 0;
	for (i = 0; i < n - 1; i++)
	{
		int end = i;
		int x = a[end + 1];
		while (end >= 0)
		{
			if (a[end] > x)
			{
				a[end + 1] = a[end];
				end--;
			}
			else
				break;
		}
		//end<0 或者 a[end] < x 
		a[end + 1] = x;
	}
}

插入排序的时间复杂度为O(N^2),空间复杂度为O(1)。

 2、希尔排序

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

希尔排序就是在插入排序上分组优化，插入排序的gap为1，如果设gap为3，即每隔3个为一组，进行预排序。

 

 经过预排之后，看以看到，该乱序的数组越趋近于有序，接着在缩小gap，直到gap为1时，那么该数组就会有序。

void ShellSort(int* a, int n)
{
	int gap = n;
	while (gap > 1)
	{
		gap /= 2;
		for (int i = 0; i < n - gap; ++i)
		{
			int end = i;
			int x = a[end + gap];
			while (end >= 0)
			{
				if (a[end] > x)
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
					break;
			}
			a[end + gap] = x;
		}
	}

}

 时间复杂度接近O（N^1.3) 空间复杂度O（1），不稳定。

 3、选择排序

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

 找到之后，最小的跟数组的第一个元素交换，最大的跟数组的最后一个元素交换，然后缩小区间，即begin++,--end，注意：这里找的是最大和最小元素的下标。

注意：这里还有一个BUG，如果最大的的元素出现在区间的开始位置，那么在第一次交换的时候，就会把该下标位置的值换走，所以需要处理一下。

因为最大元素已经跟最小的位置换了，所以只需将最小的下标赋值给最大的下标即可。

void Swap(int* px, int* py)
{
	int temp = *px;
	*px = *py;
	*py = temp;
}
// 选择排序   时间复杂度O(N^2)
void SelectSort(int* a, int n)
{
	int begin = 0;
	int end = n - 1;
	
	while (begin < end)
	{
		int mini = begin;
		int maxi = begin;
		for (int i = begin; i <= end; i++)
		{
			if (a[i] < a[mini])
			{
				mini = i;
			}
			if (a[i] > a[maxi])
			{
				maxi = i;
			}
		}
		Swap(&a[begin], &a[mini]);
		//begin ==maxi 时，最大被换走了，修正
		if (maxi == begin) 
		{
			maxi = mini;
		}
		Swap(&a[end], &a[maxi]);
		++begin;
		--end;
	}
}

4、堆排序

堆排序是根据堆的特性，如果要拍的是升序，那么应该建的是大堆，然后将堆顶的位置与最后一个元素交换，然后在向下调整。

 先从最后一个孩子计算父亲，从父亲位置开始建堆。

建堆之后堆顶的位置跟最后一个位置交换，在向下调整的时候，会选出次大的数，依次循环，就可完成堆排序。

void Swap(int* px, int* py)
{
	int temp = *px;
	*px = *py;
	*py = temp;
}

void AdjustDown(int* a, int size, int parent)  
{

	int child = 2 * parent + 1;

	while (child < size)
	{
		//先找孩子中最小的那一个
		if (child + 1 < size && a[child + 1] > a[child])//因为这个地方child+1可能不存在
		{
			child++;
		}
		if (a[child] > a[parent])
		{
			Swap(&a[parent], &a[child]);
			parent = child;
			child = 2 * parent + 1;
		}
		else
		{
			break;
		}
	}
}
//堆排序  排升序，调大堆
void HeapSort(int* a, int n)
{  
	//logN
	for (int i = (n - 1 - 1) / 2; i >= 0;--i)
	{
		AdjustDown(a, n, i);
	}
	int end = n - 1;
	//O(N*lonN)
	while (end >= 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}

建堆的时间复杂度：O(N)，交换后向下调整 O(N*logN)。

5、冒泡排序

冒泡排序就是交换排序的一种，交换排序的基本思想是：

基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排 序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。 
void BubbleSort(int* a, int n)
{
	int flag = 0;  
	for (int j = 0; j < n - 1; j++)
	{
		for (int i = 0; i < n - 1-j; i++)
		{

			if (a[i] > a[i + 1])
			{
				flag = 1; //发生了交换
				Swap(&a[i], &a[i + 1]);
			}
		}
		if (flag == 0)
		{
			break;
		}
	}

	/*int end = n;  //直接控制边界
	while (end > 0)
	{
		for (int i = 0; i < end-1; i++)
		{

			if (a[i] > a[i + 1])
			{
				Swap(&a[i], &a[i + 1]);
			}
		}
		--end;
	}*/	
}

冒泡排序的时间复杂度是O(N^2),空间复杂度O(1)。

6、快速排序

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

快速排序的单趟有两个版本，第一个是hoare版本。

 选最左边的为key，然后让右边先走，找比key小的值，找到之后停下，再让左边走，左边找比key大的值，找到之后跟右边的值交换，交换之后依旧是右边先走，直到左右相遇，相遇之后交换相遇地方与key的值。

 

 

 

 

 第二种方法是挖坑法:即把选出左边的key值保存起来，当成一个坑位，然后右边走找最小值，找到之后把这个值给坑位，自己形成一个新的坑位，然后左边再走，找比key大的值，找到之后给坑位，自己又形成一个新的坑位，直到相遇。相遇之后再把key的值给坑位。

 

 

 

 

 

 

 相遇的地方就是坑位，直接用key补上。

 

 虽然方法一和方法二都是一样的思想，但是两边的数的位置还是有所差别。

这只是快排的一趟，这一趟可以看到，在区间[0 , keyi-1]中，都是比key小的数，在区间  [keyi+1 ,right]都是被key大的数，所以在第一趟排序时，返回keyi的小标，用来分隔数组，采用递归的思想，逐步缩小区间，使区间逐步有序。

int  Partion(int* a, int left, int right)
{
	int Mid = GetMidIndex(a,  left,  right);
	Swap(&a[left], &a[Mid]); 
	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]);
	return left;
}
//快排的缺点：有序 
//针对有序方法一： 随机选keyi 不靠谱
//方法二：三数取中 左数 中间 和 右数 去值在中间的那一个
int  Partion1(int* a, int left, int right)  //挖坑法
{
	int Mid = GetMidIndex(a, left, right);
	Swap(&a[left], &a[Mid]);

	int key = a[left];
	int pivot = left;
	while (left < right)
	{
		while (left < right && a[right] >= key)
		{
			right--;
		}
		a[pivot] = a[right];
		pivot = right;
		while (left < right && a[left] <= key)
		{
			left++;
		}
		a[pivot] = a[left];
		pivot = left;
	}
	a[pivot] = key;
	return pivot;
}

方法三：双指针法

依旧选取最左边为key，prev在key的位置，cur在prev的前一个位置。从cur出发找比key小的值，找到之后，先++prev，然后交换，直到cur走出数组范围后，在交换prev与key的值。

如果选取右边为key值，那么cur和prev都在key值得位置。

 

 

 

 

 

int  Partion2(int* a, int left, int right)
{
	int Mid = GetMidIndex(a, left, right);
	Swap(&a[left], &a[Mid]);
	int keyi = left;
	int prev = left;
	int cur = prev + 1;
	while (cur <= right)
	{
		//while (cur <= right && a[cur] >= a[keyi])   //找小
		//{
		//	++cur;
		//}
		这地方要防止cur越界了 所以要加个判断条件
		//if (cur <= right)
		//{	
		//	Swap(&a[cur], &a[++prev]);
		//	cur++;  //交换完也要走
		//}
		if (a[cur] < a[keyi] && ++prev != cur)   //不用跟自己交换
		{
			Swap(&a[cur], &a[prev]);
		}
		++cur;
		//cur找小，把小的往左边翻，prev把大的序列往右边推

	}
	Swap(&a[prev], &a[keyi]);
	return prev;


}

快排最坏的情况是当数组有顺序时，快排的时间复杂度是O(N^2)。所以要采用三数取中的思想，即选取最左边、最右边以及中间下标中的中间值，然后给left交换。可以优化时间。

 

 

int  GetMidIndex(int* a, int left, int right)
{
	int mid = (left + right) / 2;
	/*mid=left+(right-left)/2;*/
	if (a[left] < a[right])
	{
		if (a[right] < a[mid])
		{
			return right;
		}
		else if (a[mid] < a[left])
		{
			return left;
		}
		else
		{
			return mid;
		}
	}
	else  //a[left] > a[right]
	{
		if (a[right] > a[mid])
		{
			return right;
		}
		else if (a[mid] > a[left])
		{
			return left;
		}
		else
		{
			return mid;
		}
	}
}
void QuickSort(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	int keyi = Partion1(a, left, right);
	QuickSort(a, left, keyi - 1);
	QuickSort(a, keyi+1,right);
}

快排的优化：当left和right之间的差值很小时，可以使用插入排序，减少递归次数。插入排序相比于堆排、冒泡排序比较的次数少，相对简单。

void QuickSort(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	//小区间优化。当分割到小区间时，不在用递归
	if (right - left < 10)
	{
		InsertSort(a+left, right - left+1);
	}
	else
	{
		int keyi = Partion2(a, left, right);
		QuickSort(a, left, keyi - 1);
		QuickSort(a, keyi + 1, right);
	}

}

快排的非递归实现：要想写出快排的非递归实现，就要知道递归的具体原理，这里建议大家自己动手画一画递归展开图，这样更有助于理解递归。

快排的递归类似与下图：

 快排的非递归最好是用栈来实现：栈中存储的是数组的左右区间。先入左右区间，然后在循环出左右区间，然后单趟排序，当左区间大于右区间时，就不入栈。

void QuickSortNonR(int* a, int left, int right)
{
	Stack st;
	StackInit(&st);
	StackPush(&st,left);
	StackPush(&st,right);
	while (!StackEmpty(&st))
	{
		int end = StackTop(&st);
		StackPop(&st);

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

		int keyi = Partion(a, begin, end);

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

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

7、归并排序

归并排序就是类似于之前学的链表的练习题，合并两个数组。将两个无序的数组合并成一个有序的数组。

 归并排序的两个核心步骤就是分解和合并。

递归代码如下：

void _MergeSort(int* a, int left, int right, int* temp)
{
	if (left >= right)
	{
		return;
	}
	int mid = (left + right) / 2;
	_MergeSort(a, left, mid,  temp);
	_MergeSort( a, mid+1, right,  temp);
	int begin1 = left, end1 = mid;
	int begin2 = mid + 1, end2 = right;
	int i = left;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] < a[begin2])
		{
			temp[i++] = a[begin1++];
		}
		else
		{
			temp[i++] = a[begin2++];
		}
	}

	while (begin1 <= end1)
	{
		temp[i++] = a[begin1++];
	}
	while (begin2 <= end2)
	{
		temp[i++] = a[begin2++];
	}

	for (int j = left; j <= right; j++)
	{
		a[j] = temp[j];
	}
}

void MergeSort(int* a, int n)
{
	int* temp = (int*)malloc(sizeof(int) * n);
	if (temp == NULL)
	{
		printf("malloc is fail\n");
		exit(-1);
	}
	_MergeSort(a, 0, n - 1, temp);

	free(temp);
	
}

归并的非递归实现：

归并的非递归不需要用栈或者队列，类似于层序遍历。递归的区间是 [0 0] 、[1 1]……[0 4] [4 8] ……每次区间长度增加二倍。所以在非递归中，要用到gap来控制区间大小。同时还要注意区间的修正，因为归并的非递归方式会产生一些非法的区间，所以需要手动修正区间，当end1越界时，把end1给右值，当begin2越界时第二个区间已经无效，但是越需要手动给定一个非法区间。

void MergeSortNonR(int* a, int n)
{
	int* temp = (int*)malloc(sizeof(int) * n);
	if (temp == NULL)
	{
		printf("malloc is fail\n");
		exit(-1);
	}
	int gap = 1;
	while (gap < n)
	{
		for (int i = 0; i < n; i += 2 * gap)
		{
			// [i,i+gap-1] [i+gap, i+2*gap-1]
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2 * gap - 1;
			int index = i;
			//end1越界， [begin2,end2] 不存在
			if (end1 >= n)
			{
				end1 = n - 1;
			}

			if (begin2 >= n)
			{
				begin2 = n;  // 修正成不存在的区间  要不然index会多加一项
				end2 = n - 1;
			}

			if (end2 >= n)
			{
				end2 = n - 1;
			}
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
				{
					temp[index++] = a[begin1++];
				}
				else
				{
					temp[index++] = a[begin2++];
				}
			}
			while (begin1 <= end1)
			{
				temp[index++] = a[begin1++];
			}
			while (begin2 <= end2)
			{
				temp[index++] = a[begin2++];
			}
		}
		//归并可以，走完了在返回去
		for (int j = 0; j < n; j++)
		{
			a[j] = temp[j];
		}
		gap *= 2;
	}
	
	free(temp);
}

归并排序的非递归优化：主要针对修正区间的问题，如果end1越界，那么 区间[begin2 end2]也越界，直接跳出就好。

void MergeSortNonR1(int* a, int n)
{
	int* temp = (int*)malloc(sizeof(int) * n);
	if (temp == NULL)
	{
		printf("malloc is fail\n");
		exit(-1);
	}
	int gap = 1;
	while (gap < n)
	{
		for (int i = 0; i < n; i += 2 * gap)
		{
			// [i,i+gap-1] [i+gap, i+2*gap-1]
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2 * gap - 1;
			int index = i;
			//end1越界， [begin2,end2] 不存在
			if (end1 >= n|| begin2 >= n)
			{
				break;
			}
			if (end2 >= n)
			{
				end2 = n - 1;
			}
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
				{
					temp[index++] = a[begin1++];
				}
				else
				{
					temp[index++] = a[begin2++];
				}
			}
			while (begin1 <= end1)
			{
				temp[index++] = a[begin1++];
			}
			while (begin2 <= end2)
			{
				temp[index++] = a[begin2++];
			}
			for (int j =i; j <=end2; j++)
			{
				a[j] = temp[j];
			}
		}

	
		gap *= 2;
	}

	free(temp);
}

8、计数排序

计数排序是非比较排序，原理是映射。不需要比较数组元素的大小，只需要遍历一遍，便可知道数组元素的个数，然后以数组元素的大小映射第二个数组的下标。然后再用下标映射到数组中排序。

 在第一次遍历时，遍历出数组的最大和最小值，这样是为了节省空间。

void CountSort(int* a, int n)
{
	int max = a[0], min = a[0];
	for (int i = 1; i < n; i++)
	{
		if (a[i] > max)
		{
			max = a[i];
		}
		if (a[i] < min)
		{
			min = a[i];
		}
	}
	int range = max - min+1;
	int* temp = (int*)malloc(sizeof(int) * range);

	if (temp == NULL)
	{
		printf("malloc is fail\n");
		exit(-1);
	}
	memset(temp, 0, sizeof(int) * range);
	for (int i = 0; i < n; i++)
	{
		temp[a[i]-min]++;  //用数值映射下标
	}
	//根据次数进行排数
	int j = 0;
	for (int i = 0; i < range; i++)
	{
		while (temp[i]--)
		{
			a[j++] = i+min;
		 }
	}
}

【数据结构之排序系列】直接插入排序，冒泡排序，直接选择排序，堆排序，希尔排序
胡坚涛的博客
01-30 1776
排序算法章节在校招方面考察是相对比较频繁的，所以本章中所学习的所有排序算法需要引起很大的重视。需要掌握各种排序算法的时间复杂度
数据结构之排序（9种）
齐梦星空
03-01 3126
概览 插入排序 直接插入排序 将数组分为两部分，前半部分有序，后半部分无序，依次从后面取数据，插入到前面指定位置。 def insertSort(nums): size = len(nums) for i in range(1, size): temp = nums[i] # 待排序的数据 count = i-1 # 代表前面有count个数据...
python数据结构之排序
柳小葱的博客
12-23 2320
????上次学习了搜索的算法后，给我印象最深的当然就是hash搜索，学习完搜索之后最为重要的就是排序算法了，对以往内容感兴趣的同学可以查看以下内容????: python数据类型: python数据结构之数据类型. python的输入输出: python数据结构之输入输出、控制和异常. python数据结构之面向对象: python数据结构之面向对象. python数据结构之算法分析: python数据结构之算法分析. python数据结构之栈、队列和双端队列: python数据结构之栈、队列和双端队列.
数据结构——排序之冒泡排序
Renswc的博客
03-22 6234
冒泡排序（BubbleSort）是一种计算机科学领域的较简单的排序算法。它的基本思想是通过重复遍历待排序的数据集，并依次比较相邻的两个数据项，如果它们的顺序错误则进行交换。这个过程会持续重复直到所有相邻的数据项都已经交换完毕，此时说明该数据集已经排好序。冒泡排序的名称来源于排序过程中，较小的数据项会被逐渐“浮”到数组顶部，这个过程就像碳酸饮料中二氧化碳气泡最终会上浮到顶部的现象一样。因此，这种排序算法因其这一特性而得名。冒泡函数的核心思想。
【数据结构】十大排序
热门推荐
英雄哪里出来
01-11 7万+
打开算法大门，从排序开始
数据结构—八大排序
想要上进的coder的博客
01-09 3万+
一、直接插入排序 void InsertSort(int* a, int n) { assert(a); for (int i = 0; i < n - 1; ++i) { int end = i; int x=a[end+1];//将end后面的值保存到x里面了 //将x插入到[0，end]的有序区间 while (end >= 0) { if (a[end] > x) { a[end + 1] = a[end]; //往后挪动一位
数据结构——快速排序
2301_80401288的博客
08-25 5697
本篇博客大致说明了有关快速排序的一些知识。 求点赞收藏关注！！！
数据结构——排序
2303_78442132的博客
01-16 2288
数据结构，排序
数据结构之排序心得
weixin_38359948的博客
02-26 4502
算法的稳定性：如果待排序的两个元素Ri,Rj,其对应的关键字keyi=keyj,且在排序前Ri在Rj的前面，如果排序后Ri还在Rj的前面，则称这种排序算法是稳定的，否则称排序算法是不稳定的。内部排序和外部排序：内部排序是指在排序期间，元素全部存放在内存中的排序。外部排序是指排序期间元素无法全部同时存放在内存中，必须在排序过程中根据要求不断地在内外存之间移动的排序。1.插入排序1）插入排序：每次将一...
数据结构——排序（插入排序）
2302_80919983的博客
10-08 3092
希尔排序是对直接插入排序的改进，也称为缩小增量排序。它通过将数据分成若干个较小的子序列，对每个子序列进行插入排序，然后逐步减少子序列的数量和间隔，最终对整个序列进行一次直接插入排序，使得整个序列基本有序，从而提高排序效率。插入排序是一种简单且直观的排序算法，在实际应用和算法学习中都具有重要地位。它主要分为直接插入排序和希尔排序两种形式，每种都有其独特的特点和应用场景。
数据结构——【排序】详解
Lucky_mzc的博客
03-14 9933
一. 排序💨 1.1 基本概念 排序（sorting）又称分类，就是将一组任意序列得数据元素按一定得规律进行排列（按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作），使之成为有序序列。 平时的上下文中，如果提到排序，通常指的是排升序（非降序）。 通常意义上的排序，都是指的原地排序(in place sort)。 1.2 稳定性 定义：数组 arr 中有若干元素，其中 A元素和 B元素相等，并且 A元素在 B元素前面，如果使用某种排序算法排序后，能够保证 A元素依然在 B元素的前面，可
c语言 数据结构 快速排序算法
04-28
c语言版本的数据结构的快速排序算法，适用于新手学习
数据结构学习笔记排序算法：基数排序
09-17
数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数...
Redis7 新增数据结构深度解析：ListPack 的革新与优化
希望我的博客，能帮上你解决学习中工作中所遇到的问题,也期待与您一起探讨技术问题，共同成长。
05-23 688
Redis 7.0引入了ListPack作为新一代序列化格式，替代了传统的ZipList，成为字符串、哈希、有序集合等数据类型的底层存储引擎。ListPack通过扁平化内存布局、高效的增删操作、优化的遍历机制和兼容性设计，显著提升了内存效率和访问速度。
自学嵌入式 day21 - 数据结构 双向链表
2301_81142331的博客
05-20 1128
双向链表，Makefile
数据结构 -- 交换排序（冒泡排序和快速排序）
最新发布
2202_75324779的博客
05-23 234
注：408原题中说，对所有尚未确定最终位置的所有元素进行⼀遍处理称为“⼀趟”排序，因此⼀次“划分”≠⼀趟排序。若每⼀次选中的“枢轴”将待排序序列划分为很不均匀的两个部分，则会导致递归深度增加，算法效率变低。基于“交换”的排序：根据序列中两个元素关键字的比较结果来对换这两个记录在序列中的位置。若每⼀次选中的“枢轴”将待排序序列划分为均匀的两个部分，则递归深度最⼩，算法效率最⾼。⼀次划分可以确定⼀个元素的最终位置，而⼀趟排序也许可以确定多个元素的最终位置。时间复杂度=O(n*递归层数)
【Python 算法零基础 4.排序 ② 冒泡排序】
m0_73983707的博客
05-19 1400
从未排序序列开始，初始时整个数组都是未排序的。：遍历未排序部分的所有元素，找到其中的最小值。使用变量min_idx记录最小值的索引，初始时假设当前未排序部分的第一个元素是最小的。将找到的最小值与未排序部分的第一个元素交换位置。此时，未排序部分的第一个元素成为已排序序列的一部分。：缩小未排序部分的范围（从下一个元素开始），重复寻找最小值并交换的过程，直到整个数组排序完成。
【数据结构 -- AVL树】用golang实现AVL树
2401_87046050的博客
05-20 983
什么是AVL树，AVL树的思想，以及如何用go语言实现AVL树
C语言图数据结构之拓扑排序实现方法
在C语言中实现图时，通常会使用邻接矩阵或邻接表这两种数据结构。邻接矩阵用二维数组表示图中的边，而邻接表则用链表表示每个顶点的邻接顶点。在拓扑排序中，因为需要表示顶点之间的依赖关系，通常采用有向图。 ###...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

开拓的嚣张

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

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

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

打赏作者

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

抵扣说明：

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

余额充值