JZ29 最小的K個數

最小的K個數

給定一個數組，找出其中最小的K個數。例如數組元素是4,5,1,6,2,7,3,8這8個數字，則最小的4個數字是1,2,3,4。如果K>數組的長度，那麼返回一個空的數組

 

方法1：堆
思路和算法

我們用一個大根堆實時維護數組的前 k 小值。首先將前 k 個數插入大根堆中，隨後從第 k+1個數開始遍歷，如果當前遍歷到的數比大根堆的堆頂的數要小，就把堆頂的數彈出，再插入當前遍歷到的數。最後將大根堆裏的數存入數組返回即可。在下面的代碼中，由於 C++ 語言中的堆（即優先隊列）爲大根堆，我們可以這麼做。而 Python 語言中的堆爲小根堆，因此我們要對數組中所有的數取其相反數，才能使用小根堆維護前 k 小值。

方法2、用快排最最最高效解決 TopK 問題：O(N)O(N)
注意找前 K 大/前 K 小問題不需要對整個數組進行 O(NlogN)O(NlogN) 的排序！
例如本題，直接通過快排切分排好第 K 小的數（下標爲 K-1），那麼它左邊的數就是比它小的另外 K-1 個數啦～

func getLeastNumbers(arr []int, k int) []int {
    if len(arr)==0 || k==0 {
        return nil
    }

    //方法一 基於快排的快速選擇
    // return quicksearch(arr, 0, len(arr)-1, k)

    //方法二 快排 然後取前k個
    // quicksort(arr, 0, len(arr)-1)
    // return arr[:k]


    //方法三  建堆，大根堆
    d:=&heapInt{}
    for _,v:=range arr {
        if d.Len()<k {
            heap.Push(d,v)
        }else {
            if d.Peek()>v {
                heap.Pop(d)
                heap.Push(d,v)
            }
        }
    }
    return *d


}

func partition(nums []int,i,j int) int {
    l,m,r:=i,i,j
    for l<r {
        for l<r && nums[r]>=nums[m] {
                r--
        }
        for l<r && nums[l]<=nums[m] {
                l++
        }
        if l<r {
            nums[l],nums[r]=nums[r],nums[l]
        }
    }
    nums[m],nums[l]=nums[l],nums[m]
    
    return l
}

func quicksearch(nums []int,i,j,k int) []int{
    
    t:=partition(nums,i,j)

    if t==k-1 {
        return nums[:k]
    }

    if t<k-1 {
        return quicksearch(nums,t+1,j,k)
    }


    return quicksearch(nums,i,t-1,k)
    
}

func quicksort(nums []int,i,j int) {
    if i>=j {
        return
    }

    m:=partition(nums, i,j)
    quicksort(nums,i,m-1)
    quicksort(nums,m+1,j)
}

type heapInt []int

//Less  小於就是小跟堆，大於號就是大根堆
func (h *heapInt)Less(i,j int)bool {return (*h)[i]>(*h)[j]}
func (h *heapInt)Swap(i,j int) {(*h)[i],(*h)[j]=(*h)[j],(*h)[i]}
func (h *heapInt)Len() int {return len(*h)}
func (h *heapInt)Push(x interface{}) {
    *h=append(*h,x.(int))
}
func (h *heapInt)Pop() interface{} {
    t:=(*h)[len(*h)-1]
    *h=(*h)[:len(*h)-1]
    return t
}
func (h *heapInt)Peek() int {
    return (*h)[0]
}
`