数据结构_排序

最新推荐文章于 2024-12-16 16:53:48 发布

Blijiojiodibuliduo

最新推荐文章于 2024-12-16 16:53:48 发布

阅读量286

点赞数 1

CC 4.0 BY-SA版权

分类专栏：数据结构

本文链接：https://blog.youkuaiyun.com/burning1996/article/details/53046903

数据结构专栏收录该内容

5 篇文章

订阅专栏

排序

插入排序：

插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。插入算法把要排序的数组分成两部分：第一部分包含了这个数组的所有元素，但将最后一个元素除外（让数组多一个空间才有插入的位置），而第二部分就只包含这一个元素（即待插入元素）。在第一部分排序完成后，再将这个最后元素插入到已排好序的第一部分中。

#include <stdio.h>
void InsertionSort(int A[], int n){
	int i, j, tmp;
	for(i = 1; i < n; i++){
		tmp = A[i];
		for(j = i;  j > 0 && A[j - 1] > tmp; j--){
			A[j] = A[j - 1];
		}
		A[j] = tmp;
	}
} 
int main(){
	int n, i, A[1000];
	scanf("%d", &n);
	for(i = 0; i < n; i++){
		scanf("%d", &A[i]);
	}
	InsertionSort(A, n);
	for(i = 0; i < n; i++){
		printf("%d ", A[i]);
	} 
	return 0;
}

希尔排序：

先取一个小于n的整数d1作为第一个增量，把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量 =1( < …<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。一般的初次取序列的一半为增量，以后每次减半，直到增量为1。

#include <stdio.h>
void ShellSort(int A[], int n){
	int i, j, Increment, tmp;
	for(Increment = n / 2; Increment > 0; Increment /= 2){
		for(j = Increment; j < n; j++){
			tmp = A[j];
			for(i = j; i >= Increment; i -= Increment){
				if(tmp < A[i - Increment]){
					A[i] = A[i - Increment];
				}
				else 
				    break;
			}
			A[i] = tmp;
		}
	}
} 
int main(){
	int n, i, A[1000];
	scanf("%d", &n);
	for(i = 0; i < n; i++){
		scanf("%d", &A[i]);
	}
	ShellSort(A, n);
	for(i = 0; i < n; i++){
		printf("%d ", A[i]);
	} 
	return 0;
}

堆排序：

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆，是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值，即A[PARENT[i]] >= A[i]。在数组的非降序排序中，需要使用的就是大根堆，因为根据大根堆的要求可知，最大的值一定在堆顶。n个关键字序列Kl，K2，…，Kn称为（Heap），当且仅当该序列满足如下性质（简称为堆性质）：

(1)ki<=k(2i）且ki<=k(2i+1)(1≤i≤ n/2），当然，这是小根堆，大根堆则换成>=号。//k(i）相当于二叉树的非叶子结点，K(2i）则是左子节点，k(2i+1）是右子节点若将此序列所存储的向量R[1..n]看做是一棵完全二叉树的存储结构，则堆实质上是满足如下性质的完全二叉树：

树中任一非叶子结点的关键字均不大于（或不小于）其左右孩子（若存在）结点的关键字堆排序利用了大根堆（或小根堆）堆顶记录的关键字最大（或最小）这一特征，使得在当前无序区中选取最大（或最小）关键字的记录变得简单。

（1）用大根堆排序的基本思想

① 先将初始文件R[1..n]建成一个大根堆，此堆为初始的无序区

② 再将关键字最大的记录R[1]（即堆顶）和无序区的最后一个记录R[n]交换，由此得到新的无序区R[1..n-1]和有序区R[n]，且满足R[1..n-1].keys≤R[n].key

③由于交换后新的根R[1]可能违反堆性质，故应将当前无序区R[1..n-1]调整为堆。然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换，由此得到新的无序区R[1..n-2]和有序区R[n-1..n]，且仍满足关系R[1..n-2].keys≤R[n-1..n].keys，同样要将R[1..n-2]调整为堆。

……

直到无序区只有一个元素为止。

（2）大根堆排序算法的基本操作：

①建堆，建堆是不断调整堆的过程，从len/2处开始调整，一直到第一个节点，此处len是堆中元素的个数。建堆的过程是线性的过程，从len/2到0处一直调用调整堆的过程，相当于o(h1)+o(h2)…+o(hlen/2) 其中h表示节点的深度，len/2表示节点的个数，这是一个求和的过程，结果是线性的O(n)。

②调整堆：调整堆在构建堆的过程中会用到，而且在堆排序过程中也会用到。利用的思想是比较节点i和它的孩子节点left(i),right(i)，选出三者最大(或者最小)者，如果最大（小）值不是节点i而是它的一个孩子节点，那边交互节点i和该节点，然后再调用调整堆过程，这是一个递归的过程。调整堆的过程时间复杂度与堆的深度有关系，是lgn的操作，因为是沿着深度方向进行调整的。

③堆排序：堆排序是利用上面的两个过程来进行的。首先是根据元素构建堆。然后将堆的根节点取出(一般是与最后一个节点进行交换)，将前面len-1个节点继续进行堆调整的过程，然后再将根节点取出，这样一直到所有节点都取出。堆排序过程的时间复杂度是O(nlgn)。因为建堆的时间复杂度是O(n)（调用一次）；调整堆的时间复杂度是lgn，调用了n-1次，所以堆排序的时间复杂度是O(nlgn)[2]

注意

①只需做n-1趟排序，选出较大的n-1个关键字即可以使得文件递增有序。

②用小根堆排序与利用大根堆类似，只不过其排序结果是递减有序的。堆排序和直接选择排序相反：在任何时刻堆排序中无序区总是在有序区之前，且有序区是在原向量的尾部由后往前逐步扩大至整个向量为止

特点

堆排序（HeapSort）是一树形选择排序。堆排序的特点是：在排序过程中，将R[l..n]看成是一棵完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系（参见二叉树的顺序存储结构），在当前无序区中选择关键字最大（或最小）的记录

#include <stdio.h>
#define LeftChild(i) (2 * i + 1)
void PercDown(int A[], int i, int n){
	int tmp, child;
	for(tmp = A[i]; LeftChild(i) < n; i = child){
		child = LeftChild(i);
		if(child != n - 1 && A[child + 1] > A[child]){
			child++;
		} 
		if(tmp < A[child]){
		    A[i] = A[child];
		}
		else 
		    break;
	}
	A[i] = tmp;
}
void Swap(int *p , int *q){
	int t;
	t = *p;
	*p = *q;
	*q = t;
}
void HeapSort(int A[], int n){
	int i;
	for(i = n / 2; i >= 0; i--){
		PercDown(A, i, n);
	}
	for(i = n - 1; i > 0; i--){
		Swap(&A[0], &A[i]);
		PercDown(A, 0, i);
	}
}
int main(){
	int n, i, A[1000];
	scanf("%d", &n);
	for(i = 0; i < n; i++){
		scanf("%d", &A[i]);
	}
	HeapSort(A, n);
	for(i = 0; i < n; i++){
		printf("%d ", A[i]);
	} 
	return 0;
}

归并排序：

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

归并过程为：比较a[i]和a[j]的大小，若a[i]≤a[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1；否则将第二个有序表中的元素a[j]复制到r[k]中，并令j和k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。归并排序的算法我们通常用递归实现，先把待排序区间[s,t]以中点二分，接着把左边子区间排序，再把右边子区间排序，最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。

归并操作(merge)，也叫归并算法，指的是将两个顺序序列合并成一个顺序序列的方法。

如　设有数列{6，202，100，301，38，8，1}

初始状态：6,202,100,301,38,8，1

第一次归并后：{6,202},{100,301},{8,38},{1}，比较次数：3；

第二次归并后：{6,100,202,301}，{1,8,38}，比较次数：4；

第三次归并后：{1,6,8,38,100,202,301},比较次数：4；

总的比较次数为：3+4+4=11,；

逆序数为14；

#include <stdio.h>
#include <stdlib.h>
void MSort(int A[], int TmpArray[], int Left, int Right){
	int Center;
	if(Left < Right){
		Center = (Left + Right) / 2;
	    MSort(A, TmpArray, Left, Center);
	    MSort(A, TmpArray, Center + 1, Right);
	    Merge(A, TmpArray, Left, Center + 1, Right);
	}
} 
void MergeSort(int A[], int n){
	int *TmpArray;
	TmpArray = malloc(n * sizeof(int));
	MSort(A, TmpArray, 0, n - 1);
	free(TmpArray);
}
void Merge(int A[], int TmpArray[], int Lpos, int Rpos, int RightEnd){
	int LeftEnd = Rpos - 1;
	int i , TmpPos, NumElements;
	NumElements = RightEnd - Lpos + 1;
	TmpPos = Lpos;
	while(LeftEnd >= Lpos && RightEnd >= Rpos){
		if(A[Lpos] < A[Rpos]){
			TmpArray[TmpPos++] = A[Lpos++];
		}
		else{
			TmpArray[TmpPos++] = A[Rpos++];
		}
	}
	while(LeftEnd >= Lpos){
		TmpArray[TmpPos++] = A[Lpos++];
	}
	while(RightEnd >= Rpos){
		TmpArray[TmpPos++] = A[Rpos++];
	}
	for(i = 0; i < NumElements; i++, RightEnd--){
		A[RightEnd] = TmpArray[RightEnd];
	}
}
int main(){
	int n, i, A[1000];
	scanf("%d", &n);
	for(i = 0; i < n; i++){
		scanf("%d", &A[i]);
	}
	MergeSort(A, n);
	for(i = 0; i < n; i++){
		printf("%d ", A[i]);
	} 
	return 0;
}

快速排序：

快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。

一趟快速排序的算法是：

1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；

2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；

3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；

4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换；

5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。

#include <stdio.h> 
int a[100001];
void Swap(int i, int j){
	int t = a[i];
	a[i] = a[j];
	a[j] = t;
}
void QuickSort(int Left, int Right){
	int tmp, i, j;
	tmp = a[Left];
	j = Right; i = Left;
	if(Left > Right)
	    return;
	while(i != j){
	    while(a[j] >= tmp && i < j)
	        j--;
	    while(a[i] <= tmp && i < j)
	        i++;
	    if(i < j){
		    Swap(i, j);
	    } 
	}
	a[Left] = a[i];
	a[i] = tmp;
	QuickSort(Left, i - 1);
	QuickSort(j + 1, Right); 
	
} 
int main(){
	int i, n;
	scanf("%d", &n);
	for(i = 1; i <= n; i++){
		scanf("%d", &a[i]);
	}
	QuickSort(1, n);
	for(i = 1; i <= n; i++){
		printf("%d ", a[i]);
	} 
	return 0;
}