算法—找出最小的k个数（涉及7种排序）

题目

输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。

方法1：快排

import java.util.ArrayList;

public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        //排序：快排
        ArrayList<Integer> list = new ArrayList<>();
        if(k > input.length){
            return list;
        }
        quickSort(input, 0, input.length-1);//快排
        for(int i=0; i<k; i++){
            list.add(input[i]);
        }
        return list;
    }
    public void quickSort(int[] input, int start, int end){
        int q = start; //定义一个基准q，初始值为start
        int left = start; //左指针
        int right = end; //右指针
        int temp; //temp在后面交换的时候用到
        if(start >= end){
            return; //递归跳出的条件
        }
        while(left < right){
            while(left<right && input[right]>=input[q]){
                right--; //往左走，找到小于基准值的数，一定要是右指针先走！
            }
            while(left<right && input[left]<=input[q]){
                left++; //往右走，找到大于基准值的数
            }
            //将上面两数交换
            if(left < right){
                temp = input[left];
                input[left] = input[right];
                input[right] = temp;
            }
        }
        //左指针与右指针相等了，说明找到了基准，注意此时还要将基准值与现在left所指的值互换
        temp = input[q];
        input[q] = input[left];
        input[left] = temp;
        q = left;
        quickSort(input, start, q-1);  //把基准左边的做一次快排
        quickSort(input, q+1, end);    //把基准右边的做一次快排
        }
    }

注意：快排有一个地方值得注意，如果初定义的基准在最左边，那么应该右指针(right)先走；如果初定义的基准在最右边，那么应该左指针(left)先走。如果基准在中间，则无所谓。

方法二：冒泡排序

import java.util.ArrayList;

public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        //排序：冒泡
        ArrayList<Integer> list = new ArrayList<>();
        if(k > input.length){
            return list;
        }
        bubbleSort(input); //当然这里只用执行k次冒泡，但此题为了巩固冒泡排序，就单独写了一个，还是执行n次冒泡
        for(int i=0; i<k; i++){
            list.add(input[i]);
        }
        return list;
    }
    public void bubbleSort(int[] input){
        int temp;
        for(int i=0; i<input.length; i++){
            //n次冒泡
            for(int j=input.length-1; j>0; j--){
                if(input[j] < input[j-1]){ //邻居两两比较，小的换到前面去
                    temp = input[j];
                    input[j] = input[j-1];
                    input[j-1] = temp;
                }
            }
        }
    }
    }

注意：这里只用执行k次冒泡，但此题为了巩固冒泡排序，就单独写了一个，还是执行n次冒泡。

方法3：归并排序

import java.util.ArrayList;

public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        //排序：归并
        ArrayList<Integer> list = new ArrayList<>();
        if(k > input.length){
            return list;
        }
        mergeSort(input, 0, input.length-1);
        for(int i=0; i<k; i++){
            list.add(input[i]);
        }
        return list;
    }
    public void mergeSort(int[] input, int start, int end){
        /*
        归并排序：
        1.将数组分为两个部分；
        2.递归操作：对这两个部分进行归并排序，递归跳出条件：数组的长度为1时
        3.将排好序的两个数组归并(merge)
        */
        if(start >= end){
            return;
        }
        int mid = (start+end)/2; //将数组分成左右两个数组
        mergeSort(input, start, mid); //对左边的进行归并排序
        mergeSort(input, mid+1, end); //对右边的进行归并排序
        merge(input, start, mid, end); //将左右数组归并成一个新的有序数组
    }
    public void merge(int[] input, int start, int mid, int end){
        /*参数有点多，逻辑还是很简单的
        start,mid,end:三个参数确定左右数组
        */
        int[] temp = new int[end-start+1]; //引入一个辅助数组
        int left = start; //left指针指向左边的数组
        int right = mid+1; //right指针指向右边的数组
        int t=0; //t指针指向新的数组temp
        while(left<=mid && right<=end){
            if(input[left] <= input[right]){
                temp[t++] = input[left++];
            }else{
                temp[t++] = input[right++];
            }
        }
        while(left <= mid){//左边数组有剩余
            temp[t++] = input[left++];
        }
        while(right <= end){//右边数组有剩余
            temp[t++] = input[right++];
        }
        for(int i=0; i<temp.length; i++){
            input[start+i] = temp[i]; //这里很容易出错，注意每次merge后组成的不是一个完整的数组，只是一部分而已,千万不能写成input[i]=temp[i]了
        }
    }
    }

注意：归并排序考察重点，除了递归之外，还有“merge()”函数，里面的参数要能确定左右两个子数组，另外，归并操作会引入一个辅助数组，最后要记得将辅助数组里的值复制到原数组的对应位置上去。

方法4：堆排序

未完待续。。