排序算法

最新推荐文章于 2022-02-03 22:39:45 发布

丫就是熊个猫猫

最新推荐文章于 2022-02-03 22:39:45 发布

阅读量511

点赞数

分类专栏：面试笔试题文章标签：排序算法插入排序算法存储

本文链接：https://blog.csdn.net/wzhCAlex/article/details/76546552

版权

面试笔试题专栏收录该内容

38 篇文章 3 订阅

订阅专栏

排序算法

一、插入排序——直接插入排序（Straight InsertionSort）

基本思想：将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。

要点：设立哨兵，作为临时存储和判断数组边界之用。

如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。

算法实现：

template<typename T>
void insertionSort(T arr[], int n){   //插入排序
	for (int i = 1; i < n; i++){
		//寻找元素arr[i]合适的插入位置
		T e = arr[i];
		int j;   //保存元素e应该插入的位置
		for (j = i; j > 0 && arr[j - 1] > e; j--){
			arr[j] = arr[j - 1];
		}
		arr[j] = e;
	}
}
template<typename T>
void insertionSort(T arr[], int l, int r){
	for (int i = l + 1; i <= r; i++)
	{
		T e = arr[i];
		int j;
		for (j = i; j > l && arr[j - 1] > e; j--){
			arr[j] = arr[j - 1];
		}
		arr[j] = e;
	}

	return;
}

效率：时间复杂度：O(n^2)

二、插入排序——希尔排序（ShellSort）

基本思想：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

操作方法：

选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；

按增量序列个数k，对序列进行k 趟排序；

每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

算法实现：

template<typename T>
void shellSort(T arr[], int n){

	int h = 1;
	while (h < n / 3)
		h = 3 * h + 1;
	// 计算 increment sequence: 1, 4, 13, 40, 121, 364, 1093...

	while (h >= 1){

		// h-sort the array
		for (int i = h; i < n; i++){

			// 对 arr[i], arr[i-h], arr[i-2*h], arr[i-3*h]... 使用插入排序
			T e = arr[i];
			int j;
			for (j = i; j >= h && e < arr[j - h]; j -= h)
				arr[j] = arr[j - h];
			arr[j] = e;
		}

		h /= 3;
	}
}

希尔排序时效分析很难，关键码的比较次数与记录移动次数依赖于增量因子序列d的选取，特定情况下可以准确估算出关键码的比较次数和记录的移动次数。目前还没有人给出选取最好的增量因子序列的方法。增量因子序列可以有各种取法，有取奇数的，也有取质数的，但需要注意：增量因子中除1 外没有公因子，且最后一个增量因子必须为1。希尔排序方法是一个不稳定的排序方法。

三、选择排序——简单选择排序（Simple SelectionSort）

基本思想：在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。

操作方法：

第一趟，从n 个记录中找出关键码最小的记录与第一个记录交换；

第二趟，从第二个记录开始的n-1 个记录中再选出关键码最小的记录与第二个记录交换；

以此类推.....

第i 趟，则从第i 个记录开始的n-i+1 个记录中选出关键码最小的记录与第i 个记录交换，

直到整个序列按关键码有序。

算法实现：

template<typename T>
void selectionSort(T arr[], int n){    //选择排序
	for (int i = 0; i < n; i++)
	{
		//寻找[i,n)区间里最小值
		int minIndex = i;
		for (int j = i + 1; j < n; j++)
		{
			if (arr[j] < arr[minIndex])
			{
				minIndex = j;
			}
		}
		swap(arr[i], arr[minIndex]);
	}
}

四、选择排序——堆排序（Heap Sort）

基本思想：

堆的定义如下：具有n个元素的序列（k1,k2,...,kn),当且仅当满足

时称之为堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最小项（小顶堆）。

若以一维数组存储一个堆，则堆对应一棵完全二叉树，且所有非叶结点的值均不大于(或不小于)其子女的值，根结点（堆顶元素）的值是最小(或最大)的。如：

（a）大顶堆序列：（96, 83,27,38,11,09)

(b) 小顶堆序列：（12，36，24，85，47，30，53，91）

初始时把要排序的n个数的序列看作是一棵顺序存储的二叉树（一维数组存储二叉树），调整它们的存储序，使之成为一个堆，将堆顶元素输出，得到n 个元素中最小(或最大)的元素，这时堆的根节点的数最小（或者最大）。然后对前面(n-1)个元素重新调整使之成为堆，输出堆顶元素，得到n 个元素中次小(或次大)的元素。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。称这个过程为堆排序。

因此，实现堆排序需解决两个问题：

1. 如何将n 个待排序的数建成堆；

2. 输出堆顶元素后，怎样调整剩余n-1 个元素，使其成为一个新堆。

首先讨论第二个问题：输出堆顶元素后，对剩余n-1元素重新建成堆的调整过程。

调整小顶堆的方法：

1）设有m 个元素的堆，输出堆顶元素后，剩下m-1 个元素。将堆底元素送入堆顶（（最后一个元素与堆顶进行交换），堆被破坏，其原因仅是根结点不满足堆的性质。

2）将根结点与左、右子树中较小元素的进行交换。

3）若与左子树交换：如果左子树堆被破坏，即左子树的根结点不满足堆的性质，则重复方法（2）.

4）若与右子树交换，如果右子树堆被破坏，即右子树的根结点不满足堆的性质。则重复方法（2）.

5）继续对不满足堆性质的子树进行上述交换操作，直到叶子结点，堆被建成。

称这个自根结点到叶子结点的调整过程为筛选。如图：

再讨论对n 个元素初始建堆的过程。

建堆方法：对初始序列建堆的过程，就是一个反复进行筛选的过程。

1）n 个结点的完全二叉树，则最后一个结点是第个结点的子树。

2）筛选从第个结点为根的子树开始，该子树成为堆。

3）之后向前依次对各结点为根的子树进行筛选，使之成为堆，直到根结点。

如图建堆初始过程：无序序列：（49，38，65，97，76，13，27，49）

算法的实现：

//堆排序
template <typename T>
void __shiftDown(T arr[], int n, int k)
{
	while (2 * k + 1 < n){
		int j = 2 * k + 1;
		if (j + 1 < n && arr[j + 1] > arr[j])
			j += 1;
		if (arr[k] >= arr[j])
			break;

		swap(arr[k], arr[j]);
		k = j;
	}
}

template <typename T>
void heapSort(T arr[], int n){
	for (int i = (n - 1) / 2; i >= 0; i--){
		__shiftDown(arr, n, i);
	}
	for (int i = n - 1; i >= 0; i--){
		swap(arr[0], arr[i]);
		__shiftDown(arr, i, 0);
	}
}

效率：时间复杂度：最坏情况下时间复杂度为O(nlogn)

五、交换排序——冒泡排序（Bubble Sort）

基本思想：

在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

算法的实现:

//冒泡排序
template<typename T>
void bubbleSort(T arr[], int n){

	bool swapped;

	do{
		swapped = false;
		for (int i = 1; i < n; i++)
		if (arr[i - 1] > arr[i]){
			swap(arr[i - 1], arr[i]);
			swapped = true;
		}

		n--;

	} while (swapped);
}

六、交换排序——快速排序（Quick Sort）

基本思想：

1）选择一个基准元素,通常选择第一个元素或者最后一个元素,

2）通过一趟排序讲待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的元素值比基准值大。

3）此时基准元素在其排好序后的正确位置

4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。

算法的实现：

//三路快速排序处理arr[l...r]
//将arr[l...r]分为< v;==v; >v三部分
//之后递归对<v;>v两部分继续进行三路快速排序
template <typename T>
void __quickSort3Ways(T arr[], int l, int r)
{
	if (r - l < 15){
		insertionSort(arr, l, r);
		return;
	}
	//partition
	swap(arr[l], arr[rand() % (r - l + 1) + l]);
	T v = arr[l];

	int lt = l;//arr[l+1,lt] < v
	int gt = r + 1;//arr[gt...r] > v
	int i = l + 1;//arr[lt+1...i] == v

	while (i < gt)
	{
		if (arr[i] < v){
			swap(arr[i], arr[lt + 1]);
			lt++;
			i++;
		}
		else if (arr[i] > v){
			swap(arr[i], arr[gt - 1]);
			gt--;
		}
		else{//arr[i] == v
			i++;
		}
	}
	swap(arr[l], arr[lt]);

	__quickSort3Ways(arr, l, lt - 1);
	__quickSort3Ways(arr, gt, r);
}

template <typename T>
void quickSort3Ways(T arr[], int n)
{
	srand(time(NULL));
	__quickSort3Ways(arr, 0, n - 1);
}
//对arr[l...r]部分进行partition操作
//返回p,使得arr[l...p-r] < arr[p];arr[p+1...r]>arr[p]
template<typename T>
int __partition2(T arr[], int l, int r){
	swap(arr[l], arr[rand() % (r - l + 1) + l]);

	T v = arr[l];

	//arr[l+1...i]<=v;arr[j...r] >= v
	int i = l + 1, j = r;
	while (true){
		while (i <= r && arr[i] < v) i++;
		while (j >= l + 1 && arr[j] > v) j--;
		if (i > j) break;
		swap(arr[i], arr[j]);
		i++;
		j--;
	}
	swap(arr[l], arr[j]);

	return j;
}
//对arr[l...r]部分进行快速排序
template<typename T>
void __quickSort2(T arr[], int l, int r)
{
	//if (l >= r)
	//{
	//	return;
	//}

	if (r - l <= 15)
	{
		insertionSort(arr, l, r);
		return;
	}

	int p = __partition2(arr, l, r);
	__quickSort2(arr, l, p - 1);
	__quickSort2(arr, p + 1, r);
}
//双路快速排序法
template<typename T>
void quickSort2(T arr[], int n)
{
	srand(time(NULL));
	__quickSort2(arr, 0, n - 1);
}

//对arr[l...r]部分进行partition操作
//返回p,使得arr[l...p-r] < arr[p];arr[p+1...r]>arr[p]
template<typename T>
int __partition(T arr[], int l, int r){
	swap(arr[l], arr[rand() % (r - l + 1) + l]);

	T v = arr[l];

	//arr[l+1...v]<v;arr[j+1...i] > v
	int j = l;
	for (int i = l + 1; i <= r; i++){
		if (arr[i] < v)
		{
			swap(arr[j + 1], arr[i]);
			j++;
		}
	}
	swap(arr[l], arr[j]);

	return j;
}
//对arr[l...r]部分进行快速排序
template<typename T>
void __quickSort(T arr[], int l, int r)
{
	//if (l >= r)
	//{
	//	return;
	//}

	if (r - l <= 15)
	{
		insertionSort(arr, l, r);
		return;
	}

	int p = __partition(arr, l, r);
	__quickSort(arr, l, p - 1);
	__quickSort(arr, p + 1, r);
}

template<typename T>
void quickSort(T arr[], int n)
{
	srand(time(NULL));
	__quickSort(arr, 0, n - 1);
}

七、归并排序（Merge Sort）

基本思想：

归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

合并方法：

设r[i…n]由两个有序子表r[i…m]和r[m+1…n]组成，两个子表长度分别为n-i +1、n-m。

j=m+1；k=i；i=i; //置两个子表的起始下标及辅助数组的起始下标

若i>m 或j>n，转⑷ //其中一个子表已合并完，比较选取结束

//选取r[i]和r[j]较小的存入辅助数组rf

如果r[i]<r[j]，rf[k]=r[i]； i++； k++；转⑵

否则，rf[k]=r[j]； j++； k++；转⑵

//将尚未处理完的子表中元素存入rf

如果i<=m，将r[i…m]存入rf[k…n] //前一子表非空

如果j<=n , 将r[j…n] 存入rf[k…n] //后一子表非空

合并结束。

算法的实现:

//自底向上的归并排序算法
template<typename T>
void mergeSortBU(T arr[], int n)
{
	for (int sz = 1; sz <= n; sz += sz)
	{
		for (int i = 0; i < n; i += sz + sz)
		{
			//对arr[i...i+sz-1]和arr[i+sz...i+2*sz-1]进行归并
			__merge(arr, i, i + sz - 1, min(i + sz + sz - 1, n - 1));
		}
	}
}

//将arr[l...mid]和arr[mid+1...r]两部分进行归并
template <typename T>
void __merge(T arr[], int l, int mid, int r)
{
	T *aux = new T[r - l + 1];

	for (int i = l; i <= r; i++)
	{
		aux[i - l] = arr[i];
	}
	int i = l;
	int j = mid + 1;
	for (int k = l; k <= r; k++)
	{
		if (i > mid){
			arr[k] = aux[j - l];
			j++;
		}
		else if (j > r){
			arr[k] = aux[i - l];
			i++;
		}
		else if (aux[i - l] < aux[j - l])
		{
			arr[k] = aux[i - l];
			i++;
		}
		else
		{
			arr[k] = aux[j - l];
			j++;
		}
	}
	delete[] aux;
}

//递归使用归并排序，对arr[l...r]的范围进行排序
template <typename T>
void __mergeSort(T arr[], int l, int r)
{
	//if (l >= r)
	//{
	//	return;
	//}
	if (r - l <= 15){
		insertionSort(arr, l, r);
		return;
	}
	int mid = (l + r) / 2;  //解决数据溢出：(x&y)+((x^y)>>1)
	__mergeSort(arr, l, mid);
	__mergeSort(arr, mid + 1, r);
	if (arr[mid] > arr[mid + 1])
	{
		__merge(arr, l, mid, r);
	}
}

template <typename T>
void mergeSort(T arr[], int n)
{
	__mergeSort(arr, 0, n - 1);

}

总结:

各排序的稳定性、时间复杂度和空间复杂度：

丫就是熊个猫猫

关注

0
点赞
踩
1

收藏

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

排序算法一、插入排序——直接插入排序（Straight InsertionSort）基本思想：将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。要点：设立哨兵，作为临时存储和判断数组边界之用。如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。算法实现：
复制链接

扫一扫

专栏目录