常用(内部)排序算法

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/LoveHYZH/article/details/86748132

1. 术语说明

  1. 稳定如果a原本在b前面,而a=b,排序之后a仍然在b的前面
  2. 不稳定:如果a原本在b的前面,而a=b,排序之后a可能会出现在b的后面
  3. 内排序:所有排序操作都在内存中完成;
  4. 外排序:由于数据太大,因此把数据放在磁盘中,而排序通过磁盘和内存的数据传输才能进行
  5. 时间复杂度: 一个算法执行所耗费的时间,一般指最差情况下,在规模为nn时,所需执行代码量的数量级
  6. 空间复杂度:运行完一个程序所需内存的大小

2. 排序算法分类

在这里插入图片描述

3. 各种排序算法比较

排序算法 最差时间复杂度 空间复杂度 排序方式 稳定性
直接插入排序 O(n2)O(n^2) O(1)O(1) InplaceIn-place 稳定
希尔排序 O(n2)O(n^2) O(1)O(1) InplaceIn-place 不稳定
简单选择排序 O(n2)O(n^2) O(1)O(1) InplaceIn-place 不稳定
堆排序 O(n×logn)O(n{\times}logn) O(1)O(1) InplaceIn-place 不稳定
冒泡排序 O(n2)O(n^2) O(1)O(1) InplaceIn-place 稳定
快速排序 O(n×logn)O(n{\times}logn) O(logn)O(logn) InplaceIn-place 不稳定
归并排序 O(n×logn)O(n{\times}logn) O(n)O(n) OutplaceOut-place 稳定
计数排序 O(n+k)O(n+k) O(k)O(k) OutplaceOut-place 稳定
桶排序 O(n2)O(n^2) O(n+k)O(n+k) OutplaceOut-place 稳定
基数排序 O(n×k)O(n{\times}k) O(n+k)O(n+k) OutplaceOut-place 稳定

【注】
        nn:数据规模
        kk:“桶”的个数
        InplaceIn-place:不占用额外内存或占用常数的内存
        OutplaceOut-place:占用额外内存

4. 算法实现

4.1 插入排序

4.1.1 直接插入排序

        插入排序(Insertion-Sort)的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。插入排序在实现上,通常采用in-place排序(即只需用到O(1)的额外空间的排序),因而在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间。
算法描述
        ①从第一个元素开始,该元素可以认为已经被排序
        ②取出下一个元素
        ③在已经排序的元素序列中从后向前扫描,如果该元素(已排序)大于新元素,将该元素移到下一位置
        ④重复步骤③,直到找到已排序的元素小于或者等于新元素的位置;
        ⑤将新元素插入到该位置
        ⑥重复步骤②~⑤
动画演示

C++代码

/*
 * @function	
 * 	直接插入排序
 * @parameter
 * ary		存储数据数组
 * n		数组元素个数
 */
void insertionSort(int ary[], int n) {
	for (int i = 1; i < n; i++) {
		int k = i - 1;
		int temp = ary[i];
		while(temp < ary[k] && k >= 0) {
			ary[k + 1] = ary[k];
			k--;
		}
		ary[k + 1] = temp;
	}
}

算法分析

  • 稳定度
    稳定,temp<arr[k], 只有小于的时候后移,等于的时候保持先前的相对位置,所以是稳定的
  • 空间复杂度
    只有一个新增变量存储每次要插入的元素,故空间复杂度为O(1)O(1)
  • 时间复杂度
    最差情况是每一次加入元素都要全比较一遍,即比较f(n)=1+2+3++n1=n(n1)2f(n)=1+2+3+…+n-1=\frac{n(n-1)}{2}次,故T(n)=O(n2)T(n)=O(n^2)

4.1.2 希尔排序

        希尔排序是希尔(Donald Shell)于1959年提出的一种排序算法。希尔排序也是一种插入排序,它是简单插入排序经过改进之后的一个更高效的版本,也称为缩小增量排序,同时该算法是冲破O(n2)O(n^2)的第一批算法之一。它与插入排序的不同之处在于,它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
        希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件恰被分成一组,算法便终止。

动画演示

过程图示

C++代码

/*
 * @function
 *		希尔排序
 * @parameter
 *	ary		存储数据数组
 *	n		数组元素个数
 */
void shellSort(int ary[], int n) {
	int gap = n / 2;
	int temp, k;
	while (gap > 0) {
		for (int i = gap; i < n; i++) {
			temp = ary[i];
			k = i - gap;
			while (temp < ary[k] && k >= 0) {
				ary[k + gap] = ary[k];
				k -= gap;
			}
			ary[k + gap] = temp;
		}
		gap /= 2;
	}
}

算法分析

  • 稳定度
    不稳定,对于相同的两个数,可能由于分在不同的组中而导致它们的顺序发生变化
  • 空间复杂度
    本质上仍是简单选择排序,只是分了组分层次进行,故空间复杂度为O(1)O(1)
  • 时间复杂度
    希尔排序的时间复杂度与增量(即,步长gap)的选取有关,数学上问题没解决,没有具体分析方法,一般T(n)T(n)取值在O(n1.3)O(n^{1.3})~O(n2)O(n^2)

4.2 选择排序

4.2.1 简单选择排序

        表现最稳定的排序算法之一,因为无论什么数据进去都是O(n2)O(n^2)的时间复杂度,所以用到它的时候,数据规模越小越好。
算法描述
        首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。
动画演示

C++代码

/*
 * @function
 *		简单选择排序
 * @parameter
 *	ary		存储数据数组
 *	n		数组元素个数
 */
void selectionSort(int ary[], int n) {
	for (int i = 0; i < n; i++) {
		int k = i;
		for (int j = i + 1; j < n; j++) {
			if (ary[j] < ary[k]) {
				k = j;
			}
		}
		swap(ary[i], ary[k]);	//#include<algorithm>	using namespace std;
	}
}

算法分析

  • 稳定度
    稳定,相同元素交换后仍然保持相对位置
  • 空间复杂度
    空间复杂度为O(1)O(1)
  • 时间复杂度
    每次从规模为nn的队列中选取最小(最大)元素,故总共要比较$f(n)=1+2+3++n1=n(n1)21+2+3+…+n-1=\frac{n(n-1)}{2}次,故T(n)=O(n2)T(n)=O(n^2)

4.2.2 堆排序

        堆排序(Heapsort)是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构,并同时满足堆积的性质:即子结点的键值或索引总是小于(或者大于)它的父节点。
算法描述
        ①首先将待排序的数组构造成一个大根堆,此时,整个数组的最大值就是堆结构的顶端
        ②将顶端的数与末尾的数交换,此时,末尾的数为最大值,剩余待排序数组个数为n-1
        ③将剩余的n-1个数再构造成大根堆,再将顶端数与n-1位置的数交换,如此反复执行,便能得到有序数组
动画演示

C++代码

/*
 * @function
 *		建立最大堆
 * @parameter
 *	ary		存储数据数组
 *	n		数组元素个数
 */
void buildMaxHeap(int ary[],int n) {
	int k = n / 2 - 1; //从最后一个非叶子节点开始,从右向左,从下到上构建最大堆
	for (int i = k; i >= 0; i--) {
		int t = i;
		int c = 2 * t + 1;
		while (c <= n-1) {
			if (c + 1 <= n - 1 && ary[c] < ary[c + 1]) {
				c++;
			}
			if (ary[t] < ary[c]) {
				swap(ary[t], ary[c]);
				t = c;
				c = 2 * t + 1;
			}else {
				break;
			}
		}
	}
}

/*
 * @function
 *		堆排序
 * @parameter
 *	ary		存储数据数组
 *	n		数组元素个数
 */
void heapSort(int ary[], int n) {
	for (int i = n; i > 1; i--) {
		buildMaxHeap(ary, i);
		swap(ary[0], ary[i - 1]);
	}
}

算法分析

  • 稳定度
    不稳定,树状结构,并且从最后一个元素倒着判断的,无法保证相对顺序。
  • 空间复杂度
    空间复杂度为O(1)O(1)
  • 时间复杂度
    时间复杂度为O(n×logn)O(n{\times}logn),主要在重建最大堆时,与层数有关,例如二叉堆就是22的对数

4.3 交换排序

4.3.1 冒泡排序

        冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
算法描述
        从第一个元素开始遍历,比较当前元素跟下一个元素的大小,如果不符合排序,交换位置。结束最后一个元素后,再从头开始不断遍历,直到完成排序。

动画演示

C++代码

/*
 * @function
 *		冒泡排序
 * @parameter
 *	ary		存储数据数组
 *	n		数组元素个数
 */
void bubbleSort(int ary[], int n) {
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n - i - 1; j++) {
			if (ary[j] > ary[j + 1]) {
				swap(ary[j], ary[j + 1]);
			}
		}
	}
}

算法分析

  • 稳定度
    决定于比较的时候用的是大于等于(小于等于)还是大于(小于)
    “≥”不稳定
    “>”稳定
  • 空间复杂度
    空间复杂度为O(1)O(1)
  • 时间复杂度
    时间复杂度为O(n2)O(n^2)

4.3.2 快速排序

        快速排序的基本思想:通过一趟排序将待排记录分隔成独立的两部分,其中一部分记录的关键字均比另一部分的关键字小,则可分别对这两部分记录继续进行排序,以达到整个序列有序。
算法描述
        快速排序使用分治法来把一个串(list)分为两个子串(sub-lists)。具体算法描述如下:
        ①从数列中挑出一个元素,称为 “基准”(pivot)
        ②重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区退出之后,该基准就处于数列的中间位置。这个称为分区(partition)操作。
        ③递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。

动画演示

C++代码

/*
 * @function
 *		分治
 * @parameter
 *	ary		存储数据数组
 *	begin	操作起始下标
 *	end		操作结束下标
 */
int partition(int ary[], int begin,int end) {
	int pivotal = ary[begin];
	int i = begin + 1, j = end;
	while (i <= j) {
		if (ary[i] < pivotal) {
			i++;
		}else if (ary[j] > pivotal) {
			j--;
		}else if (ary[i] >= pivotal && ary[j] <= pivotal) {
			swap(ary[i++], ary[j--]);
		}
	}
	swap(ary[j], ary[begin]);
	return j;
}

/*
 * @function
 *		快速排序递归函数
 * @parameter
 *	ary		存储数据数组
 *	begin	操作起始下标
 *	end		操作结束下标
 */
void quickSort_recursive(int ary[], int left, int right) {
	if (left < right) {
		int k = partition(ary, left, right);
		quickSort_recursive(ary, left, k - 1);
		quickSort_recursive(ary, k+1, right);
	}
}
/*
 * @function
 *		快速排序
 * @parameter
 *	ary		存储数据数组
 *	n	数组元素个数
 */
void quickSort(int ary[], int n) {
	quickSort_recursive(ary, 0, n - 1);
}

算法分析

  • 稳定度
    不稳定
  • 空间复杂度
    空间复杂度为O(logn)O(logn),因为有递归,每一次函数调用都需要一个变量pivotal存储空间
  • 时间复杂度
    时间复杂度最好是哨兵都是区间段重点,为O(n×logn)O(n{\times}logn),最差时就是有序数列,为O(n2)O(n^2),平均为O(n×logn)O(n{\times}logn)

4.4 归并排序

        和选择排序一样,归并排序的性能不受输入数据的影响,但表现比选择排序好的多,因为始终都是O(n×lognO(n{\times} log n)的时间复杂度。代价是需要额外的内存空间
算法描述
        归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法Divide and Conquer)的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为2-路归并

动画演示

C++代码

/*
 * @function
 *		合并两个有序序列
 * @parameter
 *	ary		存储数据数组
 *	l		起始下标
 *	mid		分治的中间下标
 *	r		结束下标
 */
void merge(int ary[], int l, int mid, int r) {
	int i = l, j = mid + 1;
	int * temp = new int[r - l + 1]();
	int k = 0;
	while (i <= mid && j <= r) {
		if (ary[i] <= ary[j]) {
			temp[k++] = ary[i++];
		}else {
			temp[k++] = ary[j++];
		}
	}
	while (i <= mid) {
		temp[k++] = ary[i++];
	}
	while (j <= r) {
		temp[k++] = ary[j++];
	}
	for (int p = l, k = 0; p <= r; p++, k++) {
		ary[p] = temp[k];
	}
	delete[] temp;
}

/*
 * @function
 *		归并排序递归函数
 * @parameter
 *	ary		存储数据数组
 *	l		起始下标
 *	r		结束下标
 */
void mergeSort_recusive(int ary[], int l, int r) {
	if (l < r) {
		int mid = (l + r) / 2;
		mergeSort_recusive(ary, l, mid);
		mergeSort_recusive(ary, mid + 1, r);
		merge(ary, l, mid, r);
	}
}

/*
 * @function
 *		归并排序
 * @parameter
 *	ary		存储数据数组
 *	n		数组元素个数
 */
void mergeSort(int ary[],int n) {
	mergeSort_recusive(ary, 0, n - 1);
}

算法分析

  • 稳定度
    稳定,因为元素相等时不改变位置
  • 空间复杂度
    最大需要的额外空间就是元素要排序的元素个数,所以空间复杂度为O(n)O(n)
  • 时间复杂度
    每次都将子序列分为母序列的一半,所以空间复杂度为O(n×logn)O(n{\times}logn)

4.5 计数排序

        计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序,计数排序要求输入的数据必须是有确定范围的整数
        计数排序(Counting sort)是一种稳定的排序算法。计数排序使用一个额外的数组C,其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。它只能对整数进行排序。
算法描述
        找出待排序的数组中最大和最小的元素;
        统计数组中每个值为ii的元素出现的次数,存入数组CC的第ii项;
        对所有的计数累加(从CC中的第一个元素开始,每一项和前一项相加);
        反向填充目标数组:将每个元素i放在新数组的第C(i)C(i)项,每放一个元素就将C(i)C(i)减去1。

动画演示

算法分析

  • 稳定度
    稳定,注意相同元素顺序,如果只是数值比大小,则无所谓,如果同一元素比较数值但是还有其他不同的属性,则最好用链表来表示桶,并且最好用头插法,上面的例子仅考虑数值排序
  • 空间复杂度
    空间复杂度为O(k)O(k)kk是范围
  • 时间复杂度
    时间复杂度为O(n+k)O(n+k)kk是范围

4.6 桶排序

        桶排序是计数排序的升级版。它利用了函数的映射关系,高效与否的关键就在于这个映射函数的确定。
        桶排序 (Bucket sort)的工作的原理:假设输入数据服从均匀分布,将数据分到有限数量的桶里,每个桶再分别排序(有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排
算法描述
        人为设置一个BucketSize,作为每个桶所能放置多少个不同数值(例如当BucketSize=5时,该桶可以存放{1,2,3,4,5}这几种数字,但是容量不限,即可以存放100个3);
        遍历输入数据,并且把数据一个一个放到对应的桶里去;
        对每个不是空的桶进行排序,可以使用其它排序方法,也可以递归使用桶排序;
        从不是空的桶里把排好序的数据拼接起来。
注意
        如果递归使用桶排序为各个桶排序,则当桶数量为1时要手动减小BucketSize增加下一循环桶的数量,否则会陷入死循环,导致内存溢出
图片演示

算法分析
        桶排序最好情况下使用线性时间O(n)O(n),桶排序的时间复杂度,取决与对各个桶之间数据进行排序的时间复杂度,因为其它部分的时间复杂度都为O(n)O(n)。很显然,桶划分的越小,各个桶之间的数据越少,排序所用的时间也会越少。但相应的空间消耗就会增大。
        最佳情况:T(n)=O(n+k)T(n) = O(n+k) 最差情况:T(n)=O(n2)T(n) = O(n^2) 平均情况:T(n)=O(n+k)T(n) = O(n+k)

4.7 基数排序

        基数排序也是非比较的排序算法,对每一位进行排序,从最低位开始排序,复杂度为O(n×k)O(n{\times}k),为数组长度,kk为数组中的数的最大的位数;
        基数排序是按照低位先排序,然后收集;再按照高位排序,然后再收集;依次类推,直到最高位。有时候有些属性是有优先级顺序的,先按低优先级排序,再按高优先级排序。最后的次序就是高优先级高的在前,高优先级相同的低优先级高的在前。基数排序基于分别排序,分别收集,所以是稳定的。
算法描述
        ①取得数组中的最大数,并取得位数;
        ②ary为原始数组,从最低位开始取每个位组成radix数组;
        ③对radix进行计数排序(利用计数排序适用于小范围数的特点);

动画演示

算法分析

  • 稳定度
    稳定,基数排序基于分别排序,分别收集,所以是稳定的
  • 空间复杂度
    基数排序的空间复杂度为O(n+k)O(n+k),其中kk为桶的数量。一般来说n&gt;&gt;kn&gt;&gt;k,因此额外空间需要大概nn个左右
  • 时间复杂度
    最佳情况:T(n)=O(n×k)T(n) = O(n{\times}k) 最差情况:T(n)=O(n×k)T(n) = O(n{\times}k) 平均情况:T(n)=O(n×k)T(n) = O(n{\times}k)
  • 基数排序 vs 计数排序 vs 桶排序
    这三种排序算法都利用了桶的概念,但对桶的使用方法上有明显差异:
            基数排序:根据键值的每位数字来分配桶
            计数排序:每个桶只存储单一键值
            桶排序:每个桶存储一定范围的数值

没有更多推荐了,返回首页