subject

Enter the integer array arr to find the minimum number of k. For example, if you enter 8 numbers: 4, 5, 1, 6, 2, 7, 3 and 8, the smallest 4 numbers are 1, 2, 3 and 4.

Example 1:

Input: arr = [3,2,1], k = 2 output: [1,2] or [2,1] example 2:

Input: arr = [0,1,2,1], k = 1, output: [0]

Restrictions:

0 <= k <= arr.length <= 10000 0 <= arr[i] <= 10000

Xiao Xi: there is another solution to this problem, which is counting and sorting. Let's talk about counting and sorting first

Count sort

 

Count sort animation

Counting and sorting graphic Edition

Count sort text version

• During initialization, the subscript count of the count array is equal to 0, It means that each element appears 0 times.

• The first element 2 is placed where the subscript is 2. Since it only appears once, the count value with subscript 2 + 1

• The second element 2 is placed at the position where the subscript is 2. Count count and then + 1 becomes 2, indicating that 2 appears twice.

• The third element 1 is placed at the position where the subscript is 1. The count with subscript 1 is + 1 and becomes 1, indicating that 1 occurs once.

• The fourth element 0 is placed at the position where the subscript is 0. The count with subscript 0 is + 1 to 1, which means that 0 occurs once.

• The fifth element 1 is placed at the position where the subscript is 1. The count with subscript 1 is + 1 and becomes 2, indicating that 1 occurs twice.

• The sixth element 5 is placed at the position where the subscript is 5. The count with subscript 5 is + 1 and becomes 1, indicating that 5 appears once

• Next, process the count array, traverse the count array, and empty the original array for convenience of understanding.

• The traversal index is 0, and the count array value is 1, which means that 0 occurs once, so let 0 occupy the 1 bit of the original array.

• The traversal index is 1, and the count array value is 2, which means that 1 occurs twice, so let 1 occupy 2 bits of the original array.

• The traversal index is 2, and the count array value is 2, which means that 2 occurs twice, so let 2 occupy the 2 bits of the original array.

• The traversal index is 3, and the count array value is 0, which means that 3 occurs 0 times, so it does not occupy a bit

• The traversal index is 4, and the count array value is 0, which means that 4 occurs 0 times, so it does not occupy a bit

• The traversal index is 5, and the count array value is 1, which means that 5 occurs once, so 5 occupies 1 bit of the original array.

• Come here. The original array has become orderly!

Use counting sorting to solve problems

 

Problem solving animation

Counting sorting problem solving diagram

code

Java

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        if (k == 0 || arr.length == 0) {
            return new int[0];
        }
        // Count the number of occurrences of each number
        int[] counter = new int[10001];
        for (int num: arr) {
            counter[num]++;
        }
        // Find k numbers from the beginning according to the counter array as the return result
        int[] res = new int[k];
        int idx = 0;
        for (int num = 0; num < counter.length; num++) {
            while (counter[num]-- > 0 && idx < k) {
                res[idx++] = num;
            }
            if (idx == k) {
                break;
            }
        }
        return res;
    }
}

C++

class Solution {
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        vector<int> temp(10000);  //The value in arr will not be greater than 10000 or less than 0, so apply for an integer array of 10000 size
        for(const int& val : arr)  //The array subscript val corresponds to the number of val in arr, and temp[val] corresponds to the number of val in arr
            ++temp[val];
        vector<int> result;  //Results to return
        int count = 0;  //count
        for(int i = 0; i < temp.size(); ++i)  //Traverse temp from front to back, that is, traverse val from small to large
        {
            if(count >= k)  //If the number stored in the result to be returned is greater than or equal to k, jump out of the loop
                break;            
            if(temp[i])  //temp[i] is not 0, indicating that there is data there
            {
                while(temp[i]--)  //If several values in arr are i, put several data into result
                {
                    result.push_back(i);
                    count++;  //count
                }
            }
        }
        result.resize(k);
        return result;
    }
};

Python

def get_least_numbers(arr, k):
    nums = [0] * 10000  # Request an element that contains the maximum number of elements
    for a in arr:
        nums[a] += 1  # Count duplicate elements
    output = []
    i = 0  # Traverse from 0 (traverse from minimum)
    while len(output) < k:
        if nums[i] >= 1:  # If the value at the index is greater than 1, it indicates that the value exists at least once, and the loop writes to the output
            for j in range(nums[i]):
                output.append(i)
        i += 1
    return output[:k]  # Be sure to pay attention to the situation that there are more than k single repeated elements

This article is reproduced to Xiaoxi