算法之快速排序(遞歸和非遞歸)

快速排序的兩種實現方式.遞歸和非遞歸

package com.ebiz.sort;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.Stack;

/**
 * @author YHj
 * @create 2019-08-18 17:42
 */
public class Quick {

    public static void main(String[] args) {
        int[] arr = new int[8];
        for (int i = 0; i < 8; i++) {
            arr[i] = (int) (Math.random() * 800000);
        }

        String s = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        System.out.println("排序前 = " + s);

        quickSort(arr,0,arr.length-1);


        String l = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        System.out.println("排序后 = " + l);
    }

    /**
     * 快速排序（遞歸）
     * <p>
     * ①. 從數列中挑出一個元素，稱為"基准"（pivot）。
     * ②. 重新排序數列，所有比基准值小的元素擺放在基准前面，所有比基准值大的元素擺在基准后面（相同的數可以到任一邊）。在這個分區結束之后，該基准就處於數列的中間位置。這個稱為分區（partition）操作。
     * ③. 遞歸地（recursively）把小於基准值元素的子數列和大於基准值元素的子數列排序。
     *
     * @param arr  待排序數組
     * @param low  左邊界
     * @param high 右邊界
     */
    public static void quickSort(int[] arr, int low, int high) {
        if (arr.length <= 0){
            return;
        }
        if (low >= high) {
            return;
        }
        int left = low;
        int right = high;

        int temp = arr[left];   //挖坑1：保存基准的值
        while (left < right) {
            while (left < right && arr[right] >= temp) {  //坑2：從后向前找到比基准小的元素，插入到基准位置坑1中
                right--;
            }
            arr[left] = arr[right];
            while (left < right && arr[left] <= temp) {   //坑3：從前往后找到比基准大的元素，放到剛才挖的坑2中
                left++;
            }
            arr[right] = arr[left];
        }
        arr[left] = temp;   //基准值填補到坑3中，准備分治遞歸快排
        System.out.println("Sorting: " + Arrays.toString(arr));
        quickSort(arr, low, left - 1);
        quickSort(arr, left + 1, high);
    }
    /**
     * 快速排序（非遞歸）
     *
     * ①. 從數列中挑出一個元素，稱為"基准"（pivot）。
     * ②. 重新排序數列，所有比基准值小的元素擺放在基准前面，所有比基准值大的元素擺在基准后面（相同的數可以到任一邊）。在這個分區結束之后，該基准就處於數列的中間位置。這個稱為分區（partition）操作。
     * ③. 把分區之后兩個區間的邊界（low和high）壓入棧保存，並循環①、②步驟
     * @param arr   待排序數組
     */
    public static void quickSortByStack(int[] arr){
        if(arr.length <= 0){
            return;
        }
        Stack<Integer> stack = new Stack<Integer>();

        //初始狀態的左右指針入棧
        stack.push(0);
        stack.push(arr.length - 1);
        while(!stack.isEmpty()){
            int high = stack.pop();     //出棧進行划分
            int low = stack.pop();

            int pivotIdx = partition(arr, low, high);

            //保存中間變量
            if(pivotIdx > low) {
                stack.push(low);
                stack.push(pivotIdx - 1);
            }
            if(pivotIdx < high && pivotIdx >= 0){
                stack.push(pivotIdx + 1);
                stack.push(high);
            }
        }
    }

    private static int partition(int[] arr, int low, int high){
        if(arr.length <= 0) {
            return -1;
        }
        if(low >= high) {
            return -1;
        }
        int l = low;
        int r = high;

        int pivot = arr[l];    //挖坑1：保存基准的值
        while(l < r){
            while(l < r && arr[r] >= pivot){  //坑2：從后向前找到比基准小的元素，插入到基准位置坑1中
                r--;
            }
            arr[l] = arr[r];
            while(l < r && arr[l] <= pivot){   //坑3：從前往后找到比基准大的元素，放到剛才挖的坑2中
                l++;
            }
            arr[r] = arr[l];
        }
        arr[l] = pivot;   //基准值填補到坑3中，准備分治遞歸快排
        return l;
    }


}