快速排序代码实现

快速排序的思想

 首先找到一串数中的基准点 ponit，比如下图中拿第一个数为基准点，分别查询两边，从左边开始，如果 start < end && nums[start] > point ,交换位置，以交换后的基准点为线，递归两边排序，右边同理，具体思想如图所示

Java代码：

public class quickSort {
    public static void main(String[] args) {
        int[] su = new int[]{1,3,5,2};
        sort(su,0,su.length - 1);
        for(int i = 0; i <= su.length - 1; i ++){
            System.out.println(su[i]);
        }
    }
    public static void sort(int[] su , int start, int end){
        // 如果只有一个元素就不用再排序了
        if(start > end){
            return;
        }else {
            // 继续划分递归从两边开始排序
            // 找到基准点
            int partation = divide(su,start,end);
            sort(su,start,partation -1);
            sort(su,partation + 1,end);
        }
    }

    /**
     * 将数组的某一段元素进行划分，小的在基准点左边，大的在右边
     * @param su
     * @param start
     * @param end
     * @return
     */
    public static int divide(int[] su,int start,int end){
        // 每次以最右边为基准点
        int base = su[end];

        while (start < end){
            // 循环左边
            while (start < end && su[start] <= base){
                start ++;
            }
            // 上边的循环结束代表开始值大于基准点需要做交换
            if(start < end){
                int temp = su[start];
                su[start] = su[end];
                su[end] = temp;
                end --;
            }
            // 循环后边
            while (start < end && su[end] >= base){
                end --;
            }
            if(start < end){
                int temp = su[start];
                su[start] = su[end];
                su[end] = temp;
                start ++;
            }
        }
        return end;

    }
}

kotlin代码：

fun main(args : Array<String>){
    var su : IntArray = intArrayOf(1,3,5,2)
    sort(su,0,su.size - 1)
    for(i : Int in 0 .. su.size - 1){
        print(su[i])
    }


}
// 排序
fun sort(su : IntArray, start : Int, end : Int){
    if(start > end){
        return
    }
    // 找到基准位置
    val paration = divide(su,start,end)
    // 进行基准位置左边遍历
    sort(su,start,paration - 1)
    sort(su,paration + 1,end)

    // 进行基准位置右边遍历
}

// 找到基准位置
fun divide(su : IntArray, start : Int, end : Int) : Int{
    // 先将基准位置定位最后一个数
    var base = su[end];
    var s = start
    var e = end
    while (s < e){
        // 遍历左边
        while (s < e && su[s] <= base){
            s ++
        }
        // 当不满足要求时说明大于基准位置要进行交换
        if(s < e){
            var temp = su[s]
            su[s] = su[e]
            su[e] = temp
            e --
        }

        // 遍历右边
        while (s < e && su[e] >= base ){
            e --
        }
        if(s < e){
            var temp = su[s]
            su[s] = su[e]
            su[e] = temp
            s ++
        }

    }
    return s
}