sort排序算法集合

public class Sort {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] array = { 2, 3, 5, 76, 3, 6, 7, 5, 4, 4, 6 };
		quickSortArray(array);
	}

	/**
	 * 冒泡排序 
	 * 效率 O（n²）,适用于排序小列表
	 */
	private static void bubbleSortArray(int[] array) {
		int length = array.length;
		for (int i = 1; i < length; i++) {
			for (int j = 0; j < length - i; j++) {
				if (array[j] > array[j + 1]) {
					int temp = array[j + 1];
					array[j + 1] = array[j];
					array[j] = temp;
				}
			}
		}
		println(array);
	}

	/**
	 * 选择排序
	 * 效率 O（n²）,适用于排序小列表
	 */
	private static void selectSortArray(int[] array) {
		int length = array.length;
		int min_index;
		for (int i = 0; i < length - 1; i++) {
			min_index = i;
			for (int j = i + 1; j < length; j++) {
				if (array[j] < array[min_index]) {
					min_index = j;
				}
			}
			if (min_index != i) {
				int temp = array[min_index];
				array[min_index] = array[i];
				array[i] = temp;
			}
		}
		println(array);
	}

	/**
	 * 插入排序
	 * 最佳效率O（n）；最糟效率O（n²）与冒泡、选择相同。 
	 * 适用于排序小列表 若列表基本有序，则插入排序比冒泡、选择更有效率。
	 */
	private static void insertSortArray(int[] array) {
		int length = array.length;
		for (int i = 1; i < length; i++) {
			int temp = array[i];
			int j = i - 1;
			while (j >= 0 && array[j] > temp) {
				array[j + 1] = array[j];
				j--;
			}
			array[j + 1] = temp;
		}
		println(array);
	}

	/**
	 * 希尔排序，也称缩小增量排序 适用于排序小列表 效率估计O（nlog2^n）~O（n^1.5），取决于增量值的最初大小。
	 * 建议使用质数作为增量值，因为如果增量值是2的幂，则在下一个通道中会再次比较相同的元素。
	 * 改进了插入排序，减少了比较的次数。是不稳定的排序，因为排序过程中元素可能会前后跳跃。
	 */
	private static void ShellSortArray(int[] array) {
		int length = array.length;
		int d = length;
		while (true) {
			d = d / 2;// 初次取序列的一半为增量，以后每次减半，直到增量为1
			for (int x = 0; x < d; x++) {
				for (int i = x + d; i < length; i += d) {
					int temp = array[i];
					int j;
					for (j = i - d; j >= 0 && array[j] > temp; j -= d) {
						array[j + d] = array[j];
					}
					array[j + d] = temp;
				}
			}
			if (d == 1) {
				break;
			}
		}
		println(array);
	}
	
	//------------------------归并排序 start----------------------------------
	/** 
	 * 归并排序
	 * 适用于排序大列表，基于分治法
	 * 归并排序算法稳定，数组需要O(n)的额外空间，链表需要O(log(n))的额外空间，时间复杂度为O(nlog(n))
	 * 算法不是自适应的，不需要对数据的随机读取
	 */
	private static void mergeSortArray(int[] array){
		mergeSortArray(array,0,array.length-1);
		println(array);
	}
	
	private static void mergeSortArray(int[] data , int left , int right){
		if(left >= right){//每个子列表中剩下一个元素时停止 
			return;
		}
		int center = (left+right)/2;
		mergeSortArray(data,left , center);
		mergeSortArray(data, center+1, right);
		merge(data,left,center,right);
	}
	
	/** 
	 * 归并两个有序表
	 */
	private static void merge(int[] data , int left,int center,int right){
		int[] tempArray = new int[data.length];
		int mid = center+1;
		int k=left;
		int tmp = left;
		while(left <= center && mid <= right){
			if(data[left]<data[mid]){
				tempArray[k++] = data[left++];
			}else{
				tempArray[k++] = data[mid++];
			}
		}
		while(left<=center){
			tempArray[k++] = data[left++];
		}
		while(mid<=right){
			tempArray[k++] = data[mid++];
		}
		while (tmp <= right) {  
            data[tmp] = tempArray[tmp++];  
        }  
	}
	//------------------------归并排序 end----------------------------------
	
	//------------------------快速排序 start----------------------------------
	/** 
	 * 快速排序
	 * 平均效率O（nlogn），适用于排序大列表。基于分治法。
	 * 此算法的总时间取决于枢纽值的位置；选择第一个元素作为枢纽，可能导致O（n²）的最糟用例效率。
	 * 若数基本有序，效率反而最差。选项中间值作为枢纽，效率是O（nlogn）。
	 * 通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，
	 * 则分别对这两部分继续进行排序，直到整个序列有序。
	 */
	private static void quickSortArray(int[] array){
		quickSort(array, 0, array.length-1);
		println(array);
	}
	
	 private static void quickSort(int[] array,int low,int high){
		 if(low >= high){
			 return;
		 }
		 int middle = getMiddle(array, low, high);
		 quickSort(array, low, middle-1);
		 quickSort(array, middle +1, high);
	 }
	 
	 private static int getMiddle(int[] array,int low, int high){
		 int tmp = array[low];
		 while(low < high){
			 while(low < high && array[high]>=tmp){
				 high--;
			 }
			 array[low] = array[high];
			 while(low < high && array[low] <= tmp){
				 low++;
			 }
			 array[high] = array[low];
		 }
		 array[low] = tmp;
		 return low;
	 }
	//------------------------快速排序 end----------------------------------
	 
	 
	
	private static void println(int[] array) {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < array.length; i++) {
			sb.append(array[i] + "  ");
		}
		System.out.println(sb.toString());
	}
}