花五分钟学会十大排序--第一部分

最新推荐文章于 2023-12-05 19:45:20 发布

哼哧哼哧做大事

最新推荐文章于 2023-12-05 19:45:20 发布

阅读量85

点赞数

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

本文链接：https://blog.csdn.net/m0_67500944/article/details/127916602

版权

数据结构专栏收录该内容

11 篇文章 0 订阅

订阅专栏

这里将介绍直接插入排序，希尔排序，气泡排序，快速排序，简单排序，堆排序，归并排序。这些排序的复杂层度与之间的关系如下图所示：

1.起泡排序（Bubble Sort）

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

代码如下：

void BubbleSort(int* data,int length){
	int exchange, bound, temp;
	exchange = length - 1;
	while(exchange != 0){
		bound = exchange;
		exchange = 0;
		for(int j = 0;j < bound;j ++){
			if(data[j] > data[j+1]){
				temp = data[j];
				data[j] = data[j+1];
				data[j+1] = temp;
				exchange = j;
			}
		}
	}
}

2.选择排序（Selection Sort）

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

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

代码：

void SelectSort(int* data,int length) {
	int index, temp;
	for (int i = 0; i < length - 1; i++) {
		 index = i;
		 for (j = i + 1; j <length; j++){
			 if (data[j] < data[index]) index = j;
		 }
	if (index != i) {
		temp = data[i];
		data[i] = data[index];
		data[index] = temp;
	}
	}
}

3.希尔排序（Shell Sort）

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

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

代码

void ShellSort(int* data,int length){
	int temp, d;
	for (d = length/2;d >= 1; d = d/2){
		for (int i = d;i < length;i ++){
			temp = data[i];
			for (int j = i - d; j >= 0 && temp < data[j];j = j - d)
				 	data[j + d] = data[j];
			data[j+d] = temp;
       }
	}
	
}

4.插入排序（Insertion Sort）

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

代码

void InsertSort(int* data,int length) {
	int temp;
	for (int i = 1;i < length; i ++) {
		temp = data[i];
		for (int j = i - 1;j >= 0 && temp < data[j];j --)
			data[j + 1] = data[j];
		data[j + 1] = temp;
	}
}

5.归并排序（Merge Sort）

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

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

代码有两种，一个是递归的，一个是非递归的

void Merge(int first1,int last1;int last2,int* data,int length) {
	int *temp = new int[lenght];
	int i = first1, j = last1 + 1, k = first1;
	while(i <= last1 && j <= last2) {
		if (data[i] <= data[j]) {
			temp[k++] = data[i++];
		}else {
			temp[k++] = data[j++];
		} 
	}
	while(i <= last1) temp[k++] = data[i++];
	while (j <= last2) temp[k++] = data[j++];
	for (i = first1;i <= last2;i ++) data[i] = temp[i];
} 

void MergeSort1(int first, int last,int* data,int length) {
	if (first == last) {
		return ;
	}else {
		int mid = (first + last)/2;
		MergeSort1(first, mid);
		MergeSort1(mid+1, last);
		Merge(first, mid, last);
	}
	
}

还有一个是非递归的需要使用前面的Merge函数

void MergePass(int h,int length,int* data)
{
int i = 0;
while (i + 2 * h <= length) //待归并记录有两个长度为h的子序列
{
Merge(i, i+h-1, i+2*h-1);
i = i + 2 * h;
}
if (i + h < length)
Merge(i, i+h-1, length-1,data,length); //两个子序列一个长度小于h
}
void MergeSort2(int length)
{
int h = 1; 
while (h < length)
{
MergePass(h); 
h = 2 * h;
}
}

今天就介绍到这里，如果有帮到忙，请点赞支持