《基础算法之排序》： 5、快速排序——java实现

5、快速排序

题目思路：

其实快排的思想很简单，一共两个步骤：
第一个步骤就是将首位看成分割或者轴点，让小于该位置的数放到左边，大于该位置的数放到右边。
第二个步骤就是一旦第一个步骤完成，就在此基础上再分别将左边和右边递归做第一步的处理，直到每一个位置上的都实现小的在左大的在右。

排序复杂度：

递归版本：
时间复杂度：o（n*logn）
空间复杂度：o（1）
非递归版本：
时间复杂度：o（n*logn）
空间复杂度：o（n）栈

排序稳定性：

由于left和right有一个位置交换，因此会出现相等的数位置前后不一致。

代码实现：

递归版：

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

    private static void quickSort(int[] arr, int l, int r) {
        if (l < r) {
            int pivot = partation(arr, l, r);
            quickSort(arr, l, pivot - 1);
            quickSort(arr, pivot + 1, r);
        }
    }

    private static int partation(int[] arr, int l, int r) {
        int pivot_item = arr[l];
        int begin = l;
        int end = r;
        while (begin < end){
            while (arr[begin] <= pivot_item){
                begin++;
            }
            while (pivot_item < arr[end]){
                end--;
            }
            if (begin < end){
                swap(arr,begin,end);
            }

        }
        arr[l] = arr[end];
        arr[end] = pivot_item;
        return end;
    }

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

非递归版：
由于递归版本用到了递归栈，要使用非递归版就要考虑用栈代替原来的递归。
要用到栈，需要考虑栈中push的数据，将前后坐标push到栈中，在依次弹出，然后比较前后坐标与轴的位置，在依次将坐标压栈。

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

   private static void quickSort(int[] arr, int l, int r) {
        Stack<Integer> stack = new Stack<>();
        stack.push(l);
        stack.push(r);
        while (!stack.isEmpty()) {
            int right = stack.pop();
            int left = stack.pop();
            int pivot = partation(arr, left, right);
            if (left < pivot - 1){
                stack.push(left);
                stack.push(pivot - 1);
            }
            if (pivot + 1 < right){
                stack.push(pivot + 1);
                stack.push(right);
            }
        }
    }

    private static int partation(int[] arr, int l, int r) {
        int pivot_item = arr[l];
        int begin = l;
        int end = r;
        while (begin < end){
            while (arr[begin] <= pivot_item){
                begin++;
            }
            while (pivot_item < arr[end]){
                end--;
            }
            if (begin < end){
                swap(arr,begin,end);
            }

        }
        arr[l] = arr[end];
        arr[end] = pivot_item;
        return end;
    }

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