快速排序（遞歸和非遞歸）

快速排序的時間復雜度為   壞的為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));
    } 
}