快速排序三種實現

學習演算法最快方式：直接看標準程式碼。 note ：我們不為提高智商，我們僅僅想快速 「體驗|接受」 演算法的感覺，並熟練掌握

看完程式碼後，拿出值和筆推畫出程式碼的過程 |  或debug；

如果有哪一行程式碼沒有理解，很可能是（你的初始資料或case）沒有推畫或debug出對應的邊界條件

快速排序經典演算法： 

   public static void quick_sort(int[] arr, int l, int r) {
        if (l < r) {
            int mid = mid_index(arr, l, r);
            quick_sort(arr, l, mid - 1);
            quick_sort(arr, mid + 1, r);
        }
    }

    private static int mid_index(int[] arr, int l, int r) {
        int pivot_val = arr[l];
        while (l < r) {
            while (arr[r] >= pivot_val && l < r) {
                r--;
            }
            if (l < r) {
                arr[l++] = arr[r];
            }
            while (arr[l] <= pivot_val && l < r) {
                l++;
            }
            if (l < r) {
                arr[r--] = arr[l];
            }
        }
        arr[l] = pivot_val;
        return l;
    }

快速排序三路演算法： 

      三路演算法新增隨機過程可避免 經典演算法中 遇到已拍好序的資料時間複雜度退化為O(n*n)

   public static void three_quick_sort(int[] arr, int l, int r) {
        if (l < r) {
            int mid = three_mid_index(arr, l, r);
            three_quick_sort(arr, l, mid - 1);
            three_quick_sort(arr, mid + 1, r);
        }
    }

    private static int three_mid_index(int[] arr, int l, int r) {
        int index = l + (int)(Math.random() * (r - l + 1));
        swap(arr, index, r);
        int small = l - 1;
        for (index = l; index < r; index++) {
            if (arr[index] < arr[r]) {
                small++;
                if (small != index) {
                    swap(arr, small, index);
                }
            }
        }
        swap(arr, small + 1, r);
        return small + 1;
    }

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

快速排序非遞迴實現 

    public static void stack_quick_sort(int[] arr, int l, int r) {
        Stack<Integer> stack = new Stack<>();
        do {

            if (!stack.isEmpty()) {
                l = stack.pop();
                r = stack.pop();
            }
            // three_mid_index mid_index 都可以
            int mid_idx = mid_index(arr, l, r);

            if (l < mid_idx - 1) {
                stack.push(mid_idx - 1);
                stack.push(l);
            }

            if (mid_idx + 1 < r) {
                stack.push(r);
                stack.push(mid_idx + 1);
            }

        } while (!stack.isEmpty());
    }

    private static int mid_index(int[] arr, int l, int r) {
        int pivot_val = arr[l];
        while (l < r) {
            while (arr[r] >= pivot_val && l < r) {
                r--;
            }
            if (l < r) {
                arr[l++] = arr[r];
            }
            while (arr[l] <= pivot_val && l < r) {
                l++;
            }
            if (l < r) {
                arr[r--] = arr[l];
            }
        }
        arr[l] = pivot_val;
        return l;
    }