快速排序

快速排序

​ 快速排序采用的是分治思想，即在一个无序的序列中选取一个任意的基准元素pivot，利用pivot将待排序的序列分成两部分，前面部分元素均小于或等于基准元素，后面部分均大于或等于基准元素，然后采用递归的方法分别对前后两部分重复上述操作，直到将无序序列排列成有序序列。

基于python的实现

def quicksort(arr):
    if len(arr) <= 1:
        return arr
    #基准元素pivot为数组的第一个元素
    pivot = arr[0]
    # 小于基准元素pivot的数据
    left = [x for x in arr if x < pivot] 
    # 等于基准元素pivot的数据
    middle = [x for x in arr if x == pivot]
    # 大于基准元素pivot的数据
    right = [x for x in arr if x > pivot]
    # 递归 + 拼接数组(一个递归的最优写法实践)
    return quicksort(left) + middle + quicksort(right)

arr = [3,6,8,10,1,2,1]

print(quicksort(arr))

基于Java的实现

​ 借鉴于上面python的优秀思路，故用java实现一遍。

public class QuitSort8 {
    public static long[] quitSort(long[] is) {
        if (is.length <= 1) {
            return is;
        }
        long pivot = is[0];
        long[] left = Arrays.stream(is).flatMap(j -> LongStream.of(j)).filter(i -> i < pivot).toArray();
        long[] pivotL = Arrays.stream(is).flatMap(j -> LongStream.of(j)).filter(i -> i == pivot).toArray();
        long[] right = Arrays.stream(is).flatMap(j -> LongStream.of(j)).filter(i -> i > pivot).toArray();
        //左排序
        long[] sort = quitSort(left);
        //拼接  左排序 + 基点
        long[] mergedArray = new long[sort.length + pivotL.length];
        System.arraycopy(sort, 0, mergedArray, 0, left.length);
        System.arraycopy(pivotL, 0, mergedArray, left.length, pivotL.length);
        //右排序
        long[] sort2 = quitSort(right);
        //拼接 (左排序 + 基点) + 右排序
        long[] mergedArray2 = new long[mergedArray.length + right.length];
        System.arraycopy(mergedArray, 0, mergedArray2, 0, mergedArray.length);
        System.arraycopy(sort2, 0, mergedArray2, mergedArray.length, sort2.length);

        return mergedArray2;
    }

    public static void main(String[] args) {
        long[] ll = new long[]{3,6,8,10,1,2,1};
        long[] sort = quitSort(ll);
        for (long l : sort) {
            System.out.print(l + " ");
        }
    }
}