快速排序（递归以及非递归）

原理不说了，核心函数为getParition，非递归用栈实现。

直接上代码

package sort;

import java.util.Stack;

/**
 * @author Livingdd
 * 2019/8/26 14:38
 **/
public class QuickSort {

    public void quickSort(int[] nums){
//        //递归
//        sort(nums,0,nums.length-1);
        //非递归
//        sortNotRecursion(nums);
    }
    public void sortNotRecursion(int[] nums){
        Stack<int[]> stack= new Stack<>();
        int[] temp = {0,nums.length-1};
        stack.add(temp);
        while (stack!=null && stack.size()!=0){
            int[] arr = stack.pop();
            int start = arr[0];
            int end = arr[1];
            int paration = getParition(start,end,nums);
            if(start < paration-1){
                int[] front = {start,paration-1};
                stack.add(front);
            }
            if(paration+1 < end){
                int[] after = {paration+1,end};
                stack.add(after);
            }

        }
    }
    public void sort(int[] nums,int start,int end){
        if(end<=start) return ;
        int paration = getParition(start,end,nums);
        sort(nums,start,paration-1);
        sort(nums,paration+1,end);
    }
    public int getParition(int start,int end,int[] nums){
        int parIndex = end;
        int parValue = nums[end];
        int queueIndex = start;
        for(int i = start;i<=end-1;i++){
            if(nums[i]<parValue){
                swap(nums,i,queueIndex);
                queueIndex++;
            }
        }
        swap(nums,parIndex,queueIndex);
        return queueIndex;
    }
    public void swap(int[] nums,int x,int y){
        int temp =nums[x];
        nums[x] = nums[y];
        nums[y] = temp;
    }
}