排序算法

快速排序

public class quickSort {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int [] arr={1,3,9,4,10,5,18,6,2,100,34,32,98,48,12,0,34,89};
		sort(arr,0,arr.length-1);
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i]+" ");
		}				

	}

	private static void sort(int[] array, int lo, int hi) {
		if(lo>=hi){
            return ;
        }
        int index=partition(array,lo,hi);
        sort(array,lo,index-1);
        sort(array,index+1,hi); 	
	}
	private static int partition(int[] array, int lo, int hi) {
		int key=array[lo];
        while(lo<hi){
            while(hi>lo&&array[hi]>=key){//從後半部分向前掃描
                hi--;
            }
            array[lo]=array[hi];
            while(hi>lo&&array[lo]<=key){//從前半部分向後掃描
                lo++;
            }
            array[hi]=array[lo];
        }
        array[hi]=key;
        return hi;
	}

}

運行結果

冒泡排序

private static void bubbleSort(int[] arr) {
		// TODO Auto-generated method stub
		int temp=0;
		boolean flag=true;
		while(flag){
			flag=false;
			for(int i=0;i<arr.length-1;i++){
				for(int j=0;j<arr.length-1-i;j++){
					if(arr[j]>arr[j+1]){
						temp=arr[i];
						arr[i]=arr[j];
						arr[j]=temp;
						flag=true;
					}
				}
			}
		}
		
	}

選擇排序

public static void selectSort(int[] a) {
        if (a == null || a.length <= 0) {
            return;
        }
        for (int i = 0; i < a.length; i++) {
            int temp = a[i];
            int flag = i; // 將當前下標定義爲最小值下標
            for (int j = i + 1; j < a.length; j++) {
                if (a[j] < temp) {// a[j] < temp 從小到大排序；a[j] > temp 從大到小排序
                    temp = a[j];
                    flag = j; // 如果有小於當前最小值的關鍵字將此關鍵字的下標賦值給flag
                }
            }
            if (flag != i) {
                a[flag] = a[i];
                a[i] = temp;
            }
        }
    }

運行結果

堆排序：

    堆是一種完全二叉樹結構。在排序的過程中，元素是存儲在一維數組中的，那麼知道一個元素的位置i（起始位置爲0），若存在左右子節點，則子節點的位置分別爲2i+1,2i+2。父節點爲(i-1)/2取整。

算法過程（大頂堆爲例）

class ArrayUtils {

    public static void printArray(int[] array) {
        System.out.print("{");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]);
            if (i < array.length - 1) {
                System.out.print(", ");
            }
        }
        System.out.println("}");
    }
    public static void exchangeElements(int[] array, int index1, int index2) {
        int temp = array[index1];
        array[index1] = array[index2];
        array[index2] = temp;
    }
}
public class HeapSort {
    public static void main(String[] args) {
        int[] array = { 12, 13, 5,24, 43, 4, 21, 33, 0, -12, -44, 18, 6 };
        System.out.println("初始序列");
        ArrayUtils.printArray(array);
        //創建堆
        heapSort(array);
        System.out.println("堆排序後結果");
        //升序輸出
        ArrayUtils.printArray(array);
    }
    public static void heapSort(int[] array) {
        //如果數組中的元素爲空，或者數組中的元素個數不超過1，則返回
        if (array == null || array.length <= 1) {
            return;
        }
        //創建大頂堆
        buildMaxHeap(array);
        //創建完大頂堆之後，數組中的第一個元素應該是堆中最大的元素，將最大的元素，與堆中最後一個葉子節點進行交換
        for (int i = array.length - 1; i >= 1; i--) {
            ArrayUtils.exchangeElements(array, 0, i);
            //輸出堆排序的過程
            for(int t=0;t<array.length;t++){
                System.out.print(array[t]+",");
            }
            System.out.println();
            maxHeap(array, i, 0);
        }
    }
    private static void buildMaxHeap(int[] array) {
        System.out.println("建堆運行了1次");
        if (array == null || array.length <= 1) {
            return;
        }
        //從第一個非葉子節點開始調整
        int half = array.length / 2;
        for (int i = half; i >= 0; i--) {
            maxHeap(array, array.length, i);
        }
    }
    private static void maxHeap(int[] array, int heapSize, int index) {
        int left = index * 2 + 1;
        int right = index * 2 + 2;
        int largest = index;
        //左節點較大
        if (left < heapSize && array[left] > array[index]) {
            largest = left;
        }
        //右節點較大
        if (right < heapSize && array[right] > array[largest]) {
            largest = right;
        }
        //不滿足大頂堆，需要交換
        if (index != largest) {
            ArrayUtils.exchangeElements(array, index, largest);
            //有可能會破壞堆的下層結構，需自上到下進行修正
            maxHeap(array, heapSize, largest);
        }
    }
}

運行結果