排序算法总结

几种常见的排序算法
排序一般指对关键字的排序，下面的例子都是针对int数值类型举例，对于Object类似。

相关概念：
1）内排序和外排序
排序过程完全在内存中进行称内排序，有时数据量大，内存无法全部容纳，需要借助外部存储设备存取，此种叫外排序

2）稳定排序和不稳定排序
如果待排序序列关键字相同，排序后相对顺序（前后顺序）一定保持不变，则称此排序算法稳定，否则不稳定

3）排序一般涉及两个基本操作
比较和移动

//注意自己的包名
package sort;

public class SortAlgorithm {

/*******************常见3种插入排序*******************************************/
	/**
	 * 直接插入排序(*):稳定排序
	 * 平均时间复杂度:O(n^2) ; 空间复杂度:O(1)
	 * 最好时间复杂度:O(n) ; 最差时间复杂度:O(n^2)
	 * 原理简介：将后面的记录一个一个插入到前面已有序的序列中
	 */
	public static void directInsert(int[] array) {
		final int len = array.length ;
		int temp, i, j ;
		for(i=1 ; i<len ; i++) {
			j = i-1 ;
			temp = array[i] ;
			while(j>=0 && temp<array[j]) {//比较并移动
				array[j+1] = array[j] ;
				j-- ;
			}
			array[j+1] = temp ;	//插入
		}
	}
	
	/**
	 * 折半插入排序：不稳定排序
	 * 平均时间复杂度:O(n^2) ; 空间复杂度:O(1)
	 * 相对于直接插入排序，只减少了比较次数，并没有减少移动次数。最好最差时间复杂度一样
	 * 原理简介：相比于直接插入排序，对已有序的序列采用二分搜索比较，但失去了稳定性
	 */
	public static void halfInsert(int[] array) {
		final int len = array.length ;
		int temp, i, j, low, high, mid=0 ;
		for(i=1 ; i<len ; i++) {
			temp = array[i] ;
			low = 0 ;
			high = i-1 ;
			while(low<=high) {
				mid = (low+high)/2 ;
				if(temp>array[mid])	//比较
					low = mid+1 ;
				else
					high = mid-1 ;		
			}
			for(j=i-1 ; j>=high+1 ; j--) {	//移动
				array[j+1] = array[j] ;
			}
			array[high+1] = temp ;	//插入
		}
	}
	
	/**
	 * 希尔排序(又叫缩小增量排序，直接插入排序的改进):不稳定排序
	 * 平均时间复杂度:O(n^1.3) ; 平均空间复杂度:O(1)
	 * 原理简介:以jump为步长，分组，组内进行排序，最后jump必须为1
	 */
	public static void shellSort(int[] array) {
		final int len = array.length ;
		int jump = (len-1)/2 ;
		boolean change = true ;
		int t ;
		while(jump > 0) {
			do{
				change = false ;
				for(int i = 0 ; i < len-jump ; i++) {
					if(array[i] > array[i+jump]) {
						t = array[i] ;
						array[i] = array[i+jump] ;
						array[i+jump] = t ;
						change = true ;
					}
				}
			}while(change) ;
			jump = jump/2 ;
		}
	}

	
/*******************常见2种交换排序*******************************************/
	/**
	 * 冒泡排序(*):稳定排序
	 * 平均时间复杂度:O(n^2) ; 空间复杂度:O(1)
	 * 最好时间复杂度:O(n) ; 最差时间复杂度:O(n^2)
	 * 原理简介：将前面大的数据冒泡到后面
	 */
	public static void bubbleSort(int[] array) {
		int len = array.length ;
		boolean swap = true ;
		while(swap) {
			swap = false ;	//如果没有交换则已经全部有序
			for(int i=0 ; i<len-1 ; i++) {	//向后冒泡
				if(array[i]>array[i+1]) {	//异或交换两个整数，浮点数不能这样用
					array[i] = array[i] ^ array[i+1] ;
					array[i+1] = array[i] ^ array[i+1] ;
					array[i] = array[i] ^ array[i+1] ;
					swap = true ;
				}
			}
			len-- ;	//后面已有序
		}
	}
	
	/**
	 * 快速排序(**):非稳定排序，数值类默认的排序算法
	 * 它是冒泡排序的改进，是目前速度最快的排序方法之一
	 * 平均时间复杂度:O(nlogn) ; 平均空间复杂度:O(logn),因为有递归
	 * 最好时间复杂度:O(nlogn) ; 最差时间复杂度:O(n^2)
	 * 原理简介：选取基准记录将序列划分成两个子序列，然后递归将子序列再划分成子序列，直到有序
	 */
	public static void quickSort(int[] array, int begin, int end) {
		if(begin<end) {
			int i = partition2(array, begin, end) ;
			quickSort(array, begin, i-1);
			quickSort(array, i+1, end);
		}
	}
	//此方法更好
	private static int partition2(int num[], int begin, int end) {
		int key = num[begin] ;
		while(begin<end) {
			while(num[end]>=key && begin<end) {
				end-- ;
			}
			num[begin] = num[end] ;
			while(num[begin]<=key && begin<end) {
				begin++ ;
			}
			num[end] = num[begin] ;
		}
		num[end] = key ;
		return end ;		
	}
	

/*******************常见2种选择排序*******************************************/
	/**
	 * 直接选择排序(*):不稳定排序
	 * 平均时间复杂度：O(n^2) ; 平均空间复杂度：O(1)
	 * 原理简介:每次选择剩余待排序序列的最小值放到前面
	 */
	public static void directSelect(int[] array) {
		final int len = array.length ;
		int temp ;
		int index ;	//记录最小记录的数组下标
		for(int i=0 ; i<len ; i++) {
			index = i ;
			for(int j=i+1 ; j<len ; j++) {
				if(array[index] > array[j]) {
					index = j ;
				}
			}
			if(index != i) {	//将最小记录放到前面
				temp = array[index] ;
				array[index] = array[i] ;
				array[i] = temp ;
			}
		}
	}
	
	/**
	 * 概念：利用了完全二叉树。当所有非叶子结点的值都大于(小于)其子女节点值，则成为大根堆(小根堆)
	 * 堆排序(**):不稳定排序
	 * 平均时间复杂度:O(nlogn) ; 空间复杂度:O(1)
	 * 最好时间复杂度:O(nlogn) ; 最差时间复杂度:O(nlogn)
	 * 原理简介:不断调整堆，将最大值与末尾交换，找到前K大的数，直至K==N
	 */
	public static void heapSort(int[] array) {
		final int maxIndex = array.length - 1 ;
		int temp ;
		//筛选法建立初始堆
		for(int i=(maxIndex-1)/2 ; i>=0 ; i--) {
			shift(array, i, maxIndex);
		}
		for(int i=maxIndex ; i>=1 ; i--) {	
			temp = array[0] ;
			array[0] = array[i] ;
			array[i] = temp ;
			shift(array, 0, i-1) ;	//调整新堆,最后array[0]最大
		}
	}
	//调整新堆，将num[start]调整到合适的位置，使之成为大根堆，数组下标基于0
	private static void shift(int[] num, int start, int end) {
		int i = 2*start + 1 ;	//左子节点的数组下标
		int temp = num[start] ;
		while(i <= end) {
			if((i<end) && (num[i]<num[i+1])) {	//比较左右子树大小
				i++ ;
			}
			if(temp<num[i]) {	//交换，下次循环比较子子树
				num[start] = num[i] ;
				start = i ;
				i = 2*start + 1 ;
			}
			else {
				break ;
			}
		}
		num[start] = temp ;
	}
	

/*******************二路归并排序*******************************************/
	/**
	 * 归并排序(**):稳定排序，Object排序默认使用的排序算法
	 * 平均时间复杂度:O(nlogn) ; 空间复杂度:O(n)
	 * 最好时间复杂度:O(nlogn) ; 最差时间复杂度:O(nlogn)
	 * 原理简介:将两个或以上有序表合成新有序表，递归实现
	 * @return 返回排序后有序的数组
	 */
	public static int[] mergeSort(int[] array, int low, int high) {
		int mid = (low+high)/2 ;
		if(low<high) {
			mergeSort(array, low, mid);		//使前部分有序，直至一个元素
			mergeSort(array, mid+1, high);	//使后部分有序
			merge(array, low, mid, high);	//合并两个有序表
		}
		return array ;
		
	}
	//将有序的num[low..mid]和num[mid+1..high]归并为有序的num[low,high]
	private static void merge(int[] num, int low, int mid, int high) {
		final int len = high-low+1 ;
		int[] target = new int[len] ;	//借助临时空间
		int i = low, j = mid + 1, k = 0 ;
		while(i<=mid && j<=high) {
			if(num[i] <= num[j]) {
				target[k] = num[i++] ;		
			}
			else {
				target[k] = num[j++] ;
			}
			k++ ;
		}
		while(i <= mid) {
			target[k++] = num[i++] ;
		}
		while(j <= high) {
			target[k++] = num[j++] ;
		}
		System.arraycopy(target, 0, num, low, len);	//数组的快速赋值
	}
	
	
	
	public static void main(String[] args) {
		int[] array = ProcessData.getRandIntArray(35) ;
		
//		directInsert(array);
//		halfInsert(array);
//		shellSort(array);
//		bubbleSort(array);
//		quickSort(array, 0, array.length-1);
//		heapSort(array);
		array = mergeSort(array, 0, array.length-1);
		
		//打印数字
		ProcessData.printIntArray(array);
	}
	
	//剩余问题
	/**
	 * 1、找到数组中前K个最大的数
	 * 2、找到第K个最大的数
	 */

}