最小的K个数（快排和冒泡分别实现）

关于冒泡和快速排序更加详细的解析在：Java实现的快速排序 冒泡排序和双向冒泡排序算法

思路很清晰，其实考察在于排序算法，直接上快速排序和冒泡排序两种

（1）Main方法

public static void main(String[] args) throws IOException {
        int[] array = new int[]{4,5,1,6,2,7,3,8};
        int k = 4;
        List<Integer> list = getLeastNumbers_Solution(array, k);
        System.out.println(list.toString());
    }

（2）接受入参的调用方法

private static List<Integer> getLeastNumbers_Solution(int[] array, int k) {
        List<Integer> list = new ArrayList<>(k);
        // 针对数组做快排
        fastSort(array,0, array.length-1);
        System.out.println("排序后"+Arrays.toString(array));
        // 针对数组做冒泡排序
        guluSort(array);
        System.out.println("排序后"+Arrays.toString(array));
        // 循环把前K个最小的值放入list返回
        for (int i = 0; i < k; i++) {
            list.add(array[i]);
        }
        return list;
    }

（3）gulu就是咕噜，冒泡排序的爱称

private static void guluSort(int[] array) {
        for (int i = 0; i < array.length; i++) {
            for (int j = i+1; j < array.length; j++) {
                if (array[i]>array[j]){
                    swap(array, i, j);
                }
            }
        }
    }

（4）快速排序

private static void fastSort(int[] array, int begin , int end) {
        if (begin >= end){
            return;
        }
        int left = begin+1;
        int right = end;
        int target = array[begin];
        while (left<right){
            // 从后面找一个比目标值小的
            while (array[right]>target && left<right){
                right --;
            }
            // 从前面找一个比目标值大的
            while (array[left]<target && left<right){
                left ++;
            }
            swap( array, left, right);
        }
        // 跳出循环就是left,right重叠的时候
        swap(array, begin, left);
        fastSort(array, begin, left-1);
        fastSort(array, right+1, end);
    }

（5）Swap就是根据下标交换位置的方法

private static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

（6）看结果：