java複習之快速排序的2種實現方法

java複習之快速排序的2種實現方法

第一種，使用兩個指針的方法

package learn;

import java.util.Arrays;

/**
 * 快速排序
 */
public class QuickSort {

    public static void sort(int[] array,int left,int right){
        int i=left;
        int j=right;
        int start=array[left];
        if(left>=right){
            return;
        }
        while (i!=j){
            while (i<j&&array[j]>start){
                j--;
            }
            while(i<j&&array[i]<=start){
                i++;
            }
            if(i<j){
                int temp=array[i];
                array[i]=array[j];
                array[j]=temp;
            }
        }

            array[left]=array[i];
            array[i]=start;
            sort(array,left,i-1);
            sort(array,i+1,right);
    }
    public static void main(String[] args) {
        int[] array={8,9,1,7,2,3,5,4,6,0};
        sort(array,0,9);
        System.out.println(Arrays.toString(array));
    }
}

第二種，使用一個指針的方法

package learn;

import java.util.Arrays;


public class QuickSort2 {
    public static void sort(int[] array,int start,int end){
//        int povit =array[start];
        while (start>=end){
            return;
        }
        int i=start;
        int j=end;
        int n=method(array,i,j);
        sort(array,start,n-1);
        sort(array,n+1,end);

    }
    public static int method(int[] array,int i,int j){
        int povit =array[i];
        int mark=i;
        for(int x=i+1;x<=j;x++){
            if(array[x]<povit){
                mark++;
                int temp=array[mark];
                array[mark]=array[x];
                array[x]=temp;
            }
        }
        array[i]=array[mark];
        array[mark]=povit;
        return mark;
    }
    public static void main(String[] args) {
        int[] array={8,9,1,7,2,3,5,4,6,0};
        sort(array,0,9);
        System.out.println(Arrays.toString(array));
    }
}

注意，一定注意遞歸的結束條件
非遞歸的算法

package learn;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Stack;


public class QuickStack {
    public static void sort(int[] array,int start,int end){
        Stack<Map<String,Integer>> stack = new Stack<>();
        Map headmap=new HashMap();
        headmap.put("start",start);
        headmap.put("end",end);
        stack.push(headmap);
        while (!stack.isEmpty()){
            Map<String,Integer> map = stack.pop();
            int index = method(array,map.get("start"),map.get("end"));
            if(index-1>map.get("start")){//判斷的理由時防止數組越界，比如只有一個時，index和start一樣，這樣，放進去的就是index比start小
                Map<String,Integer> leftmap = new HashMap<>();
                leftmap.put("start",map.get("start"));
                leftmap.put("end",index-1);
                stack.push(leftmap);
            }
            if(index+1<map.get("end")){
                Map<String,Integer> rightmap = new HashMap<>();
                rightmap.put("start",index+1);
                rightmap.put("end",map.get("end"));
                stack.push(rightmap);
            }

        }
    }
    public static int method(int[] array,int i,int j){
        int povit =array[i];
        int mark=i;
        for(int x=i+1;x<=j;x++){
            if(array[x]<povit){
                mark++;
                int temp=array[mark];
                array[mark]=array[x];
                array[x]=temp;
            }
        }
        array[i]=array[mark];
        array[mark]=povit;
        return mark;
    }
    public static void main(String[] args) {
        int[] array={8,9,1,7,2,3,5,4,6,0};
        sort(array,0,9);
        System.out.println(Arrays.toString(array));
    }
}