排序排序总结

最新推荐文章于 2024-07-24 14:54:00 发布

张江一哥

最新推荐文章于 2024-07-24 14:54:00 发布

阅读量151

点赞数

分类专栏：算法与数据结构文章标签：算法数据结构

本文链接：https://blog.csdn.net/Foxproll/article/details/116398916

版权

算法与数据结构专栏收录该内容

2 篇文章 0 订阅

订阅专栏

0、排序算法说明

0.1 排序的定义
对一序列对象根据某个关键字进行排序。

0.2 术语说明

稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；
不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；
内排序：所有排序操作都在内存中完成；
外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；
时间复杂度：一个算法执行所耗费的时间。
空间复杂度：运行完一个程序所需内存的大小。

0.3 算法复杂度总结

图片名词解释：
n: 数据规模
k: “桶”的个数
In-place: 占用常数内存，不占用额外内存
Out-place: 占用额外内存

0.4 算法分类

0.5 比较和非比较的区别

常见的快速排序、归并排序、堆排序、冒泡排序 等属于比较排序。
在排序的最终结果里，元素之间的次序依赖于它们之间的比较。每个数都必须和其他数进行比较，才能确定自己的位置。

在冒泡排序之类的排序中，问题规模为n，又因为需要比较n次，所以平均时间复杂度为O(n²)。
在归并排序、快速排序之类的排序中，问题规模通过分治法消减为logN次，所以时间复杂度平均O(nlogn)。

比较排序的优势是，适用于各种规模的数据，也不在乎数据的分布，都能进行排序。可以说，比较排序适用于一切需要排序的情况。

计数排序、基数排序、桶排序则属于非比较排序 。
非比较排序是通过确定每个元素之前，应该有多少个元素来排序。针对数组arr，计算arr[i]之前有多少个元素，则唯一确定了arr[i]在排序后数组中的位置。

非比较排序只要确定每个元素之前的已有的元素个数即可，所有一次遍历即可解决。算法时间复杂度O(n)。

非比较排序时间复杂度底，但由于非比较排序需要占用空间来确定唯一位置。所以对数据规模和数据分布有一定的要求。

1.选择排序（Selection Sort）

选择排序是表现最稳定的排序算法之一，因为无论什么数据进去都是O(n2)的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法了吧。

选择排序(Selection-sort) 是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

2.1 算法描述
n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：
步骤1：初始状态：无序区为R[1…n]，有序区为空；
步骤2：第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1…i-1]和R(i…n）。该趟排序从当前无序区中-选出关键字最小的记录
R[k]，将它与无序区的第1个记录R交换，使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
步骤3：n-1趟结束，数组有序化了。

2.2 动图演示

2.3 算法分析
最佳情况：T(n) = O(n2)
最差情况：T(n) = O(n2)
平均情况：T(n) = O(n2)

代码示例：
#include <iostream>
#include <string>
using namespace std;

void swap(int& a, int& b) {
	int t = a;
	a = b;
	b = t;
}

void selectsort(int array[], int len) {
	for (int i = 0; i < len; i++) {
		int min = i;
		for (int j = i+1; j < len; j++) {
			if (array[min] > array[j]) //如果有更小的值，记录下对应的位置编号
				min = j;
		}
		if (min != i)
			swap(array[i], array[min]);
	}
}

int main()
{
	int array[] = {2, 5, 4, 1, 6, 3};
	selectsort(array, 6);
	for (int i = 0; i < 6; i++) {
		cout << array[i] << endl;
	}
	system("pause");
    return 0;
}

2.插入排序（Insertion Sort）

插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

2.1 算法描述
一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：
步骤1: 从第一个元素开始，该元素可以认为已经被排序；
步骤2:取出下一个元素，在已经排序的元素序列中从后向前扫描；
步骤3: 如果该元素（已排序）大于新元素，将该元素移到下一位置；
步骤4:重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
步骤5: 将新元素插入到该位置后；步骤6: 重复步骤2~5。

2.2 动图演示

2.3 算法分析
最佳情况：T(n) = O(n)
最坏情况：T(n) = O(n2)
平均情况：T(n) = O(n2)

代码示例：
int insertsort(int array[], int len) {
	for (int i = 1; i < len; i++) {
		int flag = i;
		int current = array[i];
		for (int j = i - 1; j >= 0 && (array[j] > current); j--) {
			array[j+1] = array[j];
			flag = j;
		}
		if (flag != i)
			array[flag] = current;
	}
}

3. 冒泡排序（Bubble Sort）

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

3.1 算法描述
步骤1: 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
步骤2: 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
步骤3:针对所有的元素重复以上的步骤，除了最后一个；步骤4: 重复步骤1~3，直到排序完成。
3.2 动图演示

3.3 算法分析
最佳情况：T(n) = O(n)
最差情况：T(n) = O(n2)
平均情况：T(n) = O(n2)

代码示例：
void bubblesort(int array[], int len) {
	for (int i = 0; i < len; i++) {
		for (int j = 0; j < len - i - 1; j++) {
			if (array[j - 1] > array[j])
				swap(array[j - 1], array[j]);
		}
	}
}

4.希尔排序（Shell Sort）

希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序，同时该算法是冲破O(n2）的第一批算法之一。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

希尔排序是把记录按下表的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

4.1 算法描述
我们来看下希尔排序的基本步骤，在此我们选择增量gap=length/2，缩小增量继续以gap = gap/2的方式，这种增量选择我们可以用一个序列来表示，{n/2,(n/2)/2…1}，称为增量序列。希尔排序的增量序列的选择与证明是个数学难题，我们选择的这个增量序列是比较常用的，也是希尔建议的增量，称为希尔增量，但其实这个增量序列不是最优的。此处我们做示例使用希尔增量。
先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：
步骤1：选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
步骤2：按增量序列个数k，对序列进行k 趟排序；
步骤3：每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1时，整个序列作为一个表来处理，表长度即为整个序列的长度。

4.2 过程演示

4.3 算法分析

最佳情况：T(n) = O(nlog2 n)
最坏情况：T(n) = O(nlog2 n)
平均情况：T(n) = O(nlog2 n)

代码示例：
void shellsort(int array[], int len) {
	int d = len;
	do {
		d = d / 3 + 1;
		for (int i = d; i < len ; i += d) {
			int flag = i;
			int current = array[i];
			for (int j = i - d; j >=0 && (array[j] > current); j -= d) {
				array[j+d] = array[j];
				flag = j;
			}
			array[flag] = current;
		}
	} while (d > 1);
}

5.归并排序（Merge Sort）

和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(n log n）的时间复杂度。代价是需要额外的内存空间。

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

5.1 算法描述
步骤1：把长度为n的输入序列分成两个长度为n/2的左右两个子序列；
步骤2：对这左右两个子序列分别采用归并排序；
步骤3：将两个排序好的子序列合并成一个最终的排序序列,需要辅助空间。
5.2 动图演示

5.3 算法分析
最佳情况：T(n) = O(n)
最差情况：T(n) = O(nlogn)
平均情况：T(n) = O(nlogn)

代码示例：
void merge (int src[], int helper[], int begin, int mid, int end) {
	int i = begin; //i代表左边的起始位置
	int j = mid + 1; //j代表右边的起始位置
	int k = begin; // k代表了辅助空间的起始位置
	while ((i <= mid)&&(j <= end)) { //左右两边的空间都没有到最后的位置
		if (src[i] < src[j]) { //数据较小的一路放入辅助空间
			helper[k++] = src[i++];
		} else {
			helper[k++] = src[j++];
		}
	}
	//如果左边或者右边先做完，剩下的一边还有数据，一次性拷贝进去
	while (i <= mid) {
		helper[k++] = src[i++];
	}
	while (j <= end) {
		helper[k++] = src[j++];
	}
	for (i = begin; i <= end; i++) {
		src[i] = helper[i]; //将所有的数据拷贝到原始的数组中去
	}
}
void merge (int src[], int helper[], int begin, int end) {
	if (begin == end) { //退出条件：只有一个数据元素的序列，直接就是有序的
		return;
	} else {
		int mid = (begin + end) / 2;
		merge(src, helper, begin, mid); //左边使用递归做归并
		merge(src, helper, mid+1, end); //右边使用递归做归并
		merge(src, helper, begin, mid, end);
	}
}
void merge (int array[], int len) {
	int* helper = new int[len];
	if (helper) {
		merge(array, helper, 0, len -1);
	}
	delete[] helper;
}

6、快速排序（Quick Sort）

快速排序的基本思想：

任取序列中的某个数据元素作为基准将整个序列划分为左右两个子序列
左侧子序列中所有元素都小于或等于基准元素
右侧子序列中所有元素大于基准元素
基准元素排在这两个子序列中间
分别对着两个子序列重复进行划分，知道所有的元素都排在相应位置上为止
6.1 算法描述
快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：
步骤1：从数列中挑出一个元素，称为“基准”（pivot ）；
步骤2：重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
步骤3：递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
6.2 动图演示

6.3 算法分析
最佳情况：T(n) = O(nlogn)
最差情况：T(n) = O(n2)
平均情况：T(n) = O(nlogn)

代码示例：
int partition(int array[], int begin, int end) { //划分函数
	int pivot = array[begin];
	while (begin < end) {
		while (array[end] > pivot) { //右侧大于基准，读指针往左移动
			end--;
		}
		swap(array[begin], array[end]); //右侧不大于基准，交换到左侧开始移动
	
		while (array[begin] < pivot) {
			begin++;
		}
		swap(array[begin], array[end]);
	}
    //当左右指针重合，基准就位
	array[begin] = pivot;
	return begin;
}

void quicksort (int array[], int begin, int end) {
	if (begin < end) {
		int pivot = partition(array, begin, end);
		quicksort(array, begin, pivot-1);
		quicksort(array, pivot+1, end);
	}
}

void quicksort (int array[], int len) {
	quicksort(array, 0, len-1);
}

张江一哥

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
排序排序总结

0、排序算法说明0.1 排序的定义对一序列对象根据某个关键字进行排序。0.2 术语说明稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；内排序：所有排序操作都在内存中完成；外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；时间复杂度：一个算法执行所耗费的时间。空间复杂度：运行完一个程序所需内存的大小。图片名词解释：n: 数据规模k: “桶”的个数In.
复制链接

扫一扫

专栏目录