算法基礎（二）

例一

給定一個數組arr，和一個數num，請把小於等於num的數放在數 組的左邊，大於num的數放在數組的右邊。
要求額外空間複雜度O(1)，時間複雜度O(N)

   public  static void partition(int[] arr, int l, int num) {
        int index=-1;
        while(l<arr.length){
            if(arr[l]<num)  swap(arr,++index,l++);
            else  l++;
        }
    }
    public static void swap(int[] arr, int i, int j){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }

例一(升級版)

給定一個數組arr，和一個數num，請把小於num的數放在數組的 左邊，等於num的數放在數組的中間，大於num的數放在數組的 右邊。
要求額外空間複雜度O(1)，時間複雜度O(N）

  public static void partition(int[] arr, int l, int num) {
        int sindex=l-1;//前指標
        int eindex=arr.length;//後指標
        while(l<eindex){
            if(arr[l]<num)
                swap(arr,++sindex,l++);
            else if(arr[l]==num)
                l++;
            else
                swap(arr,--eindex,l);
         }
    }

    public static void swap(int[] arr, int i, int j){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }

 經過上面的例子引入經典快排

時間複雜度O(N*logN)，額外空間複雜度O(logN)

　　public static void quickSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        quickSort(arr, 0, arr.length - 1);
    }

    public static void quickSort(int[] arr, int l, int r) {
        if (l < r) {
　　　　　　　//加上下面一行就變成隨機快排 //swap(arr, l + (int) (Math.random() * (r - l + 1)), r);
            int[] p = partition(arr, l, r);
            quickSort(arr, l, p[0] - 1);
            quickSort(arr, p[1] + 1, r);
        }
    }

    public static int[] partition(int[] arr, int l, int r) {
        int less = l - 1;
        int more = r;
        while (l < more) {
            if (arr[l] < arr[r]) {
                swap(arr, ++less, l++);
            } else if (arr[l] > arr[r]) {
                swap(arr, --more, l);
            } else {
                l++;
            }
        }
        swap(arr, more, r);
        return new int[] { less + 1, more };
    }

    public static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

 堆排序

時間複雜度O(N*logN)，額外空間複雜度O(1)

建堆的過程，時間複雜度爲O(N)　　

優先級隊列結構，就是堆結構

public static void headSort(int[] arr){
        if(arr==null||arr.length<2)
            return;
        for (int i = 0; i < arr.length; i++) {
            headInsert(arr,i);//建成大根堆
        }
        int headSize=arr.length;
        swap(arr,0,--headSize);
        //堆頂和堆底交換，堆底元素移出比較
        while (headSize>0){
            heapify(arr,0,headSize);//從新調整成大根堆
            swap(arr,0,--headSize);
        }
    }

    //建大根堆
    public static void headInsert(int[] arr, int index) {
        while(arr[index]>arr[(index-1)/2]){
            swap(arr,index,(index-1)/2);
            index=(index-1)/2;
        }
    }
    //變成大根堆
    public static void heapify(int[] arr, int index, int size) {
        int left = index * 2 + 1;//根節點的左節點
        while (left < size) {//左節點沒超過範圍，一直做比較
            int largest = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left;//找出左節點和右節點較大的元素
            largest = arr[largest] > arr[index] ? largest : index;//再與根節點比較，找出較大的元素
            if (largest == index) {//若是較大的元素仍是根節點，節束，不用交換
                break;
            }
            swap(arr, largest, index);
            index = largest;//根節點移到交換的子節點，繼續交換
            left = index * 2 + 1;
        }
    }
    public static void swap(int[] arr, int i, int j){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }