剑指Offer第30题 - 最小的K个数 C/C++, Java, Python

 

题目描述

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

 

思路：就是排序，理论上堆排序和改进快排效率会高一些。就是不用完成全部的排序。只需要第k小的数将数据分开即可。

C/C++:    运行时间：3ms    占用内存：488k

class Solution {
public:
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k)
    {
        vector<int> ans;//动态数组
        if(input.size()==0 || input.size()<k)//不符合要求，返回空数组
            return ans;
        sort(input.begin(), input.end());//排序
        for(int i=0; i<k; ++i)
            ans.push_back(input[i]);
        return ans;
    }
};

红黑树：multiset集合  利用仿函数改变排序顺序 时间复杂度O（nlogk）

class Solution {
public:
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        int len=input.size();
        if(len<=0||k>len) return vector<int>();
         
        //仿函数中的greater<T>模板，从大到小排序
        multiset<int, greater<int> > leastNums;
        vector<int>::iterator vec_it=input.begin();
        for(;vec_it!=input.end();vec_it++)
        {
            //将前k个元素插入集合
            if(leastNums.size()<k)
                leastNums.insert(*vec_it);
            else
            {
                //第一个元素是最大值
                multiset<int, greater<int> >::iterator greatest_it=leastNums.begin();
                //如果后续元素<第一个元素，删除第一个，加入当前元素
                if(*vec_it<*(leastNums.begin()))
                {
                    leastNums.erase(greatest_it);
                    leastNums.insert(*vec_it);
                }
            }
        }
         
        return vector<int>(leastNums.begin(),leastNums.end());
    }
};

 

 

Java:    运行时间：28ms    占用内存：9692k

 

import java.util.*;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k)
    {
        ArrayList<Integer> ans = new ArrayList<>();
        if(input.length<k || input.length==0)
            return ans;
        Arrays.sort(input);//数组排序
        for(int i=0; i<k; ++i)
            ans.add(input[i]);
        return ans;
    }
}

高效方法：

import java.util.ArrayList;
import java.util.Stack;
 
/**
 * 用最小堆实现
 * 思路：建立一个最大堆，堆大小为k。当堆不满时，直接插入元素；
 *      当堆满，将插入元素k与堆中最大元素max比较，如果k<max,将max替换为k，否则不操作。
 */
public class Demo2 {
 
	ArrayList<Integer> list = new ArrayList<Integer>();
	
	public ArrayList<Integer> GetLeastNumbers_Solution(int[] input, int k) {
		//鲁棒性判断
		if (input == null || k <= 0 || k > input.length)
			return list;
 
		MaxPQ q = new MaxPQ(k);
		//最小堆插入元素O(log(n))
		for (int i = 0; i < input.length; i++) {
			q.insert(input[i]);
		}
		//用堆栈堆元素进行反序
		Stack<Integer> stack = new Stack<Integer>();
		while (q.size > 0) {
			stack.push(q.delMax());
		}
		while (!stack.isEmpty()) {
			list.add(stack.pop());
		}
		
		return list;
	}
}
 
/*
 * 最大堆
 */
class MaxPQ {
	int[] arr = null;
	int size = 0;
	int maxNum = 0;
	//数组下标从1开始
	public MaxPQ(int maxNum) {
		arr = new int[maxNum + 1];
		this.maxNum = maxNum;
	}
	
	//删除最大元素
	public int delMax() {
		if (size <= 0)
			throw new RuntimeException("堆空");
		if (size == 1) {
			size--;
			return arr[1];
		}
		int max = arr[1];
		arr[1] = arr[size--];
		sink(1);
		return max;
	}
	//插入元素
	public void insert(int v) {
		if (size < maxNum) {
			arr[++size] = v;
			swim(size);
		} else {
			if (arr[1] > v) {
				arr[1] = v;
				sink(1);
			}
		}
	}
	
	//下沉
	private void sink(int k) {
		while (k * 2 <= size) {
			int child = k * 2;
			if (child < size) {
				if (arr[child] < arr[child + 1])
					child++;
			}
			if (arr[k] < arr[child]) {
				exch(arr, k, child);
				k = child;
			} else
				break;
		}
	}
	//上浮
	private void swim(int k) {
		arr[0] = arr[k];
		while (arr[k] > arr[k / 2]) {
			exch(arr, k, k / 2);
			k = k / 2;
		}
	}
 
	private void exch(int[] arr, int i, int j) {
		int tmp = arr[i];
		arr[i] = arr[j];
		arr[j] = tmp;
 
	}
 
}

Python:    运行时间：34ms    占用内存：5732k

# -*- coding:utf-8 -*-
class Solution:
    def GetLeastNumbers_Solution(self, tinput, k):
        # write code here
        if tinput == [] or k > len(tinput):
            return []
        tinput.sort()
        return tinput[:k]