快速排序（递归和非递归）

快速排序的时间复杂度为   坏的为O(n^2)    好的为O(nlog2n)     不稳定

一趟快排得到的结果

找一次基准的时间复杂度为O（n^2）

对于一个未排序的数组 ，经过一趟快排，此时par已经确定

如果par之前 或者之后还有至少两个数那就还得找基准进行一趟快排，找出新的par

递归方法：

package sort;

import java.util.Arrays;

public class TestQuickSort {

    
    //返回基准的下标 public static int partion(int []array,int low,int hign){
        
            int tmp=array[low];
            while(low<hign){
                while(low<hign&&array[hign]>=tmp){
                    --hign;
                }
                if(low>=hign){
                    break;
                }else{
                    array[low]=array[hign];
                }
                while(low<hign&&array[low]<=tmp){
                    ++low;
                }
                if(low>=hign){
                    break;
                }else{
                    array[hign]=array[low];
                }
            
        }
            array[low]=tmp;
            return low;
        
    }
    
    public static void Quick(int[]array,int low,int hign){
        int par=partion(array,low,hign);
        if(par>low+1){//左边还需要快排
            Quick(array,low,par-1);
        }
        if(par<hign-1){//右边还需要快排
            Quick(array,par+1,hign);
        }
        
    }

    public static void QuickSort(int[]array){
        Quick(array,0,array.length-1); }

public static void main(String[] args) { // TODO Auto-generated method stub 
      int[]array={20,3,5,0,32,22,11,8,7,9}; 
      QuickSort(array); 
      System.out.println(Arrays.toString(array)); 
    }
 }

非递归：

根据上个例子：

package sort;

import java.util.Arrays;

public class TestQuickSort {
    
    public static int partion(int []array,int low,int hign){
        
            int tmp=array[low];
            while(low<hign){
                while(low<hign&&array[hign]>=tmp){
                    --hign;
                }
                if(low>=hign){
                    break;
                }else{
                    array[low]=array[hign];
                }
                while(low<hign&&array[low]<=tmp){
                    ++low;
                }
                if(low>=hign){
                    break;
                }else{
                    array[hign]=array[low];
                }
            
        }
            array[low]=tmp;
            return low;
        
    }
    //快速排序的非递归用栈来做
    public static void QuickSort(int[]array){
        int[]stack=new int[array.length];
        int top=0;
        int low=0;
        int hign=array.length-1;
        int par=partion(array,low,hign);
        //入栈
        if(par>low+1){
            stack[top++]=low;
            stack[top++]=par-1;
        }
        if(par<hign-1){
            stack[top++]=par+1;
            stack[top++]=hign;
        }
        //出栈
        while(top>0){
            hign=stack[--top];
            low=stack[--top];
            par=partion(array,low,hign);
            if(par>low+1){
                stack[top++]=low;
                stack[top++]=par-1;
            }
            if(par<hign-1){
                stack[top++]=par+1;
                stack[top++]=hign;
                
            }
            
        }
    }
   
    public static void main(String[] args) {
        // TODO Auto-generated method stub
      int[]array={20,3,5,0,32,22,11,8,7,9};
      QuickSort(array); 
      System.out.println(Arrays.toString(array));
    } 
}