排序類算法階段性總結

1.快速排序

    /*
    * 快速排序
    * 不穩定：在一個待排序隊列中,A和B相等,且A排在B的前面,而排序之後,A排在了B的後面.這個時候,我們說這種算法是不穩定的.
    * */
    public void fastSort(int a[], int start, int end) {
        if (start >= end) return;
        int i = start, j = end;
        boolean flag = true;
        while (i < j) {
            if (a[i] > a[j]) {
                swap(a, i, j);
                flag = !flag;
            }
            if (flag) j--;
            else i++;
        }
        fastSort(a, start, i - 1);
        fastSort(a, i + 1, end);
    }

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

時間複雜度：最好O(nlogn),最壞O(n^2)

2.堆排序

    //堆排序
    public void heapSort(int a[]) {
        int n = a.length;
        for (int i = n / 2 - 1; i >= 0; i--) {
            heapAjust(a, i, n);
        }
        for (int i = n - 1; i > 0; i--) {
            swap(a, 0, i);
            heapAjust(a, 0, i);
        }
    }

    private void heapAjust(int[] a, int i, int n) {
        int left = 2 * i + 1;
        while (left < n) {
            int right = left + 1;
            if (right < n && a[left] < a[right]) {
                left = right;
            }
            if (a[i] < a[left]) {
                swap(a, i, left);
                i = left;
                left = 2 * i + 1;
            } else {
                break;
            }
        }
    }

    @Test
    public void test22() {
        int a[] = {5, 7, 8, 9, 3, 1, 4, 2, 10, 6, 11};
        heapSort(a);
        for (int elem : a) {
            System.out.print(elem + "\t");
        }
    }

    /*
    * 堆排序類題目
    * 堆排序原理：以大頂堆爲例
    * 1.輸出堆頂元素後，調整剩餘元素成爲新堆：輸出堆頂元素後，以堆中最後一個元素代替，這時根節點的左右子樹都是大頂堆，需自上而下進行調整，不斷比較左右孩子，取最大的那個交換。交換後繼續以這樣的方式調整
    * 2.將無序序列構建成一個堆：將序列看成一個完全二叉樹。最後一個非終端結點的座標是（n-2）/2.從最後一個非終端結點開始自上而下調整，然後在調整倒數第二個，直到第一個結點調整完，便建立了初始堆。
    * 
    * 
    * 題目描述：找到倒數第 k 個的元素。(找第k大的元素)
    * 思路1：維護一個k個數量的小頂堆，堆頂元素相當於界限,它是堆中所有元素的最小值。
    * 遍歷所有元素，如果比它大，則把它替換掉 ,所以堆中存儲的是目前爲止k個最大的元素。
    * 思路2:利用快排的原理做
    * */
    public int findKthLargest(int[] nums, int k) {
        PriorityQueue<Integer> minHeap = new PriorityQueue<>();//小頂堆
        for (int val : nums) {
            minHeap.add(val);
            if (minHeap.size() > k) minHeap.poll();
        }
        return minHeap.peek();
    }

時間複雜度：O(nlogn)

3.桶排序

    /*
    * 桶排序
    * 原理：第i個桶中存放的是頻率爲i的元素們.
    * 題目：出現頻率最多的 k 個元素
    * 相似思路題目：按照字符出現次數對字符串排序
    * */
    public List<Integer> topKFrequent(int[] nums, int k) {
        HashMap<Integer, Integer> countOfnum = new HashMap<>();
        for (int num : nums) {
            countOfnum.put(num, countOfnum.getOrDefault(num, 0) + 1);
        }
        List<Integer>[] buckets = new ArrayList[nums.length + 1];
        for (int key : countOfnum.keySet()) {
            int value = countOfnum.get(key);//buckets[value]
            if (buckets[value] == null) buckets[value] = new ArrayList<>();
            buckets[value].add(key);
        }
        List<Integer> topKFrequent = new LinkedList<>();
        for (int i = buckets.length - 1; i >= 0; i--) {
            List<Integer> elems = buckets[i];
            if (elems != null) {
                Iterator<Integer> elemIt = elems.iterator();
                while (elemIt.hasNext()) {
                    topKFrequent.add(elemIt.next());
                    if (topKFrequent.size() == k) return topKFrequent;
                }
            }
        }
        return topKFrequent;
    }

時間複雜度O(n)

4.歸併排序

    /*
    * 歸併排序
    * 思路：將數組均分成兩份，將每一份排好序，再將兩份有序序列合併。遞歸這個過程。
    * 對兩個有序序列合併，時間複雜度可以爲O(n)
    * 可以用歸併排序的思路解決逆序對的問題
    * */
    public void mergeSort(int a[]) {
        int[] cache = new int[a.length];
        sort(a, 0, a.length - 1, cache);
    }

    private void sort(int[] a, int start, int end, int[] cache) {
        if (start == end) {
            return;
        }
        int mid = (start + end) / 2;
        sort(a, start, mid, cache);
        sort(a, mid + 1, end, cache);
        merge(a, start, mid, end, cache);
    }

    private void merge(int[] a, int start, int mid, int end, int cache[]) {
        int i = start;
        int j = mid + 1;
        int k = 0;
        while (i <= mid && j <= end) {
            if (a[i] > a[j]) {
                cache[k++] = a[j++];
            } else {
                cache[k++] = a[i++];
            }
        }
        if (i <= mid) while (i <= mid) cache[k++] = a[i++];
        if (j <= end) while (j <= end) cache[k++] = a[j++];
        for (int p = 0; p < k; p++) a[start++] = cache[p];
    }

時間複雜度O(nlogn)

5.荷蘭國旗問題：

/*
    * 荷蘭國旗問題
    * i每找到一個小於flag的數，就和left交換，然後left++
    * i每找到一個大於flag的數，就和right交換，然後right--
    * 大於的放後面，小於的放前面，等於的自然就放在中間了；
    * */
    public void sortColors(int[] nums) {
       int length=nums.length;
        int i=0,left=0,right=length-1;
        int flag=1;
        while (i<=right){
            if(nums[i]<flag){
                swap(nums,i,left);
                i++;
                left++;
            }else if(nums[i]>flag){
                swap(nums,i,right);
                right--;//這裏不可以i++，因爲還要比較交換後的元素
            }else{
                i++;
            }
        }
    }

時間複雜度O(n)