Java数据结构和算法（九）——高级排序

时间  2019-12-01
标签 java 数据 结构 算法 高级 排序 栏目 Java 繁體版
原文   原文链接

　　春晚好看吗？不存在的！！！html

　　在Java数据结构和算法（三）——冒泡、选择、插入排序算法中咱们介绍了三种简单的排序算法，它们的时间复杂度大O表示法都是O(N2)，若是数据量少，咱们还能忍受，可是数据量大，那么这三种简单的排序所须要的时间则是咱们所不能接受的。接着咱们在讲解递归 的时候，介绍了归并排序，归并排序须要O(NlogN)，这比简单排序要快了不少，可是归并排序有个缺点，它须要的空间是原始数组空间的两倍，当咱们须要排序的数据占据了整个内存的一半以上的空间，那么是不能使用归并排序的。java

　　本篇博客将介绍几种高级的排序算法：希尔排序和快速排序。算法

一、希尔排序

　　希尔排序是基于直接插入排序的，它在直接插入排序中增长了一个新特性，大大的提升了插入排序的执行效率。因此在讲解希尔排序以前，咱们先回顾一下直接插入排序。shell

　　①、直接插入排序

　　直接插入排序基本思想是每一步将一个待排序的记录，插入到前面已经排好序的有序序列中去，直到插完全部元素为止。数组

　　

　　实现代码为：数据结构

package com.ys.sort;

public class InsertSort {
	public static int[] sort(int[] array){
		int j;
		//从下标为1的元素开始选择合适的位置插入，由于下标为0的只有一个元素，默认是有序的
		for(int i = 1 ; i < array.length ; i++){
			int tmp = array[i];//记录要插入的数据
			j = i;
			while(j > 0 && tmp < array[j-1]){//从已经排序的序列最右边的开始比较，找到比其小的数
				array[j] = array[j-1];//向后挪动
				j--;
			}
			array[j] = tmp;//存在比其小的数，插入
		}
		return array;
	}
		
}

　　咱们能够分析一下这个直接插入排序，首先咱们将须要插入的数放在一个临时变量中，这也是一个标记符，标记符左边的数是已经排好序的，标记符右边的数是须要排序的。接着将标记的数和左边排好序的数进行比较，假如比目标数大则将左边排好序的数向右边移动一位，直到找到比其小的位置进行插入。数据结构和算法

　　这里就存在一个效率问题了，若是一个很小的数在很靠近右边的位置，好比上图右边待排序的数据 1 ，那么想让这个很小的数 1 插入到左边排好序的位置，那么左边排好序的数据项都必须向右移动一位，这个步骤就是将近执行了N次复制，虽然不是每一个数据项都必须移动N个位置，可是每一个数据项平均移动了N/2次，总共就是N2/2，所以插入排序的效率是O(N2)。post

　　那么若是以某种方式没必要一个一个移动中间全部的数据项，就能把较小的数据项移动到左边，那么这个算法的执行效率会有很大的改进。测试

　　②、希尔排序图解

　　希尔排序应运而生了，希尔排序经过加大插入排序中元素的间隔，并在这些有间隔的元素中进行插入排序，从而使数据项可以大跨度的移动。当这些数据项排过一趟序后，希尔排序算法减少数据项的间隔再进行排序，依次进行下去，最后间隔为1时，就是咱们上面说的简单的直接插入排序。优化

　　下图显示了增量为4时对包含10个数组元素进行排序的第一个步骤，首先对下标为 0,4,8 的元素进行排序，完成排序以后，算法右移一步，对 1,5,9 号元素进行排序，依次类推，直到全部的元素完成一趟排序，也就是说间隔为4的元素都已经排列有序。

　　

　　当咱们完成4-增量排序以后，在进行普通的插入排序，即1-增量排序，会比前面直接执行简单插入排序要快不少。

　　③、排序间隔选取

　　对于10个元素，咱们选取4的间隔，那么100个数据，1000个数据，甚至更多的数据，咱们应该怎么选取间隔呢？

　　希尔的原稿中，他建议间隔选为N/2，也就是每一趟都将排序分为两半，所以对于N=100的数组，逐渐减少的间隔序列为：50,25,12，6,3,1。这个方法的好处是不须要在开始排序前为找到初始序列的间隔而计算序列，只须要用2整除N。可是这已经被证实并非最好的序列。

　　间隔序列中的数字互质是很重要的指标，也就是说，除了1，他们没有公约数。这个约束条件使得每一趟排序更有可能保持前一趟排序已经排好的结果，而希尔最初以N/2的间隔的低效性就是没有遵照这个准则。

　　因此一种希尔的变形方法是用2.2来整除每个间隔，对于n=100的数组，会产生序列45，20，9,4,1。这比用2会整除会显著的改善排序效果。

　　还有一种很经常使用的间隔序列：knuth 间隔序列 3h+1

　　

　　可是不管是什么间隔序列，最后必须知足一个条件，就是逐渐减少的间隔最后必定要等于1，所以最后一趟排序必定是简单的插入排序。

　　下面咱们经过knuth间隔序列来实现希尔排序：

　　④、knuth间隔序列的希尔排序算法实现

//希尔排序 knuth 间隔序列 3h+1
public static void shellKnuthSort(int[] array){
	System.out.println("原数组为"+Arrays.toString(array));
	int step = 1 ;
	int len = array.length;
	while(step <= len/3){
		step = step*3 + 1;//1,4,13,40......
	}	
	while(step > 0){
		//分别对每一个增量间隔进行排序
		for(int i = step ; i < len ; i++){
			int temp = array[i];
			int j = i;
			while(j > step-1 && temp <= array[j-step]){
				array[j] = array[j-step];
				j -= step;
			}
			array[j] = temp;
		}//end for
		System.out.println("间隔为"+step+"的排序结果为"+Arrays.toString(array));
		step = (step-1)/3;
	}//end while(step>0)
		
	System.out.println("最终排序："+Arrays.toString(array));
}

　　测试结果：

public static void main(String[] args) {
	int[] array = {4,2,8,9,5,7,6,1,3,10};
	shellKnuthSort(array);
}

　　

 

　　⑤、间隔为2h的希尔排序

//希尔排序 间隔序列2h
public static void shellSort(int[] array){
	System.out.println("原数组为"+Arrays.toString(array));
	int step;
	int len = array.length;
	for(step = len/2 ;step > 0 ; step /= 2){
		//分别对每一个增量间隔进行排序
		for(int i = step ; i < array.length ; i++){
			int j = i;
			int temp = array[j];
			if(array[j] < array[j-step]){
				while(j-step >=0 && temp < array[j-step]){
					array[j] = array[j-step];
					j -= step;
				}
				array[j] = temp;
			}
		}
		System.out.println("间隔为"+step+"的排序结果为"+Arrays.toString(array));
	}
}

　　测试结果：

　　

二、快速排序

　　快速排序是对冒泡排序的一种改进，由C. A. R. Hoare在1962年提出的一种划分交换排序，采用的是分治策略（通常与递归结合使用），以减小排序过程当中的比较次数。

　　①、快速排序的基本思路

　　1、先经过第一趟排序，将数组原地划分为两部分，其中一部分的全部数据都小于另外一部分的全部数据。原数组被划分为2份

　　2、经过递归的处理， 再对原数组分割的两部分分别划分为两部分，一样是使得其中一部分的全部数据都小于另外一部分的全部数据。 这个时候原数组被划分为了4份

　　3、就1,2被划分后的最小单元子数组来看，它们仍然是无序的，可是！ 它们所组成的原数组却逐渐向有序的方向前进。

　　4、这样不断划分到最后，数组就被划分为多个由一个元素或多个相同元素组成的单元，这样数组就有序了。

　　具体实例：

　　

　　对于上图的数组[3,1,4,1,5,9,2,6,5,3]，经过第一趟排序将数组分红了[2,1,1]或[4,5,9,3,6,5,3]两个子数组，且对于任意元素，左边子数组老是小于右边子数组。经过不断的递归处理，最终获得有序数组[1 1 2 3 3 4 5 5 6]

　　②、快速排序的算法实现

　　假设被排序的无序区间为[A[i],......,A[j]]

　　1、基准元素选取：选择其中的一个记录的关键字 v 做为基准元素（控制关键字）;怎么选取关键字？

　　2、划分：经过基准元素 v 把无序区间 A[I]......A[j] 划分为左右两部分，使得左边的各记录的关键字都小于 v；右边的各记录的关键字都大于等于 v；（如何划分？）

　　3、递归求解：重复上面的1、二步骤，分别对左边和右边两部分递归进行快速排序。

　　4、组合：左、右两部分均有序，那么整个序列都有序。

　　上面的第 3、四步不用多说，主要是第一步怎么选取关键字，从而实现第二步的划分？

　　划分的过程涉及到三个关键字：“基准元素”、“左游标”、“右游标”

　　基准元素：它是将数组划分为两个子数组的过程当中，用于界定大小的值，以它为判断标准，将小于它的数组元素“划分”到一个“小数值的数组”中，而将大于它的数组元素“划分”到一个“大数值的数组”中，这样，咱们就将数组分割为两个子数组，而其中一个子数组的元素恒小于另外一个子数组里的元素。

　　左游标：它一开始指向待分割数组最左侧的数组元素，在排序的过程当中，它将向右移动。

　　右游标：它一开始指向待分割数组最右侧的数组元素，在排序的过程当中，它将向左移动。

　　注意：上面描述的基准元素/右游标/左游标都是针对单趟排序过程的， 也就是说，在总体排序过程的多趟排序中，各趟排序取得的基准元素/右游标/左游标通常都是不一样的。

　　对于基准元素的选取，原则上是任意的。可是通常咱们选取数组中第一个元素为基准元素（假设数组是随机分布的）

　　③、快速排序图示

　　

 

　　上面表示的是一个无序数组，选取第一个元素 6 做为基准元素。左游标是 i 哨兵，右游标是 j 哨兵。而后左游标向左移动，右游标向右移动，它们遵循的规则以下：

　　1、左游标向右扫描， 跨过全部小于基准元素的数组元素, 直到遇到一个大于或等于基准元素的数组元素， 在那个位置停下。

　　2、右游标向左扫描， 跨过全部大于基准元素的数组元素, 直到遇到一个小于或等于基准元素的数组元素，在那个位置停下。

　　第一步：哨兵 j 先开始出动。由于此处设置的基准数是最左边的数，因此须要让哨兵 j 先开始出动，哨兵 j 一步一步的向左挪动，直到找到一个小于 6 的元素停下来。接下来，哨兵 i 再一步一步的向右挪动，直到找到一个大于 6 的元素停下来。最后哨兵 i 停在了数字 7 面前，哨兵 j 停在了数字 5 面前。

　　

　　到此，第一次交换结束，接着哨兵 j 继续向左移动，它发现 4 比基准数 6 要小，那么在数字4面前停下来。哨兵 i 也接着向右移动，而后在数字 9 面前停下来，而后哨兵 i 和 哨兵 j 再次进行交换。

　　

　　第二次交换结束，哨兵 j 继续向左移动，而后在数字 3 面前停下来；哨兵 i 继续向右移动，可是它发现和哨兵 j 相遇了。那么此时说明探测结束，将数字 3 和基准数字 6 进行交换，以下：

　　

　　到此，第一次探测真正结束，此时已基准点 6 为分界线，6 左边的数组元素都小于等于6,6右边的数组元素都大于等于6。

　　左边序列为【3,1,2,5,4】,右边序列为【9,7,10,8】。接着对于左边序列而言，以数字 3 为基准元素，重复上面的探测操做，探测完毕以后的序列为【2,1,3,5,4】；对于右边序列而言，以数字 9 位基准元素，也重复上面的探测操做。而后一步一步的划分，最后排序彻底结束。

　　经过这一步一步的分解，咱们发现快速排序的每一轮操做就是将基准数字归位，知道全部的数都归位完成，排序就结束了。

　　

 

　　④、快速排序完整代码

package com.ys.high.sort;

public class QuickSort {
	
	//数组array中下标为i和j位置的元素进行交换
	private static void swap(int[] array , int i , int j){
		int temp = array[i];
		array[i] = array[j];
		array[j] = temp;
	}
	
	private static void recQuickSort(int[] array,int left,int right){
		if(right <= left){
			return;//终止递归
		}else{
			
			int partition = partitionIt(array,left,right);
			recQuickSort(array,left,partition-1);// 对上一轮排序(切分)时，基准元素左边的子数组进行递归
			recQuickSort(array,partition+1,right);// 对上一轮排序(切分)时，基准元素右边的子数组进行递归
		}
	}
	
	private static int partitionIt(int[] array,int left,int right){
		//为何 j加一个1，而i没有加1,是由于下面的循环判断是从--j和++i开始的.
		//而基准元素选的array[left],即第一个元素，因此左游标从第二个元素开始比较
		int i = left;
		int j = right+1;
		int pivot = array[left];// pivot 为选取的基准元素（头元素）
		while(true){
			while(i<right && array[++i] < pivot){}
			
			while(j > 0 && array[--j] > pivot){}
			
			if(i >= j){// 左右游标相遇时候中止， 因此跳出外部while循环
				break;
			}else{
				swap(array, i, j);// 左右游标未相遇时中止, 交换各自所指元素，循环继续 
			}
		}
		swap(array, left, j);//基准元素和游标相遇时所指元素交换，为最后一次交换
		return j;// 一趟排序完成， 返回基准元素位置(注意这里基准元素已经交换位置了)
	}
	
	public static void sort(int[] array){
		recQuickSort(array, 0, array.length-1);
	}
	
	//测试
	public static void main(String[] args) {
		//int[] array = {7,3,5,2,9,8,6,1,4,7};
		int[] array = {9,9,8,7,6,5,4,3,2,1};
		sort(array);
		for(int i : array){
			System.out.print(i+" ");
		}
		//打印结果为：1 2 3 4 5 6 7 7 8 9 
	}
}

　　⑤、优化分析

　　假设咱们是对一个逆序数组进行排序，选取第一个元素做为基准点，即最大的元素是基准点，那么第一次循环，左游标要执行到最右边，而右游标执行一次，而后二者进行交换。这也会划分红不少的子数组。

　　那么怎么解决呢？理想状态下，应该选择被排序数组的中值数据做为基准，也就是说一半的数大于基准数，通常的数小于基准数，这样会使得数组被划分为两个大小相等的子数组，对快速排序来讲，拥有两个大小相等的子数组是最优的状况。

　　三项取中划分

　　为了找到一个数组中的中值数据，通常是取数组中第一个、中间的、最后一个，选择这三个数中位于中间的数。

	//取数组下标第一个数、中间的数、最后一个数的中间值
	private static int medianOf3(int[] array,int left,int right){
		int center = (right-left)/2+left;
		if(array[left] > array[right]){ //获得 array[left] < array[right]
			swap(array, left, right);
		}
		if(array[center] > array[right]){ //获得 array[left] array[center] < array[right]
			swap(array, center, right);
		}
		if(array[center] > array[left]){ //获得 array[center] <  array[left] < array[right]
			swap(array, center, left);
		}
		
		return array[left]; //array[left]的值已经被换成三数中的中位数， 将其返回
	}

	private static int partitionIt(int[] array,int left,int right){
		//为何 j加一个1，而i没有加1,是由于下面的循环判断是从--j和++i开始的.
		//而基准元素选的array[left],即第一个元素，因此左游标从第二个元素开始比较
		int i = left;
		int j = right+1;
		int pivot = array[left];// pivot 为选取的基准元素（头元素）
		
		int size = right - left + 1;
		if(size >= 3){
			pivot = medianOf3(array, left, right); //数组范围大于3，基准元素选择中间值。
		}
		while(true){
			while(i<right && array[++i] < pivot){}
			
			while(j > 0 && array[--j] > pivot){}
			
			if(i >= j){// 左右游标相遇时候中止， 因此跳出外部while循环
				break;
			}else{
				swap(array, i, j);// 左右游标未相遇时中止, 交换各自所指元素，循环继续 
			}
		}
		swap(array, left, j);//基准元素和游标相遇时所指元素交换，为最后一次交换
		return j;// 一趟排序完成， 返回基准元素位置(注意这里基准元素已经交换位置了)
	}

　　处理小划分

　　若是使用三数据取中划分方法，则必须遵循快速排序算法不能执行三个或者少于三个的数据，若是大量的子数组都小于3个，那么使用快速排序是比较耗时的。联想到前面咱们讲过简单的排序（冒泡、选择、插入）。

　　当数组长度小于M的时候（high-low <= M）， 不进行快排，而进行插入排序。转换参数M的最佳值和系统是相关的，通常来讲， 5到15间的任意值在多数状况下都能使人满意。

	//插入排序
	private static void insertSort(int[] array){
		for(int i = 1 ; i < array.length ; i++){
			int temp = array[i];
			int j = i;
			while(j > 0 && array[j-1] > temp){
				array[j] = array[j-1];
				j--;
			}
			array[j] = temp;
		}
	}
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程