TopK算法总结

1.topK总结https://mp.weixin.qq.com/s/FFsvWXiaZK96PtUg-mmtEw

2.优先级队列求解topK

import java.util.PriorityQueue;

public class TopK {
    public static void main(String[] args) {
//增加删除为offer, poll
        PriorityQueue<ListNode> queue=new PriorityQueue<>((a,b)->a.val-b.val);//(a,b)->a.val-b.val 比较器
        
        ListNode a1 = new ListNode(1);
        ListNode a2 = new ListNode(2);
        ListNode a3 = new ListNode(3);
        ListNode a4 = new ListNode(4);

        queue.offer(a1);
        queue.offer(a2);
        queue.offer(a3);
        queue.offer(a4);
        while (!queue.isEmpty()){
            System.out.print(queue.poll().val+"\t");
        }
    }
}
class ListNode {
int val;
ListNode next;
     ListNode(int x) { val = x; }
 }

3. 合并 k 个排序链表，返回合并后的排序链表。

    /**
     * Definition for singly-linked list.
     * public class ListNode {
     *     int val;
     *     ListNode next;
     *     ListNode(int x) { val = x; }
     * }
     */
    class Solution {
        //思路是 优先队列(小顶堆) 遍历

        //遇到的坑!!!K个节点，每个节点都有可能是空！！！也就是说虽然lists数有长度，但是可能很多个元素都是null
        public ListNode mergeKLists(ListNode[] lists) {
            PriorityQueue<ListNode> queue = new PriorityQueue<>((a,b)->a.val-b.val);//声明
            for(int i=0;i<lists.length;i++){
                if(lists[i]!=null){
                    queue.add(lists[i]);
                }
            }
            if(queue.isEmpty()){
                return null;
            }
            ListNode temp = new ListNode(queue.peek().val);
            ListNode head = temp;
            while(!queue.isEmpty()){
                ListNode p = queue.poll();
                temp.next = p;
                temp = temp.next;
                if(p.next!=null){
                    queue.offer(p.next);
                }
            }
            return head.next;
        }
    }

3.采用堆的方法求解topK

/**
 *O(n*logk)
 * n个数中取最小
 * 采用最大堆
 * 这样做的话明显建堆和调堆都比较好
 */
class MaxHeap {
    // 堆的存储结构 - 数组，father=data[2 * i],left=data[2 * i +1], right=data[2 * i + 2]
    private int[] data;

    /**
     * 将一个数组传入构造方法，并转换成一个小根堆
     *
     * @param data
     */
    public MaxHeap(int[] data) {
        this.data = data;
        buildMaxHeap();
    }

    /**
     * 将数组转换成最大堆
     * 数组中，父节点对应的位置是i*2，左子节点对应的是i * 2 + 1， 右子节点对应的是i * 2 + 2
     */
    private void buildMaxHeap() {
        // 完全二叉树只有数组下标小于或等于 (data.length) / 2 - 1 的元素有孩子结点，遍历这些结点。
        // 比如{0， 1， 2， 3， 4}，(data.length) / 2 - 1 = 1，其左右子节点是3和4，而2,3,4没有子节点
        for (int i = (data.length) / 2 - 1; i >= 0; i--) {
            // 对有子结点的元素heapify
            heapify(i);
        }
    }

    /**
     * 调整节点i及其子节点的位置以符合最大堆的要求，即root是最大值
     * 如果是求数组最大的K个数，则使用最小堆，即左右子节点比root大的调换位置即可
     *
     * @param i
     */
    private void heapify(int i) {
        // 获取左右结点的数组下标 (i + 1) << 1 = 2 * i + 2
        int left = ((i + 1) << 1) - 1;
        int right = (i + 1) << 1;

        // 这是一个临时变量，表示 跟结点、左结点、右结点中最大的值的结点的下标
        int largest = i;

        // 存在左结点，且左结点的值大于根结点的值
        if (left < data.length && data[left] > data[largest]) {
            largest = left;
        }

        // 存在右结点，且右结点的值大于以上比较的较大值
        if (right < data.length && data[right] > data[largest]) {
            largest = right;
        }

        // 左右结点的值都小于根节点，直接return，不做任何操作
        if (i == largest) {
            return;
        }

        // 交换根节点和左右结点中最大的那个值，把根节点的值替换下去
        swap(i, largest);

        // 由于替换后左右子树会被影响，所以要对受影响的子树再进行heapify
        heapify(largest);
    }

    /**
     * 交换元素位置
     *
     * @param i
     * @param j
     */
    private void swap(int i, int j) {
        int tmp = data[i];
        data[i] = data[j];
        data[j] = tmp;
    }

    /**
     * 获取对中的最小的元素，根元素
     *
     * @return
     */
    public int getRoot() {
        return data[0];
    }

    /**
     * 替换根元素，并重新heapify
     *
     * @param root
     */
    public void setRoot(int root) {
        data[0] = root;
        heapify(0);
    }
}
public class TopKByHeapSort {
    public static int[] findLeastK(int[] array, int k) {
        if (array == null || array.length == 0 || k <= 0) {
            return null;
        }
        int[] result = new int[k];
        // 先取出数组的前K个元素来构造最大堆
        for (int i = 0; i < k; i++) {
            result[i] = array[i];
        }
        MaxHeap maxHeap = new MaxHeap(result);
        // 遍历数组其余的元素并替换最大堆的root
        for (int i = k; i < array.length; i++) {
            int max = maxHeap.getRoot();
            if (array[i] < max) {
                maxHeap.setRoot(array[i]);
            }
        }
        return result;
    }

    public static void main(String[] args) {
        int[] array = {4, 5, 1, 6, 2, 7, 3, 8,23,1231,5134};
        int[] result = findLeastK(array, 4);
        for (int i : result) {
            System.out.print(i + " ");
        }
    }
}