排序算法分析

sy'ty

已于 2023-07-02 07:35:08 修改

阅读量63

点赞数 1

分类专栏：数据结构初阶文章标签：排序算法算法数据结构

于 2023-04-18 22:08:24 首次发布

本文链接：https://blog.csdn.net/gtyyky/article/details/130203087

版权

数据结构初阶专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一、排序的概念及其运用

1.1排序的概念

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

1.2 常见的排序算法

在这里插入图片描述

二、常见排序算法的实现

2.1 插入排序

2.1.1基本思想：

直接插入排序是一种简单的插入排序法，其基本思想是：
把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列。

2.1.2直接插入排序：

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

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

// 插入排序,n为数组元素的个数
// 升序
// 最坏：O(N^2)  逆序
// 最好：O(N)    顺序有序
void InsertSort(int* a, int n)
{
	assert(a);
	//插入数据从数组的第二个元素开始，依次往后插入
	for (int i = 1; i < n; i++)
	{
		//i代表每次新插入的数据的下标，end每次都从最后一个开始比较，所以是i-1
		int end = i - 1;
		//首先保存要排序的数，一会就会被覆盖了
		int tmp = a[i];
		while (end >= 0)//end代表每次排序从后往前比较的下标，最差的情况就是插入的数据比所有的数据小，所以end一直往前减，最差插入到第一个位置	
		{
			if (tmp < a[end])
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		//当数据都整体往后移动，将tmp赋值到最前面，
		//由于前面end执行完又减了1，所以这里end需要重新加上1
		a[end + 1] = tmp;
	}
}

2.1.3 希尔排序( 缩小增量排序 )

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

希尔排序是对直接插入排序的优化。
当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些书中给出的希尔排序的时间复杂度都不固定：
《数据结构(C语言版)》— 严蔚敏

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

因为咱们的gap是按照Knuth提出的方式取值的，而且Knuth进行了大量的试验统计，我们暂时就按照：O(n^1.25)到O(1.6 * n^1.25) 来算。
稳定性：不稳定

步骤：
1.预排序 – 目标：数组接近有序
2.直接插入排序(当数组接近有序的时候，直接插入排序的效率更高，所以当gap等于1的时候是直接插入排序)

// 希尔排序
//一组排完再排另一排
void ShellSort(int* a, int n)
{
	//int gap = 3;
	//for (int j = 0; j < gap; j++)
	//{		
	//	for (int i = j; i < n-gap; i+=gap)
	//	{
	//		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;
	//	}
	//}

	//优化版本
	// gap > 1 预排序
	// gap == 1 直接插入排序
	int gap = n;
	//不能写成大于0,因为gap的值始终>=1
	while (gap > 1)
	{
		//gap /= 2;//和下面两种方法都可以，n从大到小，先进行预排序，再进行直接插入排序
		//最后一次进入后，gap等于1，执行完最后一次直接插入排序
		gap = gap / 3 + 1;//这里加1保证最后一次gap为1
		for (int j = 0; j < gap; j++)//有gap组数据需要排序
		{
			for (int i = j; i < n - gap; i += gap)
			{
				int end = i;
				int tmp = a[end + gap];
				//两个条件退出循环，当end<0,或者当tmp不小于a[end]的时候退出，并将tmp的值赋给a[end]
				while (end >= 0)
				{
					if (tmp < a[end])
					{
						a[end + gap] = a[end];
						end -= gap;
					}
					else
					{
						break;
					}
				}
				a[end + gap] = tmp;
			}
		}
	}

}
//多组并排
//void ShellSort(int* a, int n)
//{
//	int gap = 3;
		//这里只是把插入排序的1换成gap即可
		//但是这里不是排序完一个分组，再去
		//排序另一个分组，而是整体只过一遍
		//这样每次对于每组数据只排一部分
		//整个循环结束之后，所有组的数据排序完成
//	for (int j = 0; j < gap; j++)
//	{
//		for (int i = j; 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;
//		}
//	}
//}

2.2 选择排序

2.2.1基本思想：

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

2.2.2 直接选择排序:

在元素集合array[i]–array[n-1]中选择关键码最大(小)的数据元素
若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换
在剩余的array[i]–array[n-2]（array[i+1]–array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素
在这里插入图片描述
直接选择排序的特性总结：

直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
时间复杂度：O(N^2)
空间复杂度：O(1)
稳定性：不稳定

//选择排序
void Swap(int* a,int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
// 最坏：O(N^2)
// 最好：O(N^2).
void SelectSort(int* a, int n)
{
	int left = 0; int right = n - 1;

	//当左右下标指向同一个数的时候停止循环
	while (left < right)
	{
		int mini = left;int maxi = left;//注意这里是每次排序完要把mini和maxi的值重新初始化到left，否则下一轮循环查找left的数字没有进行对比

		//从第二个数开始与前一个数进行比较
		//每次循环找出区间中最大的数和最小的数
		for (int i = left + 1; i <= right; i++)
		{
			if (a[i] < a[mini])
			{
				mini = i;
			}
			if (a[i] > a[maxi])
			{
				maxi = i;
			}
		}

		//将最小的数移动到最前面	
		Swap(&a[mini], &a[left]);
		//如果最大数的下标刚好在left位置，又因为上一步的交换，下标left和mini的位置数值交换了，
		//所以此时下标maxi的数值交换到了下标mini位置，即将下标mini赋给下标maxi就行
		if (left == maxi)
		{
			maxi = mini;
		}

		//将最大的数移动到最前面
		Swap(&a[maxi], &a[right]);

		left++;
		right--;
	}
}

2.2.3 堆排序

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。
在这里插入图片描述
直接选择排序的特性：

堆排序使用堆来选数，效率就高了很多。
时间复杂度：O(N*logN)
空间复杂度：O(1)
稳定性：不稳定

// 堆排序
void AdjustDown(int* a, int n, int parent)//建堆
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		//选择大的孩子进行交换
		if (child + 1 < n && a[child + 1] > a[child])
		{
			child++;
		}
		if (a[child] > a[parent]) 
		{
			Swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
void HeapSort(int* a, int n)
{
	// 建堆 -- 向下调整建堆 -- O(N)
	//(n-1)为最后一个数的下标，(n - 1 - 1) / 2为找到最后一个数的母亲下标
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}
	
	//O(N*logN)
	//将最后的一位数挪到前面,与大堆的首元素（最大数）进行交换，然后end--，重复循环
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}

2.3 交换排序

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

2.3.1冒泡排序

冒泡排序的特性总结：

冒泡排序是一种非常容易理解的排序
时间复杂度：O(N^2)
空间复杂度：O(1)
稳定性：稳定

//冒泡排序
// 最坏：O(N^2)
// 最好：O(N)
void BubbleSort(int* a, int n)
{
	//外循环控制每次排序的区间，刚开始第一位数与所有数比较，然后每次比较数依次从后往前递减1
	for (int j = 0; j < n; j++)
	{
		bool exchange = false;
		//前一个数跟后一个数比较
		for (int i = 1; i < n - j; i++)
		{
			if (a[i - 1] > a[i])
			{
				Swap(&a[i - 1], &a[i]);
				exchange = true;
			}
		}
		
		//有一趟循环没有交换说明排序完毕
		if (exchange == false)
		{
			break;
		}
	}
}

2.3.2 快速排序

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

// 假设按照升序对array数组中[left, right)区间中的元素进行排序
void QuickSort(int array[], int left, int right)
{
	if(right - left <= 1)
	return;
	// 按照基准值对array数组的 [left, right)区间中的元素进行划分
	int keyi = PartSort3(a, left, right);
	// 划分成功后以div为边界形成了左右两部分 [left, div) 和 [div+1, right)
	// 递归排[left, div)
	QuickSort(array, left, div);
	// 递归排[div+1, right)
	QuickSort(array, div+1, right);
}

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

hoare版本

//快速排序
int GetMidNumi(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[left] < a[right])
		{
			return right;
		}
		else
		{
			return left;
		}
	}
	else// a[left] > a[mid]
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if(a[left] < a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}
//快速排序核心思想，keyi先用三数取中放在左边，防止原来数组有序，
// 每次排序将比keyi小的值放在左边，比keyi大的值放在右边，最后将keyi放在两边的数中间，返回keyi，供给下面的递归排序
//快速排序方法一
int PartSort1(int* a, int left, int right)
{
	//三数取中，将中间数的值与left的值对调，防止原来是有序的
	int midi = GetMidNumi(a, left, right);
	if (midi != left)
		Swap(&a[left], &a[midi]);

	int keyi = left;
	while (left < right)
	{
		//右边找小
		while (left < right && a[right] >= a[keyi])
			right--;		
		//左边找大
		while (left < right && a[left] <= a[keyi])
			left++;
		//将当前left和right值下的循环的最大值和最小值进行交换
		Swap(&a[left], &a[right]);
	}
	//left和right相遇，将keyi的值与相遇位置交换，此刻，keyi左边的值比keyi位置的值小，右边的值比keyi位置的值大
	Swap(&a[left], &a[keyi]);
	keyi = left;

	return keyi;
}

挖坑法

//挖坑法
int PartSort2(int* a, int left, int right)
{
	int mid = GetMidNumi(a, left, right);
	if (mid != left)
		Swap(&a[left], &a[mid]);
	
	int key = a[left];//先将key的值给存起来，这里的key主要是存a[left]的值，而不是位置
	int hole = left;//hole存位置，刚开始位置为最左边的位置
	while (left < right)
	{
		//右边找小
		while (left < right && a[right] >= key)
			right--;		
		a[hole] = a[right];//右边找到小，将小的值赋值给hole位置，将hole移动到right位置
		hole = right;

		//左边找大
		while (left < right && a[left] <= key)
			left++;
		a[hole] = a[left];//左边找到大，将大的值赋值给hole位置，将hole移动到乐left位置
		hole = left;
	}
	//最后将key的值补到hole上
	a[hole] = key;

	return hole;
}

前后指针版本

//前后指针法
int PartSort3(int* a, int left, int right)
{
	int mid = GetMidNumi(a, left, right);
	if (mid != left)
		Swap(&a[left], &a[mid]);

	int keyi = left;

	int prev = left;
	int cur = left + 1;
	while (cur <= right)
	{
		//当cur的值小于keyi，且prev下一个位置不等于cur，就将prev下一个位置的值与cur位置的值交换
		if (a[cur] < a[keyi] && ++prev != cur)
			Swap(&a[cur], &a[prev]);
		//不管有没有交换，cur++；
		cur++;
	}
	//当交换完毕，将prev位置的值与left的值交换
	Swap(&a[left], &a[prev]);
	//将prev赋值给keyi，此刻，keyi左边的值比keyi位置的值小，右边的值比keyi位置的值大
	keyi = prev;

	return keyi;
}

2.3.3 快速排序优化

三数取中法选key
递归到小的子区间时，可以考虑使用插入排序

void QuickSort(int* a, int left, int right)
{
	//当left大于等于right的时候不进入排序，返回递归
	if (left >= right)
		return;
	// 小区间优化--小区间直接使用插入排序
	if (right - left + 1 > 10)//eg.[0-9]闭区间有十个数，但9-0只有9，所以需要加上1
	{
		int keyi = PartSort3(a, left, right);
		QuickSort(a, left, keyi - 1);
		QuickSort(a, keyi + 1, right);
	}
	else
	{
		InsertSort(a + left, right - left + 1);//小区间有可能在中间位置，所以需要a需要加上left
	}
}

2.3.2 快速排序非递归

//需要利用栈先进后出的思想，其中栈存的是两端区间的值
//使用栈来完成非递归的快速排序，开始先将right和left压入栈中，然后进行单次排序，
//排序后把keyi值返回，分成两个子区间，如果子区间不止一个数，就将其再压入栈中，
//再进行排序，直到栈中所有的区间都被pop
void QuickSortNonR(int* a, int left, int right)
{
	ST st;
	STInit(&st);
	//注意push的顺序，栈是后进先出，需要先将right放进去
	STPush(&st, right);
	STPush(&st, left);

	while (!STEmpty(&st))
	{

		int begin = STTop(&st);
		STPop(&st);
		int end = STTop(&st);
		STPop(&st);

		int keyi = PartSort3(a, begin, end);
		//[begin,keyi-1]keyi[keyi+1,end]
		if (keyi + 1 < end)
		{
			STPush(&st, end);
			STPush(&st, keyi+1);
		}
		if (begin < keyi - 1)
		{
			STPush(&st, keyi - 1);	
			STPush(&st, begin);
		}
	}

	STDestory(&st);
}

快速排序的特性总结：

快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
时间复杂度：O(N*logN)
空间复杂度：O(logN)
稳定性：不稳定

2.4 归并排序

基本思想：
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。归并排序核心步骤：
在这里插入图片描述
归并排序的特性总结：

归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
时间复杂度：O(N*logN)，归并排序是一种二分排序算法，每次都需要给n个元素排序，排序的过程需要logn,即树的高度，所以时间复杂度为nlogn
空间复杂度：O(N)
稳定性：稳定

// 归并排序递归实现
void _MergeSort(int* a, int begin, int end, int* tmp)
{
	//当begin等于end或者没有区间的时候返回，此时也只剩下一个数，开始实现有序了，开始归并
	if (begin >= end)
		return;

	int mid = (end + begin) / 2;
	//[begin,mid] [mid+1,end],子区间递归排序
	_MergeSort(a, begin, mid, tmp);
	_MergeSort(a, mid+1, end, tmp);

	// [begin, mid] [mid+1,end]归并，第一次开始归并是只剩下一个数的时候，所以此时一定是有序的，开始归并
	int begin1 = begin; int end1 = mid;
	int begin2 = mid + 1; int end2 = end;
	//i不能使用0，因为处理第一次归并，经过前面的归并，tmp已经存了一些值了，此时重新归并，应该从begin开始
	int i = begin;
	//比较两个子区间各个位置的大小 
	while (begin1 <= end1 && begin2 <= end2)//此时需要加上等于，因为是闭区间，所以最后一个数也需要排序
	{
		if (a[begin1] < a[begin2])
		{
			tmp[i++] = a[begin1++];
		}
		if (a[begin2] < a[begin1])
		{
			tmp[i++] = a[begin2++];
		}
	}
	while (begin1 <= end1)
	{
		tmp[i++] = a[begin1++];
	}
	while (begin2 <= end1)
	{
		tmp[i++] = a[begin2++];
	}

	memcpy(a + begin, tmp + begin, sizeof(int) * (end - begin + 1));
}
//将归并函数分开写，这样就不用每次递归都开辟tmp;
void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) / sizeof(a[0]));
	if (tmp == NULL)
	{
		perror("malloc fail");
		return;
	}
	_MergeSort(a, 0, n - 1, tmp);

	free(tmp);
}

// 归并排序非递归实现
//方法一：梭哈法
void MergeSortNonR1(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 += gap * 2 )
		{

			int begin1 = i; int end1 = i + gap - 1;
			int begin2 = i + gap; int end2 = i + gap * 2 - 1;

			//end1越界
			if (end1 >= n)
			{
				end1 = n - 1;
				begin2 = n; //这样做修正，可以避免[begin2,end2]进行归并，导致越界
				end2 = n - 1;
			}
			//begin2越界
			else if (begin2 >= n)
			{
				begin2 = n;
				end2 = n - 1;//这样做修正，可以避免[begin2,end2]进行归并，导致越界
			}
			//end2越界
			else if (end2 >= n)
			{
				end2 = n - 1;//修正end2，可以使得[begin2,end2]之间的数进行归并
			}
			printf("[%d][%d][%d][%d]", begin1, end1, begin2, end2);

			int j = i;
			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++];
			}
		}
		printf("\n");
		// 间距为gap的多组数据，归并完以后，一把拷贝(梭哈)
		memcpy(a, tmp, sizeof(int)* n);
		gap *= 2;
	}
	free(tmp);
}
//方法二：归并一部份拷贝一部分
void MergeSortNonR2(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail\n");
		return;
	}

	int gap = 1;
	while (gap < n)
	{
		for (int i = 0; i < n; i += gap * 2)
		{

			int begin1 = i; int end1 = i + gap - 1;
			int begin2 = i + gap; int end2 = i + gap * 2 - 1;

			if (end1 >= n || begin2 >= n)
			{
				break;
			}

			else if (end2 >= n)
			{
				end2 = n - 1;//修正end2，可以使得[begin2,end2]之间的数进行归并
			}
			printf("[%d][%d][%d][%d]", begin1, end1, begin2, end2);

			int j = i;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
				{
					tmp[j++] = a[begin1++];
				}
				if (a[begin2] < a[begin1])
				{
					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) * (end2 - i + 1));
		}
		gap *= 2;
		printf("\n");
	}
	free(tmp);
}

2.5 非比较排序

思想：计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。操作步骤：

统计相同元素出现次数
根据统计的结果将序列回收到原来的序列中

在这里插入图片描述

计数排序的特性总结：

计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。
时间复杂度：O(MAX(N,范围))
空间复杂度：O(范围)
稳定性：稳定

// 计数排序
void CountSort(int* a, int n)
{
	int min = a[0];
	int 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* countA = (int*)malloc(sizeof(int) * range);
	if (countA == NULL)
	{
		perror("malloc fail\n");
		return;
	}
	//将counA的值初始化为0，这里也可以用clloc,这样可以省略掉memset
	memset(countA, 0, sizeof(int) * range);

	//计数
	for (int i = 0; i < n; i++)
	{
		countA[a[i] - min]++;
	}
	//排序
	int j = 0;
	for (int i = 0; i < range; i++)
	{
		while (countA[i]--)
		{
			a[j++] = i + min;
		}
	}

	free(countA);
}

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

在这里插入图片描述

sy'ty

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
排序算法分析

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

扫一扫