【算法】快速排序

基础算法：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 快速排序
 * 复杂度：  O（n * log n）
 * @author zx
 * @date   2022年01月04日19:28:11
 *
 * 有以下数组：[5,3,2,1,4,7,6,9,0,8]
 * 随机取一个数字5
 * 将比5小的数字全部放在左边的集合，比5大的放在右边的集合，生成以下集合：
 * [3,2,1,4,0] [5] [7,6,9,8]
 * 递归处理子数组 ..[3,2,1,4,0]  ->  [2,1,0][3][4]   -> [1,0][2][3][4] -> [0,1][2][3][4]
 *
 */
public class QuickSortUtils {
    public static void main(String[] args) {
        Integer[] i = new Integer[]{5,3,2,1,4,7,6,9,0,8};
        List<Integer> testArray = Arrays.asList(i);
        System.out.println(qSort(testArray));
    }

   /**
     * 快速排序递归方法，不考虑相等的值
     * @param  subList 待排序的集合
     * @return List<Integer>
     */
    private static List<Integer> qSort(List<Integer> subList){
        if(subList == null || subList.size() == 0){
            return Collections.emptyList();
        }
        if(subList.size() < 2){
            return subList;
        }
        // 选择一个基准值
        int pivot = 0;
        Integer pivotValue = subList.get(pivot);
        //获取所有比基准值对应的值小的集合放到 【左边集合】
        List<Integer> less = subList.stream().filter(item -> item < pivotValue).collect(Collectors.toList());
        //获取所有比基准值对应的值大的集合放到 【右边集合】
        List<Integer> greater = subList.stream().filter(item -> item > pivotValue).collect(Collectors.toList());
        //最终排序完成的集合为 【左边集合】 + pivotValue + 【右边集合】
        List<Integer> lessResult = qSort(less);
        List<Integer> greaterResult = qSort(greater);
        List<Integer> result = new ArrayList<>();
        result.addAll(lessResult);
        result.add(pivotValue);
        result.addAll(greaterResult);
        return result;
    }
}

结果：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

重复元素

存在重复元素怎么处理呢，思路是一致的，中间值代表的元素拼接时，无需排序，直接拼接到结果数组就可以了。

DEMO

package org.example.sort;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * 快速排序
 * 复杂度：  O（n * log n）
 * @author zx
 * @date   2022年01月04日19:28:11
 *
 * 有以下数组：[5,3,2,1,4,7,6,9,0,8]
 * 随机取一个数字5
 * 将比5小的数字全部放在左边的集合，比5大的放在右边的集合，生成以下集合：
 * [3,2,1,4,0] [5] [7,6,9,8]
 * 递归处理子数组 ..[3,2,1,4,0]  ->  [2,1,0][3][4]   -> [1,0][2][3][4] -> [0,1][2][3][4]
 *
 */
public class QuickSortUtils {
    public static void main(String[] args) {
        Integer[] i = new Integer[]{3,5,1,1,4,2,3};
        List<Integer> testArray = Arrays.asList(i);
        System.out.println(qSortWithEqualsValue(testArray));

    }

  

    /**
     * 快速排序递归方法-包含相等值的处理方式
     * @param subList 待排序的集合
     * @return 排序好的集合
     */
    private static List<Integer> qSortWithEqualsValue(List<Integer> subList){
        if(subList == null || subList.size() == 0){
            return Collections.emptyList();
        }
        if(subList.size() < 2){
            return subList;
        }
        // 选择一个基准值
        int pivot = 0;
        Integer pivotValue = subList.get(pivot);
        // 获取所有比基准值对应的值小的集合放到 【左边集合】
        List<Integer> less = subList.stream().filter(item -> item < pivotValue).collect(Collectors.toList());
        // 中位数相等的值，不需要参与排序，直接拼接 【中间集合】
        List<Integer> equals = subList.stream().filter(item -> Objects.equals(item, pivotValue)).collect(Collectors.toList());
        // 获取所有比基准值对应的值大的集合放到 【右边集合】
        List<Integer> greater = subList.stream().filter(item -> item > pivotValue).collect(Collectors.toList());
        // 最终排序完成的集合为 【左边集合】 + pivotValue + 【右边集合】
        List<Integer> lessResult = qSortWithEqualsValue(less);
        List<Integer> greaterResult = qSortWithEqualsValue(greater);
        List<Integer> result = new ArrayList<>();
        result.addAll(lessResult);
        result.addAll(equals);
        result.addAll(greaterResult);
        return result;
    }
}

结果:

[1, 1, 2, 3, 3, 4, 5]