【JavaDS】优先级队列(PriorityQueue),堆,Top-k问题

╰+攻爆jí腚メ 2023-09-25 12:26 48阅读 0赞

![在这里插入图片描述][3f9026f5c260455c8ecd6dfef03f83ed.gif_pic_center]

✨**博客主页:**[ **心荣~**][Link 1]  
✨**系列专栏:**[**【Java实现数据结构】**][Java]  
✨**一句短话:** **难在坚持,贵在坚持,成在坚持!**

#### 文章目录 ####

*  一. 堆
 *   *  1. 堆的概念
     *  2. 堆的存储方式
     *  3. 堆的创建
     *  4. 元素入堆
     *  5. 元素出堆
     *  6. 获取堆中元素
 *  二. 优先级堆列(PriorityQueue)
 *   *  1. 优先级队列
     *  2. PriorityQueue的特性
     *  3. 集合框架中PriorityQueue的比较方式
     *  4. PriorityQueue常用构造方法
     *  5. PriorityQueue常用操作方法
     *  6. PriorityQueue的扩容方式
 *  三. Top-k问题

## 一. 堆 ##

### 1. 堆的概念 ###

如果有一个**关键码的集合K = \{k0，k1， k2，…，kn-1\}**，把它的所有元素**按完全二叉树的顺序存储方式存储 在一 个一维数组中**，并满足：**Ki <= K2i+1 且 Ki<= K2i+2 (Ki >= K2i+1 且 Ki >= K2i+2) i = 0，1，2…，则称为 小堆(或大堆)**。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

**堆的性质**:

*  堆中某个节点的值总是不大于或不小于其父节点的值；
 *  堆总是一棵**完全二叉树**。

![img][]

### 2. 堆的存储方式 ###

从堆的概念可知，**堆是一棵完全二叉树，因此可以层序的规则采用顺序的方式来高效存储**，

![img][img 1]注意：对于**非完全二叉树**，**则不适合使用顺序方式进行存储**，因为为了能够还原二叉树，**空间中必须要存储空节点，就会导致空间利用率比较低**。

假设i为节点在数组中的下标，则有：

*  如果i为0，则i表示的节点为根节点，否则i节点的双亲节点为 (i - 1)/2
 *  如果2 \* i + 1 小于节点个数，则节点i的左孩子下标为2 \* i + 1，否则没有左孩子
 *  如果2 \* i + 2 小于节点个数，则节点i的右孩子下标为2 \* i + 2，否则没有右孩子

### 3. 堆的创建 ###

**【向下调整】**

首先我们需要知道堆的特点, 堆的堆顶的元素大于 (或小于) 子堆的元素大小，堆的本质就是一棵完全二叉树，堆采用顺序存储的方式来实现, 所以根据这些特点可以总结出堆的创建过程。

1.  找到数组中最后一个子树所在位置，注意这里的子树不包含单独的叶子结点。
2.  对该子树进行**向下调整**，如果要创建的是大根堆，**找到该树两个子结点值较大的结点与根结点进行比较**，**如果这个子结点比根结点要大**，则**交换**两结点的值，然后再对被调整的子结点作相同的调整(向下调整)，直到被调整的子树满足大堆条件或下标超出数组的范围; 同样的思路, 如果建立的是小根堆 , **找到该树两个子结点值较小的结点与根结点进行比较**，**如果这个子结点比根结点要小**，则**交换**两结点的值 , 然后再对被调整的子结点作相同的调整(向下调整)，直到被调整的子树满足大堆条件或下标超出数组的范围
3.  从最后一棵子树（该树不为叶子，最右边一棵高度为2的子树）开始调整，调整完后再向前找前一棵子树 , 以此类推, 直至调整完最后一棵(以堆顶结点所代表的树)结束，按此顺序对所有树进行向下调整，此时(大/小)堆就创建好了。

设最后一棵**子树根结点所对应数组下标为parent**，其**左子树根结点为child**，**堆大小为len**，根据二叉树的性质，下标会满足**child = 2 ∗ parent + 1** ； **parent = (child − 1 ) / 2** ;

最后一个结点下标为len−1，其父结点下标为(len−2) / 2 ; 也就是说 , 最后一棵子树根结点的下标为(len−2) / 2

对于向下调整中，以创建**大根堆**为例，**如果一棵子树右结点存在且大于左结点的值，则child++保证child指向的是左右结点中较大的那一个**

![img][img 2]

下面给出的是堆的基本成员属性,

public class MyHeap {
        
        public int[] elem;
        public int usedSize;//记录有效元素个数
        public static final int DEFAULT_SIZE = 10;//默认容量
    
        public MyHeap() {
        
            elem = new int[DEFAULT_SIZE];
        }
    
        //初始化数组
        public void initElem(int[] array) {
        
            for (int i = 0; i < array.length; i++) {
        
                this.elem[i] = array[i];
                usedSize++;
            }
        }
    }

**代码实现创建大根堆**,

//调整数组元素,创建大根堆
        public void createHeap() {
        
            //从最后一个双亲节点开始向下调整
            for (int parent = (this.usedSize-1-1)/2; parent >= 0; parent--) {
        
                //向下调整
                shiftDown(parent, this.usedSize);
            }
        }
    
        /**
         * 向下调整
         * @param parent 每棵树的根节点位置
         * @param len 用来判断每棵子树调整的结束时机, 位置不能大于len
         */
        public void shiftDown(int parent, int len) {
        
            //计算左孩子位置
            int child = parent*2+1;
            //要判断左孩子是否存在
            while(child < len) {
        
                //确定右孩子是否存在,确定最大值
                if (child + 1 < len && elem[child] < elem[child+1]) {
        
                    child++;
                }
                //走到这里child指向的一定是左右孩子中较大的
                if(elem[parent] < elem[child]) {
        
                    int tmp = elem[parent];
                    elem[parent] = elem[child];
                    elem[child] = tmp;
                    parent = child;
                    child = 2*parent+1;
                }else {
        
                    break;
                }
            }
        }

**【建堆的时间复杂度】**

建堆的过程是自下而上的，堆的本质就是一棵完全二叉树，不妨设该二叉树的高度为h，堆元素个数为n，建堆时需要对所有高度大于1的子树进行调整，最坏情况下该堆是一个满堆，设该堆所处层次为x（从1开始），则第x层次的子树需要调整h-x次，有2 ^ (h-1)个结点，由于只调整高度大于1的子树，因此x的范围为\[1,h−1\]

![img][img 3]

调整的次数为T(n):

![img][img 4]

我们发现T(n)为等比数列和减去h再加上1，等比数列求和公式为Sn=a1(1−qn)/(1−q)

T(n)=2∗(1−2h−1)/(−1)−h+1

T(n)=2 ^ h−h−1

![img][img 5]

所以，建堆的时间复杂度为O(N)。

### 4. 元素入堆 ###

按照如下步骤完成元素入堆:

1.  先将元素放入到放入堆尾(注意：空间不够时需要扩容)
2.  将最后新插入的节点向上调整，直到满足堆的性质

下面是对**向上调整的说明**:

在数组最后一个位置放入一个元素后，以大根堆为例, 这个元素所在的子树就可能不满足大根堆的条件了, 所以需要对该结点进行向上调整，让这棵子树再次满足大根堆, 如果做出了调整, 就需要一直先向上调整, 直至满足条件 ; 所谓向上调整就是比较 调整结点与父亲结点 值的大小，如果该结点值比较大，则与父亲结点交换值，否则不需调整，该堆已经满足大根堆条件，因为交换后不知道上面的子树是否为大根堆，所以需要对交换路径上所有的结点进行相同的向上调整，直到调整完堆顶，过程中出现父亲结点比较大则结束调整; 同样的如果是小根堆，思路是一样的, 只需要把把 调整结点与父亲结点 的比较方式改变一下即可.

**下面的实现代码以大根堆为例**:

public void offer(int val) {
        
            //判断空间是不是满了
            if(isFull()) {
        
                elem = Arrays.copyOf(elem, 2*elem.length);
            }
            elem[usedSize] = val;
            usedSize++;
            //向上调整
            shiftUp(usedSize-1);
        }
        public boolean isFull() {
        
            return usedSize == elem.length;
        }
        public void shiftUp(int child) {
        
            int parent = (child-1)/2;
            while(child > 0) {
        
                if (elem[parent] < elem[child]) {
        
                    int tmp = elem[parent];
                    elem[parent] = elem[child];
                    elem[child] = tmp;
                    child = parent;
                    parent = (child-1)/2;
                }else{
        
                    break;
                }
            }
        }

### 5. 元素出堆 ###

**注意**：**出堆的元素一定是堆顶元素**

按照如下步骤完成元素出堆:

1.  将堆顶元素与堆尾元素交换，保存并删除堆尾元素。
2.  将堆中有效数据个数减少一个
3.  对堆顶元素向下调整，因为堆顶交换元素的路径可能会破坏大根堆（或小根堆）结构。
4.  返回之前保存的堆尾元素，返回的是删除元素的值。

**下面的实现代码以大根堆为例**:

//堆的删除
        public int pop() {
        
            if(isEmpty()) {
        
                throw new EmptyHeapException("当前堆为空");
            }
            int tmp = elem[0];
            elem[0] = elem[usedSize-1];
            elem[usedSize-1] = tmp;
            usedSize--;
    
            shiftDown(0, usedSize);
            return tmp;
        }

### 6. 获取堆中元素 ###

//判断堆是否为空
        public boolean isEmpty() {
        
            return usedSize == 0;
        }
    
        //获取堆中元素
        public int peek() {
        
            if(isEmpty()) {
        
                throw new EmptyHeapException();
            }
            return elem[0];
        }
    
        //清空
        public void clear() {
        
            usedSize = 0;
        }
    
        public int size() {
        
            return usedSize;
        }

## 二. 优先级堆列(PriorityQueue) ##

### 1. 优先级队列 ###

在优先级队列中，元素被赋予优先级。当访问元素时，具有最高优先级的元素最先删除。优先队列具有最高级先出 (first in, largest out)的行为特征，通常采用堆数据结构来实现; 比如说一个优先队列是由小根堆实现的，则该队列优先最小的元素出队，反之，优先队列由大根堆实现，则该队列优先最大的元素出队。

### 2. PriorityQueue的特性 ###

![img][img 6]

关于PriorityQueue的使用要注意：

1.  使用时必须导入PriorityQueue所在的包，即： **import java.util.PriorityQueue**;
2.  PriorityQueue中放置的**元素必须要能够比较大小，不能插入无法比较大小的对象，否则会抛出ClassCastException异常**
3.  不能插入**null对象，否则会抛出NullPointerException**
4.  **没有容量限制，可以插入任意多个元素，其内部可以自动扩容**
5.  **插入和删除元素的时间复杂度为O(logN)**
6.  **PriorityQueue底层使用了堆数据结构**
7.  PriorityQueue默认情况下是小堆 , 如果想要改变使用大根堆实现，则需要传入对象的比较器，或比较器内部类或lambda表达式所实现的比较器。

### 3. 集合框架中PriorityQueue的比较方式 ###

集合框架中的PriorityQueue底层使用堆结构，因此其内部的元素必须要能够比较大小，PriorityQueue采用了：  
Comparble和Comparator两种方式。

1.  Comparble是默认的内部比较方式，如果用户插入自定义类型对象时，该类对象必须要实现Comparble接口，并覆写compareTo方法
2.  用户也可以选择使用比较器对象，如果用户插入自定义类型对象时，必须要提供一个比较器类，让该类实现Comparator接口并覆写compare方法。

// JDK中PriorityQueue的实现：
        public class PriorityQueue<E> extends AbstractQueue<E>
                implements java.io.Serializable {
        
            // ...
            // 默认容量
            private static final int DEFAULT_INITIAL_CAPACITY = 11;
            // 内部定义的比较器对象，用来接收用户实例化PriorityQueue对象时提供的比较器对象
            private final Comparator<? super E> comparator;
            // 用户如果没有提供比较器对象，使用默认的内部比较，将comparator置为null
            public PriorityQueue() {
        
                this(DEFAULT_INITIAL_CAPACITY, null);
            }
            // 如果用户提供了比较器，采用用户提供的比较器进行比较
            public PriorityQueue(int initialCapacity, Comparator<? super E> comparator) {
        
            // Note: This restriction of at least one is not actually needed,
            // but continues for 1.5 compatibility
                if (initialCapacity < 1)
                    throw new IllegalArgumentException();
                this.queue = new Object[initialCapacity];
                this.comparator = comparator;
            }
            // ...
            // 向上调整：
            // 如果用户没有提供比较器对象，采用Comparable进行比较
            // 否则使用用户提供的比较器对象进行比较
            private void siftUp(int k, E x) {
        
                if (comparator != null)
                    siftUpUsingComparator(k, x);
                else
                    siftUpComparable(k, x);
            }
            // 使用Comparable
            @SuppressWarnings("unchecked")
            private void siftUpComparable(int k, E x) {
        
                Comparable<? super E> key = (Comparable<? super E>) x;
                while (k > 0) {
        
                    int parent = (k - 1) >>> 1;
                    Object e = queue[parent];
                    if (key.compareTo((E) e) >= 0)
                        break;
                    queue[k] = e;
                    k = parent;
                }
                queue[k] = key;
            }
            // 使用用户提供的比较器对象进行比较
            @SuppressWarnings("unchecked")
            private void siftUpUsingComparator(int k, E x) {
        
                
                while (k > 0) {
        
                    int parent = (k - 1) >>> 1;
                    Object e = queue[parent];
                    if (comparator.compare(x, (E) e) >= 0)
                        break;
                    queue[k] = e;
                    k = parent;
                }
                queue[k] = x;
            }
        }

下面的代码是定义一个的自定义类型, 要将自定义类型入堆, 自定义类型必须实现Comparble接口; 将第一个元素入堆时不涉及比较, 当第二个元素入堆就会涉及比较了;

class Person implements Comparable<Person>{
        
        int age;
        String name;
    
        public Person(int age, String name) {
        
            this.age = age;
            this.name = name;
        }
    
        @Override
        public int compareTo(Person o) {
        
            return this.age - o.age;
        }
    
        @Override
        public String toString() {
        
            return "Person{" +
                    "age=" + age +
                    ", name='" + name + '\'' +
                    '}';
        }
    }
    public class Test {
        
        public static void main(String[] args) {
        
            PriorityQueue<Person> priorityQueue = new PriorityQueue<>();
            priorityQueue.offer(new Person(18,"张三"));
            priorityQueue.offer(new Person(20,"李四"));
        }
    }

### 4. PriorityQueue常用构造方法 ###

<table> 
 <thead> 
  <tr> 
   <th>构造器</th> 
   <th>功能介绍</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>PriorityQueue()</td> 
   <td>创建一个空的优先级队列，默认容量是11</td> 
  </tr> 
  <tr> 
   <td>PriorityQueue(int initialCapacity)</td> 
   <td>创建一个初始容量为initialCapacity的优先级队列，注意： initialCapacity不能小于1，否则会抛IllegalArgumentException异 常</td> 
  </tr> 
  <tr> 
   <td>PriorityQueue(Collection&lt; ? extends E &gt; c)</td> 
   <td>用一个集合来创建优先级队列</td> 
  </tr> 
 </tbody> 
</table>

观察这三个构造方法的源码, 其实在底层是又调用了含有两个参数的构造方法public PriorityQueue(int initialCapacity\*\*,\*\* Comparator<? super **E**> comparator), 除了设置容量的参数外, 另一个参数是一个比较器, 在调用时设置为了null;

![img][img 7]

![img][img 8]

![img][img 9]

![img][img 10]

构造示例:

static void TestPriorityQueue(){
        
           // 创建一个空的优先级队列，底层默认容量是11
            PriorityQueue<Integer> q1 = new PriorityQueue<>();
           // 创建一个空的优先级队列，底层的容量为initialCapacity
            PriorityQueue<Integer> q2 = new PriorityQueue<>(100);
            ArrayList<Integer> list = new ArrayList<>();
            list.add(4);
            list.add(3);
            list.add(2);
            list.add(1);
            // 用ArrayList对象来构造一个优先级队列的对象
            // q3中已经包含了三个元素
            PriorityQueue<Integer> q3 = new PriorityQueue<>(list);
            System.out.println(q3.size());
            System.out.println(q3.peek());
        }

注意：默认情况下，PriorityQueue队列是小堆，如果需要大堆需要用户提供比较器

public static void main(String[] args) {
        
            PriorityQueue<Integer> priorityQueue1 = new PriorityQueue<>(new IntCmp());
            priorityQueue1.offer(1);
            priorityQueue1.offer(2);
            priorityQueue1.offer(3);
            System.out.println(priorityQueue1);
    
            //使用隐藏内部类创建基于大根堆的优先队列
            PriorityQueue<Integer> priorityQueue2 = new PriorityQueue<>(new Comparator<Integer>() {
        
                @Override
                public int compare(Integer o1, Integer o2) {
        
                    return o2 - o1;
                }
            });
            priorityQueue2.offer(1);
            priorityQueue2.offer(2);
            priorityQueue2.offer(3);
            System.out.println(priorityQueue1);
    
            //使用lambda表达式创建基于大根堆的优先队列
            PriorityQueue<Integer> priorityQueue3 = new PriorityQueue<>((x, y) -> y-x);
            priorityQueue3.offer(1);
            priorityQueue3.offer(2);
            priorityQueue3.offer(3);
            System.out.println(priorityQueue1);
        }

### 5. PriorityQueue常用操作方法 ###

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>功能介绍</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>boolean offer(E e)</td> 
   <td>插入元素e，插入成功返回true，如果e对象为空，抛出NullPointerException异常，时 间复杂度 O(logN)，注意：空间不够时候会进行扩容</td> 
  </tr> 
  <tr> 
   <td>E peek()</td> 
   <td>获取优先级最高的元素，如果优先级队列为空，返回null</td> 
  </tr> 
  <tr> 
   <td>E poll()</td> 
   <td>移除优先级最高的元素并返回，如果优先级队列为空，返回null</td> 
  </tr> 
  <tr> 
   <td>int size()</td> 
   <td>获取有效元素的个数</td> 
  </tr> 
  <tr> 
   <td>void clear()</td> 
   <td>清空</td> 
  </tr> 
  <tr> 
   <td>boolean isEmpty()</td> 
   <td>检测优先级队列是否为空，空返回true</td> 
  </tr> 
 </tbody> 
</table>

static void TestPriorityQueue2(){
        
            int[] arr = {
        4,1,9,2,8,0,7,3,6,5};
            // 一般在创建优先级队列对象时，如果知道元素个数，建议就直接将底层容量给好
            // 否则在插入时需要不够时要去扩容
            // 扩容机制：开辟更大的空间，拷贝元素，这样效率会比较低
            PriorityQueue<Integer> q = new PriorityQueue<>(arr.length);
            for (int e: arr) {
        
                q.offer(e);
            }
            System.out.println(q.size()); // 打印优先级队列中有效元素个数
            System.out.println(q.peek()); // 获取优先级最高的元素
            // 从优先级队列中删除两个元素之和，再次获取优先级最高的元素
            q.poll();
            q.poll();
            System.out.println(q.size()); // 打印优先级队列中有效元素个数
            System.out.println(q.peek()); // 获取优先级最高的元素
            q.offer(0);
            System.out.println(q.peek()); // 获取优先级最高的元素
            // 将优先级队列中的有效元素删除掉，检测其是否为空
            q.clear();
            if(q.isEmpty()){
        
                System.out.println("优先级队列已经为空!!!");
            }
            else{
        
                System.out.println("优先级队列不为空");
            }
        }

### 6. PriorityQueue的扩容方式 ###

*  如果容量小于64时，是按照oldCapacity的2倍方式扩容的
 *  如果容量大于等于64，是按照oldCapacity的1.5倍方式扩容的
 *  如果容量超过MAX\_ARRAY\_SIZE，按照Integer.MAX\_VALUE大小来进行扩容

以下是JDK 1.8中，PriorityQueue的扩容方式：

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
        private void grow(int minCapacity) {
        
            int oldCapacity = queue.length;
            // Double size if small; else grow by 50%
            int newCapacity = oldCapacity + ((oldCapacity < 64) ?
                    (oldCapacity + 2) :
                    (oldCapacity >> 1));
            // overflow-conscious code
            if (newCapacity - MAX_ARRAY_SIZE > 0)
                newCapacity = hugeCapacity(minCapacity);
            queue = Arrays.copyOf(queue, newCapacity);
        }
        private static int hugeCapacity(int minCapacity) {
        
            if (minCapacity < 0) // overflow
                throw new OutOfMemoryError();
            return (minCapacity > MAX_ARRAY_SIZE) ?
                    Integer.MAX_VALUE :
                    MAX_ARRAY_SIZE;
        }

## 三. Top-k问题 ##

TOP-K问题：即求数据集合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。  
比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。

*  **思路1**:

要处理这个问题, 我们能想到的最简单的方式就是排序, 但是如果数据量非常大的话, 就不推荐使用排序了, 因为我们只要拿到几个元素, 数据量很大时使用排序效率就比较低了;

*  **思路2**:

使用堆，如求的是前k个最大的元素，可以创建一个基于大根堆的优先级队列，把所有数据入堆，所有元素都入堆之后再出堆k个元素，这k个元素就是前k个最大的元素。

*  **思路3**:

上面的两种思路有一个缺陷就是, 如果数据量非常大的话, 效率就会很低下; Top-k问题标准解决思路如下:

1.  用数据集合中前K个元素来建堆

*  如果找的是前k个最大的元素，去建小堆  
    如果找的是前k个最小的元素，去建大堆

1.  用剩余的N-K个元素依次与堆顶元素来比较，

*  求的是前k个最大元素, 如果比所建小根堆的堆顶元素大, 则替换堆顶元素  
    求的是前k个最小元素, 如果比所建大根堆的堆顶元素大, 则替换堆顶元素
 *  将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

**时间复杂度分析**

**向上调整建堆的时间复杂度:**

![img][img 11]

![img][img 12]

**\[思路2时间复杂度分析\]**:

要将N个元素都放入到堆中, 每次入堆都需要向上调整(N\*logN);

堆建好后, 将k个元素出堆, 每次出堆都需要向下调整(K\*logN)

所以时间复杂度为O(N*logN+K*logN)

**\[思路3时间复杂度分析\]**:

建立大小为k的大/小根堆(K\*logK)

遍历剩下的N-K个元素每个都和堆顶比较, 最坏的情况下, 每次都需要去调整((N-K)\*logK)

所以时间复杂度为O( K\*logK+(N-K)*logK ) = O(N*logK)

*  **通过下面的OJ去理解Top-k问题**

**在线OJ：**[面试题 17.14. 最小K个数][17.14. _K]

设计一个算法，找出数组中最小的k个数。以任意顺序返回这k个数均可。

**示例**：

输入： arr = [1,3,5,7,2,4,6,8], k = 4
    输出： [1,2,3,4]

**提示**：

*  0 <= len(arr) <= 100000
 *  0 <= k <= min(100000, len(arr))

class Solution {
        
        //方法三: 建立一个大小为k的大根堆
        public int[] smallestK(int[] arr, int k) {
        
            if(arr == null || k <= 0) {
        
                return new int[0];
            }
            PriorityQueue<Integer> maxHeap = new PriorityQueue<>(new Comparator<Integer>(){
        
                @Override
                public int compare(Integer o1, Integer o2) {
        
                    return o2.compareTo(o1);
                }
            });
    
            for (int i = 0; i < k; i++) {
        
                maxHeap.offer(arr[i]);
            }
    
            for (int i = k; i < arr.length; i++) {
        
                if(arr[i] < maxHeap.peek()) {
        
                    maxHeap.poll();
                    maxHeap.offer(arr[i]);
                }
            }
            int[] tmp = new int[k];
            for (int i = 0; i < k; i++) {
        
                tmp[i] = maxHeap.poll();
            }
            return tmp;
        }
    
        //方法二: 将数据全部入堆
        /*public int[] smallestK(int[] arr, int k) {
            PriorityQueue<Integer> heap = new PriorityQueue<>();
            for (int i = 0; i < arr.length; i++) {
                heap.offer(arr[i]);
            }
    
            int[] tmp = new int[k];
            for (int i = 0; i < k; i++) {
                tmp[i] = heap.poll();
            }
            return tmp;
        }*/
    
        //方法一: 排序
        /*public int[] smallestK(int[] arr, int k) {
            Arrays.sort(arr);
            int[] tmp = new int[k];
            for(int i = 0; i < k; i++) {
                tmp[i] = arr[i];
            }
            return tmp;
        }*/
    }

[3f9026f5c260455c8ecd6dfef03f83ed.gif_pic_center]: https://img-blog.csdnimg.cn/3f9026f5c260455c8ecd6dfef03f83ed.gif#pic_center
[Link 1]: https://blog.csdn.net/Trong_?spm=1000.2115.3001.5343
[Java]: https://blog.csdn.net/trong_/category_11997769.html
[img]: https://img-blog.csdnimg.cn/img_convert/6199b85748679827cd586b37538eded8.png
[img 1]: https://img-blog.csdnimg.cn/img_convert/37d9b06f5aebd9d1a5ad727cf4e3009f.png
[img 2]: https://img-blog.csdnimg.cn/img_convert/0dfcd357399a2508ae74df976a4d71e0.png
[img 3]: https://img-blog.csdnimg.cn/img_convert/e1f067489afe31f92dc6d9feadc4fdd2.png
[img 4]: https://img-blog.csdnimg.cn/img_convert/acafdef22db9d27fe4312e2166b61b5e.png
[img 5]: https://img-blog.csdnimg.cn/img_convert/d4a747a4bb179e10597e9611462d82e1.png
[img 6]: https://img-blog.csdnimg.cn/img_convert/fa0984a62cf5700515f583b0e9c08821.png
[img 7]: https://img-blog.csdnimg.cn/img_convert/7e802eaa6b5411003c948b3397c4f380.png
[img 8]: https://img-blog.csdnimg.cn/img_convert/d33c3de1893f6ede275bac496ba2d047.png
[img 9]: https://img-blog.csdnimg.cn/img_convert/89d0ebe406af44a29de8672a7a4642d1.png
[img 10]: https://img-blog.csdnimg.cn/img_convert/ecac2cd9849181bd4a80ee60f9cabe3a.png
[img 11]: https://img-blog.csdnimg.cn/img_convert/5988346dce2cc9ff7e7031f9d4e18199.png
[img 12]: https://img-blog.csdnimg.cn/img_convert/e4adc9dad1b99456e690130d73f255c5.png
[17.14. _K]: https://leetcode-cn.com/problems/same-tree/