文章最前： 我是Octopus，這個名字來源於我的中文名--章魚；我熱愛編程、熱愛算法、熱愛開源。所有源碼在我的個人github ；這博客是記錄我學習的點點滴滴，如果您對 Python、Java、AI、算法有興趣，可以關注我的動態，一起學習，共同進步。
相關文章：
- LeetCode：55. Jump Game（跳遠比賽）
- Leetcode：300. Longest Increasing Subsequence（最大增長序列）
- LeetCode：560. Subarray Sum Equals K（找出數組中連續子串和等於k）
文章目錄：
題目描述：
輸入整數數組 arr ，找出其中最小的 k 個數。例如，輸入4、5、1、6、2、7、3、8這8個數字，則最小的4個數字是1、2、3、4。
示例 1：
輸入：arr = [3,2,1], k = 2
輸出：[1,2] 或者 [2,1]
示例 2：
輸入：arr = [0,1,2,1], k = 1
輸出：[0]
限制：
0 <= k <= arr.length <= 100000 <= arr[i] <= 10000
題目分析：
首先這個問題，就是一個普通的排序問題： 排序分爲選擇排序，冒泡排序，插入排序，快速排序，基數排序，歸併排序等;可以解決該問題。
正在上傳…1）暴力算法：
首先對於解決本題目，先想到使用冒泡排序，冒泡排序是一種簡單的排序算法。它重複地走訪過要排序的數列，一次比較兩個元素，如果它們的順序錯誤就把它們交換過來。走訪數列的工作是重複地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個算法的名字由來是因爲越小的元素會經由交換慢慢“浮”到數列的頂端。 它的思路是先將數組進行排序，然後取前面k個值，最直接的思路：
- 比較相鄰的元素。如果第一個比第二個大，就交換它們兩個；
- 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對，這樣在最後的元素應該會是最大的數；
- 針對所有的元素重複以上的步驟，除了最後一個；
- 重複步驟1~3，直到排序完成。
排序完成之後再選取前面k個值：
/**
* 獲取最小多個值;快速排序
*
* @param arr 數組
* @param k k個數
* @return 數組
*/
public int[] getLeastNumbers(int[] arr, int k) {
if (arr.length == 0)
return arr;
for (int i = 0; i < arr.length; i++)
for (int j = 0; j < arr.length - 1 - i; j++)
if (arr[j + 1] < arr[j]) {
int temp = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = temp;
}
return Arrays.stream(arr).limit(k).toArray();
}
時間複雜度：O(n)
空間複雜度：O(1)
2）優化算法(堆排序)：
堆排序（Heapsort）是指利用堆這種數據結構所設計的一種排序算法。堆積是一個近似完全二叉樹的結構，並同時滿足堆積的性質：即子結點的鍵值或索引總是小於（或者大於）它的父節點。將初始待排序關鍵字序列(R1,R2….Rn)構建成大頂堆，此堆爲初始的無序區；
- 將堆頂元素R[1]與最後一個元素R[n]交換，此時得到新的無序區(R1,R2,……Rn-1)和新的有序區(Rn),且滿足R[1,2…n-1]<=R[n]；
- 由於交換後新的堆頂R[1]可能違反堆的性質，因此需要對當前無序區(R1,R2,……Rn-1)調整爲新堆，然後再次將R[1]與無序區最後一個元素交換，得到新的無序區(R1,R2….Rn-2)和新的有序區(Rn-1,Rn)。不斷重複此過程直到有序區的元素個數爲n-1，則整個排序過程完成。
這種方法相對於上一種方法有一定的優化。
/**
* 獲取最小多個值,利用優先隊列
*
* @param arr 數組
* @param k k個數
* @return 數組
*/
public int[] getLeastNumbers2(int[] arr, int k) {
PriorityQueue<Integer> priorityQueue = new PriorityQueue();
List<Integer> list = new ArrayList<>();
for (int num : arr) {
priorityQueue.add(num);
if (priorityQueue.size() > arr.length - k) {
list.add(priorityQueue.poll());
}
}
return list.stream().mapToInt(e -> Integer.valueOf(e)).toArray();
}
時間複雜度：O（n.logn）
空間複雜度：O（n）
3）最優算法(快速排序)
快速排序的基本思想：通過一趟排序將待排記錄分隔成獨立的兩部分，其中一部分記錄的關鍵字均比另一部分的關鍵字小，則可分別對這兩部分記錄繼續進行排序，以達到整個序列有序。快速排序使用分治法來把一個串（list）分爲兩個子串（sub-lists）。具體算法描述如下：
- 從數列中挑出一個元素，稱爲 “基準”（pivot）；
- 重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面（相同的數可以到任一邊）。在這個分區退出之後，該基準就處於數列的中間位置。這個稱爲分區（partition）操作；
- 遞歸地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序。
/**
* 獲取最小多個值 ,利用快速排序方法
*
* @param arr 數組
* @param k k個數
* @return 數組
*/
public int[] getLeastNumbers3(int[] arr, int k) {
int len = arr.length;
if (k == 0 || k > len) {
return new int[0];
}
int target = k - 1;
int left = 0;
int right = len - 1;
while (true) {
int index = partition(arr, left, right);
if (index == target) {
int[] res = new int[k];
for (int i = 0; i < k; i++) {
res[i] = arr[i];
}
return res;
} else if (index < target) {
// 下一輪搜索區間在 [index + 1, right]
left = index + 1;
} else {
// 下一輪搜索區間在 [left, index - 1]
right = index - 1;
}
}
}
/**
* 進行分區操作
*
* @param arr 數組
* @param left 左邊
* @param right 右邊
* @return 下標
*/
private int partition(int[] arr, int left, int right) {
int pivot = arr[left];
int index = left;
for (int i = left + 1; i <= right; i++) {
if (arr[i] < pivot) {
index++;
swap(arr, index, i);
}
}
swap(arr, left, index);
return index;
}
/**
* 交換數據中元素的位置
*
* @param arr 數組
* @param i 位置i
* @param j 位置j
*/
private void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
時間複雜度：O（n）
空間複雜度：O（n）