學習快速排序和二分查找算法

       1. 快速排序的思想采用的是分治算法實現，從頭選擇一個元素是作為“哨兵元素”，然后從尾部開始尋找一個比“哨兵元素“小的元素，然后跟它交換，接着從頭開始尋找比“哨兵元素“大的；元素，然后交換，直到“哨兵元素“的左邊都“哨兵元素“小，右邊都比“哨兵元素“大為止，這算是一次划分，快速排序是要經過的 k-1趟(假設有k個元素)划分才能排序好所有的元素。  

　　　下面根據分治實現的java代碼： 

public class QuickSort {


    public static void main(String[] args) {

        Integer[] a = new Integer[]{1,4,775,34,22,67};

        for(Integer e : a){
            System.out.print(e  + " ");
        }

        System.out.println();
        quickSort(a,0,a.length-1);

        for(Integer e : a){
            System.out.print(e + " ");
        }
    }

    public static int  getMiddle(Integer[] a, int low, int high){

        int key = a[low];

        while(low < high){

            //從最高開始尋找一個比key小的元素，然后交換
            while(low < high && a[high] > key){
                high--;
            }
           a[low] = a[high];

            //從頭開始查找一個比key大的元素，然后交換
            while (low < high && a[low] < key){
                low++;
            }

            a[high] = a[low];
        }

        //將正確的位置放在正確的位置
        a[low] = key;

        return low;
    }

    public static void quickSort(Integer a[], int low, int high){

        if(low > high)return;

        if(low < high){
            int middle = getMiddle(a,low,high);
            quickSort(a,low,middle-1);
            quickSort(a,middle+1,high);
        }
    }

 

   算法的性能是O(NogN)，快速排序的最差的性能是O(n*n）,最差性能是在每次的划分選取的"哨兵元素"都是改划分的最小元素。那么這樣它每次划分都是只有一個段，失去了快速排序多次划分的優勢，復雜度又退回n的平方。

    2.二分查找的比較簡單的算法，它默認是有序數組，它是每次選取數組的元素的中間索引值比較，如果比目標值大，則目標值可能在數組的中間的位置到數組的末尾的位置,然后接着比較

 數組的中間的位置到數組的末尾的位置的中間位置的值和目標值比較，直到找到最小的索引(low) 大於最大的索引(high)為止。
  下面是實現的java代碼：

package com.algorithm.sort;

public class BinarySerach {

    private  static final int t = 4;

    public static void main(String[] args) {

        Integer[] a = new Integer[]{1,4,775,34,22,67};

        int result  = binarySearch(a,0,a.length-1);
        System.out.println(a[result]);
    }

    //默認數組是排序的
    public static  int  binarySearch(Integer[] a,int left , int right){

        while (left <= right){
            int mid = (left +right)>>1;

            if(a[mid] > t){
                right = mid - 1;
            }else if(a[mid] < t){
                left = mid+1;
            }else{
                return mid;
            }
        }
        return -1;
    }

    //分治算法
    public int bsearch(int array[], int low, int high, int target)
    {
        if (low > high) return -1;

        int mid = (low + high)/2;
        if (array[mid]> target)
            return    bsearch(array, low, mid - 1, target);
        if (array[mid]< target)
            return    bsearch(array, mid+1, high, target);

        //if (midValue == target)
        return mid;
    }
}

 

   二分查找的算法復雜度O(logn),它比順序查找的時間復雜度O(n)小，效率高。