剑指offer-最小的K个数

题目：最小的K个数

题目描述

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

 

分析：这是一道考察排序的题，借此重新复习下常见的排序

方法一：利用堆排序

建立并维持一个只有k个元素的最大堆，后面的元素进来时先与堆顶元素进行比较，如果比堆顶元素大，则不放进去；如果比堆顶元素小，则删掉堆顶元素，将次元素入堆，对整个堆重新进行排序，当着n个数都遍历完后，此时堆中元素便是最小的k个元素

代码参考了讨论区，java中优先队列是用堆实现的

import java.util.ArrayList;
import java.util.Comparator;
import java.util.PriorityQueue;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer>result=new ArrayList<Integer>();
        int n=input.length;
        if(k>n||k==0) return result;
        PriorityQueue<Integer>maxHeap=new PriorityQueue<Integer>(k,new Comparator<Integer>(){
          @Override
            public int compare(Integer o1,Integer o2){
                return o2.compareTo(o1);
            }
        });
        for(int i=0;i<n;i++){
            if(maxHeap.size()!=k){
                maxHeap.offer(input[i]);
            }else if(maxHeap.peek()>input[i]){
                Integer tmp=maxHeap.poll();
                tmp=null;
                maxHeap.offer(input[i]);
            }
        }
        for(Integer integer:maxHeap){
            result.add(integer);
        }
        return result;
    }
}

java优先队列回顾

java中提供了PriorityQueue，PriorityQueue是基于小顶堆实现的无界优先队列，这个优先队列中的元素可以默认自然排序(实现了Comparable接口或内建类型)或者通过提供的Comparator（比较器）在队列实例化的时进行排序。

优先队列的大小是不受限制的，但在创建时可以指定初始大小。当我们向优先队列增加元素的时候，队列大小会自动增加。如果不指定初始大小，其默认的初始大小为11。

优先队列使用实例：

首先创建一个用户类Customer，它没有提供任何类型的排序。当我们用它建立优先队列时，应该为其提供一个比较器对象。

public class Customer {
 
    private int id;
    private String name;
 
    public Customer(int i, String n){
        this.id=i;
        this.name=n;
    }
 
    public int getId() {
        return id;
    }
 
    public String getName() {
        return name;
    }
 
}

使用Java随机数生成随机用户对象。对于自然排序，我们使用Integer对象，这也是一个封装过的Java对象。

import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
 
public class PriorityQueueExample {
 
    public static void main(String[] args) {
 
        //优先队列自然排序示例
        Queue<Integer> integerPriorityQueue = new PriorityQueue<>(7);
        Random rand = new Random();
        for(int i=0;i<7;i++){
            integerPriorityQueue.add(new Integer(rand.nextInt(100)));
        }
        for(int i=0;i<7;i++){
            Integer in = integerPriorityQueue.poll();
            System.out.println("Processing Integer:"+in);
        }
 
        //优先队列使用示例
        Queue<Customer> customerPriorityQueue = new PriorityQueue<>(7, idComparator);
        addDataToQueue(customerPriorityQueue);
 
        pollDataFromQueue(customerPriorityQueue);
 
    }
 
    //匿名Comparator实现
    public static Comparator<Customer> idComparator = new Comparator<Customer>(){
 
        @Override
        public int compare(Customer c1, Customer c2) {
            return (int) (c1.getId() - c2.getId());
        }
    };
 
    //用于往队列增加数据的通用方法
    private static void addDataToQueue(Queue<Customer> customerPriorityQueue) {
        Random rand = new Random();
        for(int i=0; i<7; i++){
            int id = rand.nextInt(100);
            customerPriorityQueue.add(new Customer(id, "Pankaj "+id));
        }
    }
 
    //用于从队列取数据的通用方法
    private static void pollDataFromQueue(Queue<Customer> customerPriorityQueue) {
        while(true){
            Customer cust = customerPriorityQueue.poll();
            if(cust == null) break;
            System.out.println("Processing Customer with ID="+cust.getId());
        }
    }
 
}

java中比较器的用法

在Java中有两个接口来支持这两个概念(Comparable和Comparator)，这两个接口都有连个需要被实现的方法。分别是： 
* java.lang.Comparable: int comparaTo(Object o1) 

该方法将该对象(this)和o1进行对比，返回一个int型的值，意义如下(大小都是逻辑上的大小)： 
1. positive – 该对象比o1大 
2. zero –　该对象和o1对象一样大 
3. negative – 该对象比o1对象小

*java.util.Comparator: int compare(Object o1, Object o2) 

该方法将o1和o2进行比较，返回一个int型的值，意义如下(大小都是逻辑上的大小)：

• 1. positive – o1 的值比 o2大
  2. zero – o1 的值和 o2 一样大
  3. negative – o1 的值比 o2小  

java.util.Collections.sort(List)和java.util.Arrays.sort(Object [])这两个方法用把指定的list按照升序排列，这时list中的元素必须实现java.lang.Comparable接口.

java.util.Collections.sort(List,Comparator)和java.util.Arrays.sort(Object[], Comparator)这两个方法在能够提供Comparator时对list进行排序。

关于比较器的返回值的正负与排序时升序还是降序的关系之前一直比较模糊，即什么时候返回1，就是升序，什么时候返回-1，也是升序，什么时候又是降序。

实质上

 jdk官方默认是升序，是基于：int compare(Object o1, Object o2) 

< return -1   
= return 0
> return 1

官方的源码就是基于这个写的；可以理解为硬性规定。 
也就是说，排序是由这三个参数同时决定的。

有时候我们在排序时会直接使用

 return o1.compareTo(o2)

这句代码实质上和上面<,=,>是一样的，我们根据其定义

将该对象(o1)和o2进行对比，返回一个int型的值，意义如下(大小都是逻辑上的大小)： 

1. 负 – 该对象比o2对象小

2. 正 – 该对象比o2大 

3. 0 –　该对象和o2对象一样大 

所以他表示的就是将集合从前到后进行升序排列

那么，同理

 return o2.compareTo(o1)

表示的就是从前到后降序排列

同理，对于前面的那种，如果要降序就必须完全相反：

< return 1 
= return 0
> return -1

我们需要注意的是比较器，起的作用就是比较，它返回的是你想要一个什么样的序列，所以他的返回结果是需要你进行设计的，即你想要什么顺序就让它返回对应的结果，打个比方我想要从前到后升序排列，对于

 compare(Object o1, Object o2) 来说，它在运行时o1自然就代表着前一个值，o2自然就代表着后一个值，随着函数的调用，从前往后依次进行比较

在从前到后的每一次的两两比较中，由于我想要得到升序排列，所以我的返回值需要设计的和默认顺序（默认顺序为升序）的返回值一致

所以，我仅仅需要写出以下语句即可

     public int compare(Integer o1, Integer o2) {
                //下面这么写，结果是升序
             if(o1 < o2){
                    return -1;
                }else if(o1 > o2){
                    return 1;
                }
                return 0;
            }    
            }

或是直接写

  public int compare(Integer o1, Integer o2) {
                //下面这么写，结果是升序
        
                 return o1.compareTo(o2);
            }

这样的返回值和官方默认顺序时的返回值时一致的，所以便能得到从前到后升序的排列

如果你想得到降序的排列，你只需使和前面的返回值相反就行

而至于排列是如何排的，真正要排序的工作并不交给比较器，而是由sort()函数里的Timsort()算法来进行排序

而Timsort算法来确定是进行升序还是降序排列的的依据就是前面的返回值

给个例子说明下：

需求：设计一个学生类， 属性有姓名，年龄， 成绩，并产生一个数组，要求安照成绩从高到低，如果成绩相等则由年龄由低到高排序。

实现代码：

import java.util.Arrays;
class Student implements Comparable<Student>{
    private String name;
    private int age;
    private float score;
    public Student(String name, int age, float score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
    public String toString() {
        return name + " " + age + " " + score;
    }
    public int compareTo(Student stu) {
        if(this.score > stu.score)  {
            return -1;
        } else if(this.score < stu.score) {
            return 1;
        } else {
            if(this.age > stu.age) {
                return 1;
            } else if(this.age < stu.age) {
                return -1;
            } else {
                return 0;
            }
        }
    }
}

public class ComparableDemo {
    public static void main(String[] args) {
        Student students[] = {new Student("张三", 20, 90.0f), new Student("李四", 22, 90.0f),
                new Student("王五", 20, 99.0f), new Student("赵六", 20, 70.0f), new Student("孙七", 22, 100.0f)};
        Arrays.sort(students);
        for (Student stu: students) {
            System.out.println(stu);
        }
    }

}

方法二：有空再补上

参考：java比较器原理

java比较器源码分析

java比较器排序原理

timSort排序原理