數據結構-快速排序

java實現快速排序

源代碼

public class QuickSort extends DataCrol {
    /**
     * 優化
     *
     * @param array
     * @param left
     * @param right
     * @return
     */
    int partition3(int[] array, int left, int right) {
        //三數取中
        int mid = (left + right) / 2;
        if (array[mid] > array[right]) {
            swap(array, mid, right);
        }
        if (array[left] > array[right]) {
            swap(array, left, right);
        }
        if (array[mid] > array[left]) {
            swap(array, mid, left);
        }
        return partition2(array, left, right);
    }

    // 58 55 93 61 61 29 68 00 22 07
    // 07 55 93 61 61 29 68 00 22 07
    // 07 55 93 61 61 29 68 00 22 93
    // 07 55 22 61 61 29 68 00 22 93
    // 07 55 22 61 61 29 68 00 61 93
    // 07 55 22 00 61 29 68 00 61 93
    // 07 55 22 00 61 29 68 61 61 93
    // 07 55 22 00 29 58 68 61 61 93
    //                OK
    int partition2(int[] array, int left, int right) {
        //1.先取最左邊的數作爲基準
        //2.執行函數後劃分爲基準數左邊的數都比基準數小，右邊的數都比基準數大
        //3.返回基準數下標
        //固定的切分方式
        int key = array[left];
        while (left < right) {
            while (array[right] >= key && right > left) {//從後半部分向前掃描
                right--;
            }
            array[left] = array[right];
            while (array[left] <= key && right > left) {//從前半部分向後掃描
                left++;
            }
            array[right] = array[left];
        }
        array[right] = key;
        return right;
    }

    // 58 55 93 61 61 29 68 00 22 07
    // P  i
    // 58 55 29 61 61 93 68 00 22 07
    // P     i
    // 58 55 29 00 61 93 68 61 22 07
    // P        i
    // 58 55 29 00 22 93 68 61 61 07
    // P           i
    // 58 55 29 00 22 07 68 61 61 93
    // P              i
    // 07 55 29 00 22 58 68 61 61 93
    // P              OK
    int partition(int A[], int left, int right) { // 劃分函數
//        int pivot = A[right];               // 這裏每次都選擇最後一個元素作爲基準
//        int tail = left - 1;                // tail爲小於基準的子數組最後一個元素的索引
//        for (int i = left; i < right; i++) { // 遍歷基準以外的其他元素
//            if (A[i] < pivot) {             // 把小於等於基準的元素放到前一個子數組末尾
//                swap(A, ++tail, i);
//            }
//        }
//        swap(A, tail + 1, right);           // 最後把基準放到前一個子數組的後邊，剩下的子數組既是大於基準的子數組
//        // 該操作很有可能把後面元素的穩定性打亂，所以快速排序是不穩定的排序算法
//        return tail + 1;                    // 返回基準的索引

        int pivot = A[left];
        int tail = left;
        for (int i = left + 1; i <= right; i++) {
            if (A[i] < pivot) {
                swap(A, ++tail, i);
            }
        }
        swap(A, left, tail);
        return tail;
    }

    void quickSort(int A[], int left, int right) {
        if (left >= right)
            return;
        int pivot_index = partition3(A, left, right); // 基準的索引
        quickSort(A, left, pivot_index - 1);
        quickSort(A, pivot_index + 1, right);
    }

    /**
     * 快速排序非遞歸（棧）
     *
     * @param array
     */
    void quickSortIteration(int array[]) {
        LinkedList<Integer> stack = new LinkedList<>();
        int left, right, pivotPos;
        stack.push(0);
        stack.push(array.length - 1);
        while (stack.size() != 0) {
            right = stack.pop();
            left = stack.pop();
            pivotPos = partition(array, left, right);
            if (left < pivotPos - 1) {
                stack.push(left);
                stack.push(pivotPos - 1);
            }
            if (right > pivotPos + 1) {
                stack.push(pivotPos + 1);
                stack.push(right);
            }
        }
    }

    @Override
    public void sort(int[] array) {
//        quickSort(array, 0, array.length - 1);
        quickSortIteration(array);
    }

    public static void main(String[] args) {
        QuickSort quickSort = new QuickSort();
        int[] array = DataCrol.createRandomArray(10);
//        int[] array = new int[]{6, 3, 7, 4, 1};
        DataCrol.print(array);
        quickSort.sort(array);
        DataCrol.print(array);
        quickSort.timeTest(700000);
    }
}