幾種排序算法

package com.tydic;

import java.util.Arrays;

public class InsertSort {
	/**
	 * 1.直接插入排序:
	 * 基本思想：在要排序的一組數中，假設前面(n-1)[n>=2] 個數已是排.
	 * 好順序的，如今要把第n個數插到前面的有序數中，使得這n個數.
	 * 也是排好順序的。如此反覆循環，直到所有排好順序.
	 */
	public static void insertSort() {
		int a [] = {49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
		int temp=0;
		for(int i=0;i<a.length;i++) {
			int j = i-1;
			temp = a[i];
			for(;j>=0&&temp<a[j];j--) {
				a[j+1]=a[j];
			}
			a[j+1]=temp;
		}
		for(int i=0;i<a.length;i++) {
			System.out.print(a[i]+"->");
		}
	}
	/**
	 * 2.希爾排序（最小增量排序）:
	 * 基本思想：算法先將要排序的一組數按某個增量d（n/2,n爲要排序數的個數）分紅若干組，每組中.
	 * 記錄的下標相差d.對每組中所有元素進行直接插入排序，而後再用一個較小的增量（d/2）對它進行分組.
	 * 在每組中再進行直接插入排序。當增量減到1時，進行直接插入排序後，排序完成.
	 */
	public static void shellSort() {
		int a [] = {1,54,6,3,78,34,12,45,56,100};
		double dl = a.length;
		int temp = 0;
		while(true) {
			dl = Math.ceil(dl/2);
			int d = (int) dl;
			for(int x=0;x<d;x++) {
				for(int i=x+d;i<a.length;i+=d) {
					int j=i-d;
					temp=a[i];
					for(;j>=0&&temp<a[j];j-=d) {
						a[j+d]=a[j];
					}
					a[j+d]=temp;
				}
			}
			 if(d==1) {
				 break;
			 }
		}
		for(int i=0;i<a.length;i++) {
			System.out.print(a[i]+"->");
		}
	}
	/**
	 * 3.簡單選擇排序:
	 * 基本思想：在要排序的一組數中，選出最小的一個數與第一個位置的數交換
	 * 而後在剩下的數當中再找最小的與第二個位置的數交換，如此循環到倒數第二個數和最後一個數比較爲止。
	 */
	public static void selectSort() {
		int a[]={1,54,6,3,78,34,12,45};  
		int position=0; 
		for(int i=0;i<a.length;i++) {
			int j=i+1;
			position=i;  
			int temp=a[i];  
			for(;j<a.length;j++){
				if(a[j]<temp){  
					temp=a[j];  
					position=j;
				}
			}
			a[position]=a[i];  
			a[i]=temp;
		}
		for(int i=0;i<a.length;i++) {
			System.out.print(a[i]+"->");
		}
	}
	
	/**
	 * 4.堆排序:
	 * 基本思想：堆排序是一種樹形選擇排序，是對直接選擇排序的有效改進。
	 * 堆的定義以下：具備n個元素的序列（h1,h2,...,hn),當且僅當知足（hi>=h2i,hi>=2i+1）或
	 *（hi<=h2i,hi<=2i+1）(i=1,2,...,n/2)時稱之爲堆。在這裏只討論知足前者條件的堆。由堆的定義可
	 * 以看出，堆頂元素（即第一個元素）必爲最大項（大頂堆）。徹底二叉樹能夠很直觀地表示堆的結構。堆 
	 * 頂爲根，其它爲左子樹、右子樹。初始時把要排序的數的序列看做是一棵順序存儲的二叉樹，調整它們的存儲序，
	 * 使之成爲一個堆，這時堆的根節點的數最大。而後將根節點與堆的最後一個節點交換。
	 * 而後對前面(n-1)個數從新調整使之成爲堆。依此類推，直到只有兩個節點的堆，並對它們做交換，最後獲得有n個節點的有序序列。
	 * 從算法描述來看，堆排序須要兩個過程，一是創建堆，二是堆頂與堆的最後一個元素交換位置。因此堆排序有兩個函數組成。
	 * 一是建堆的滲透函數，二是反覆調用滲透函數實現排序的函數。
	 */
	public static void heapSort() {
		int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};  
		int arrayLength=a.length;
		//循環建堆
		for(int i=0;i<arrayLength-1;i++){  
			//建堆
			buildMaxHeap(a,arrayLength-1-i);  
			//交換堆頂和最後一個元素 
			swap(a,0,arrayLength-1-i);  
			System.out.println(Arrays.toString(a));  
		}
		
	}
	private static void swap(int[] data, int i, int j) { 
		int tmp=data[i];  
		data[i]=data[j];  
		data[j]=tmp;
	}
	//對data數組從0到lastIndex建大頂堆  
	private static void buildMaxHeap(int[] data, int lastIndex) {
		//從lastIndex處節點（最後一個節點）的父節點開始  
		for(int i=(lastIndex-1)/2;i>=0;i--){  
			 //k保存正在判斷的節點  
			 int k=i;
			 //若是當前k節點的子節點存在 
			 while(k*2+1<=lastIndex){  
				 //k節點的左子節點的索引 
				 int biggerIndex=2*k+1;  
				 //若是biggerIndex小於lastIndex，即biggerIndex+1表明的k節點的右子節點存
				 if(biggerIndex<lastIndex){  
					 //若果右子節點的值較大  
					 if(data[biggerIndex]<data[biggerIndex+1]){  
						 //biggerIndex老是記錄較大子節點的索引  
						 biggerIndex++;  
					 }
				 }
				  //若是k節點的值小於其較大的子節點的值 
				 if(data[k]<data[biggerIndex]){  
					 //交換他們  
					 swap(data,k,biggerIndex); 
					//將biggerIndex賦予k，開始while循環的下一次循環，從新保證k節點的值大於其左右子節點的值  
					 k=biggerIndex;  
				 }else {
					 break; 
				 }
			 }
		}
	}
	
	/**5.冒泡排序:
	 * 基本思想：在要排序的一組數中，對當前還未排好序的範圍內的所有數，自上而下對相鄰的兩個數依
	 * 次進行比較和調整，讓較大的數往下沉，較小的往上冒。即：每當兩相鄰的數比較後發現它們的排序與排
	 * 序要求相反時，就將它們互換.
	 * 
	 */
	public static void bubbleSort() {
		int a[]={49,38,65,97,76,13,27,49,78,34};  
		int temp=0; 
		for(int i=0;i<a.length-1;i++){  
			for(int j=0;j<a.length-1-i;j++){  
				if(a[j]>a[j+1]){  
					temp=a[j];  
					a[j]=a[j+1];  
					 a[j+1]=temp;
				}
			}
		}
		for(int i=0;i<a.length;i++) {
			System.out.print(a[i]+"->");
		}
	}
	
	/**
	 * 6.快速排序:
	 * 基本思想：選擇一個基準元素,一般選擇第一個元素或者最後一個元素,經過一趟掃描，將待排序列分
	 * 成兩部分,一部分比基準元素小,一部分大於等於基準元素,此時基準元素在其排好序後的正確位置,而後再
	 * 用一樣的方法遞歸地排序劃分的兩部分。
	 */
	public static void quickSort() {
		int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
		quick(a);  
		for(int i=0;i<a.length;i++)  {
			System.out.print(a[i]+"->");  
		}
		
	}
	private static void quick(int[] a2) {
		//查看數組是否爲空    
		if (a2.length > 0) {
			_quickSort(a2, 0, a2.length - 1);     
		}
	}
	private static void _quickSort(int[] list, int low, int high) { 
		if (low < high) { 
			int middle = getMiddle(list, low, high);  //將list數組進行一分爲二   
			 _quickSort(list, low, middle - 1);        //對低字表進行遞歸排序     
			 _quickSort(list, middle + 1, high);       //對高字表進行遞歸排序     
		}
	}
	private static int getMiddle(int[] list, int low, int high) {   
		int tmp = list[low];    //數組的第一個做爲中軸     
		while (low < high) {
			while (low < high && list[high] >= tmp) {
				high--;
			}
			list[low] = list[high];   //比中軸小的記錄移到低端 
			while (low < high && list[low] <= tmp) {    
				low++;     
			}
			list[high] = list[low];   //比中軸大的記錄移到高端  
		}
		list[low] = tmp;              //中軸記錄到尾     
		
		return low;     
	}
	public static void main(String [] args ) {
		//insertSort();
		//shellSort();
		//selectSort();
		//heapSort();
		//bubbleSort();
		quickSort();
	}
}