高级数据结构之堆树

野心与梦

于 2023-04-16 00:38:59 发布

阅读量1w

点赞数 1

分类专栏：数据结构与算法文章标签：数据结构算法 java

本文链接：https://blog.csdn.net/weixin_45690643/article/details/130177793

版权

数据结构与算法专栏收录该内容

14 篇文章 0 订阅

订阅专栏

堆树

堆的定义

堆是什么？堆是一种特殊的树，他需要满足以下两点：

是一颗完全二叉树：除了最后一层，其他层每个节点都是满的且最后一层的节点都要靠左排列
其每一个节点的值都大于等于或者小于等于其左右子节点的值

堆实现思路

堆树如何来存储？

完全二叉树的最佳存储结构就是数组。因为它有着特殊的属性，直接利用下标就可以表示左右节点

左右子节点的公式：左=2i 、右=2i+1，i为数组下标
如果下标从0开始开始，这两个公式：2i+1,2i+2

堆的插入操作：

两种插入方式，头插法和尾插法，插入后可能不满足堆特性，调整过程称为堆化
头插法，从上往下堆化；尾插法：从下往上堆化
举例演示尾插法：从下往上堆化过程：
插入22

从下往上堆化

堆顶删除操作

其实就是把堆顶拿掉，然后进行堆化，怎么删除呢？
思路1：将数组第一个元素删除，整体迁移一位，然后堆化；
思路2：头尾交换，尾部位置指向null回收，然后堆化
对比：思路1需数组迁移复制，消耗大，思路2只需头尾交换

堆排序

假设给你一个序列：8 4 20 7 3 1 25 14 17，利用堆树进行排序

先按照序列顺序存储在完全二叉树中，然后堆化

堆化.png

头尾交换，保留尾节点数据，然后堆化

跟堆顶的删除操作类似

堆的应用

在前边实现赫夫曼树，我使用了一个优先队列大大减轻了我们的开发任务，但是大家知道这个优先队列内部是如何实现的呢？
如何实现一个用户热门搜索排行榜功能（微博热搜）？给你一个包含1亿关键词的用户检索的日志，如何取出排行前10的关键词。给你的处理机器：2CPU 2G内存一台

Map分治+堆树

统计出现的频率Hash
维护一个大小为10的大顶堆
时间复杂度
空间复杂度。有可能内存爆炸，因为数据太多，放到硬盘
放到硬盘：分治，分成很多份。1亿个我分成 10个文件。分布式，分库分表。我要知道我的数据在哪张表，hash%分表数Hash%10=当前这个词放在哪个文件。分成了10个文件后：分别求top10，然后再把这个top10合起来。也就是有100个数，再求一次

优先级队列
TOP K问题，比如给你一串1000万的数字求前k大的数

一种是静态的数据
一种是动态的的数据

定时任务
给你1亿个不重复的数字（整数，1~2^32-1），求出top10。前10大的数字，还可动态添加新数字，但总个数不会超过1亿

实现优先队列

优先队列性质

offer操作添加元素构建堆
poll操作获取堆头并删除，然后堆化
peek操作取堆头不删除

offer操作

// 添加一个元素
public boolean offer(E e) {
    if (size == 0) queue[size++] = e;
    else {
        queue[size] = e;
        bottomUpHeap(size, e);
        //minHeap((E[]) queue, 0, size - 1);
        size++;
        grow(queue); // 扩容
    }
    return true;
}

自下而上堆化

/**
 * 从下往上堆化， 时间复杂度：o(lgn)
 * @param k 插入位置
 * @param x 插入元素
 */
private void bottomUpHeap(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;
}

自上而下堆化

注意：经测试该段代码处理不了两个元素的堆化，poll删除操作有两个元素的处理逻辑

/**
 * 自上而下堆化，时间复杂度：o(lgn)
 * @param data  数据
 * @param start 起始位置
 * @param end   结束位置，主要用于堆排序
 */
private void upBottomHeap(E[] data, int start, int end) {
    int p = start;         // 父节点
    int l = start * 2 + 1; // 左节点
    int r = start * 2 + 2; // 右节点
    while (l < end) {
        // 满二叉树，没有最后一个右节点
        if (r >= end && comparator.compare(data[p], data[l]) < 0) break;
        if (r < end && // 满二叉树，有最后一个右节点.父节点 大于两个子节点 无需交换位置
            comparator.compare(data[p], data[l]) < 0 &&
            comparator.compare(data[p], data[r]) < 0) return; // 不用交换
        // 比较子节点，小的一个和父节点交换位置
        int swapIndex = r;
        if (r < end && comparator.compare(data[l], data[r]) < 0) { // 左边比右边小
            swapIndex = l; // 就要换右节点跟父节点
        }
        // 交换
        swap(data, p, swapIndex);
        // 循环模拟递归，记录下次递归位置
        p = swapIndex; // 继续堆化
        l = p * 2 + 1;
        r = p * 2 + 2;
    }
}

poll操作

public E poll() {
    if (size == 0) return null;
    E e = (E) queue[0];
    removeTailHeap(); // 头尾交换，堆化
    // removeHeadHeap(); // 删除头节点堆化
    return e;
}

removeTailHeap(); // 头尾交换，堆化

private void removeTailHeap() {
    // 交换头尾，然后堆化
    swap((E[]) queue, 0, --size);
    //queue[size]=null; // 回收数据，不回收就是堆排序
    upBottomHeap((E[]) queue, 0, size - 1);
    // 处理还有两个元素的特殊情况
    if (size == 2 && comparator.compare((E) queue[0], (E) queue[1]) > 0) {
        swap((E[]) queue, 0, 1);
    }
}

removeHeadHeap(); // 删除头节点堆化

private void removeHeadHeap() {
    queue = Arrays.copyOfRange(queue, 1, queue.length);
    upBottomHeap((E[]) queue, 0, --size);
}

完整代码

package datastructure.queue;

import java.util.AbstractQueue;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Iterator;

/**
 * 优先队列
 *
 * @author zw
 * @create 2023-04-14 23:21
 */
public class MyPriorityQueue<E> extends AbstractQueue<E> {

    private final double DILATANCY_FACTOR = 0.75d;
    private final Comparator<? super E> comparator; // 比较器决定是大顶堆还是小顶堆
    transient Object[] queue;
    private int size = 0;

    public MyPriorityQueue(Comparator<? super E> comparator) {
        this.queue = new Object[16];
        this.comparator = comparator;
    }

    @Override
    public Iterator<E> iterator() {
        return null;
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }


    // 添加一个元素
    @Override
    public boolean offer(E e) {
        if (size == 0) queue[size++] = e;
        else {
            queue[size] = e;
            bottomUpHeap(size, e);
            //upBottomHeap((E[]) queue, 0, size - 1);
            size++;
            grow(queue);
        }
        return true;
    }

    private void grow(Object[] data) {
        if (size > queue.length * DILATANCY_FACTOR) {
            // 扩容，会把size*2
            int newSize = size << 1 + 1;
            queue = Arrays.copyOf(data, newSize);
        }
    }

    private void swap(E[] data, int p1, int p2) {
        E temp = data[p1];
        data[p1] = data[p2];
        data[p2] = temp;
    }

    // 移除并返问队列头部的元素

    /**
     * 两种方式：
     * 1、头尾交换，删除尾节点，堆化
     * 2、删除头节点，然后堆化
     *
     * @return
     */
    @Override
    public E poll() {
        if (size == 0) return null;
        E e = (E) queue[0];
        //System.out.println(String.format("取出%s,堆化前%s", e, Arrays.toString(queue)));
        removeTailHeap();
        //System.out.println(String.format("取出%s,堆化后%s", e, Arrays.toString(queue)));
        return e;
    }

    /**
     * 这种方式要删除位置，但是思路简单
     */
    private void removeHeadHeap() {
        queue = Arrays.copyOfRange(queue, 1, queue.length);
        upBottomHeap((E[]) queue, 0, --size);
    }

    /**
     * 这种方式位置保留
     */
    private void removeTailHeap() {
        // 交换头尾，然后堆化
        swap((E[]) queue, 0, --size);
        //queue[size]=null; // 回收数据，是否注释，打印结果有不同理解
        //System.out.println(String.format("头尾交换%s", Arrays.toString(queue)));
        upBottomHeap((E[]) queue, 0, size - 1);
        if (size == 2 && comparator.compare((E) queue[0], (E) queue[1]) > 0) {
            swap((E[]) queue, 0, 1);
        }
    }

    // 返回队列头部的元素
    @Override
    public E peek() {
        if (size == 0) return null;
        size--;
        return (E) queue[0];
    }


    /**
     * 插入过程堆化:从下往上，交换，直到根
     *
     * @param k 插入位置
     * @param x 插入元素
     */
    private void bottomUpHeap(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;
    }

    /**
     * 小顶堆化
     *
     * @param data  数据
     * @param start 起始位置
     * @param end   结束位置，主要用于堆排序
     */
    private void upBottomHeap(E[] data, int start, int end) {
        int p = start;         // 父节点
        int l = start * 2 + 1; // 左节点
        int r = start * 2 + 2; // 右节点
        while (l < end) {
            // 满二叉树，没有最后一个右节点
            if (r >= end && comparator.compare(data[p], data[l]) < 0) break;
            if (r < end && // 满二叉树，有最后一个右节点.父节点 大于两个子节点 无需交换位置
                comparator.compare(data[p], data[l]) < 0 &&
                comparator.compare(data[p], data[r]) < 0) return; // 不用交换
            // 比较子节点，小的一个和父节点交换位置
            int swapIndex = r;
            if (r < end && comparator.compare(data[l], data[r]) < 0) { // 左边比右边小
                swapIndex = l; // 就要换右节点跟父节点
            }
            // 交换
            swap(data, p, swapIndex);
            // 循环模拟递归，记录下次递归位置
            p = swapIndex; // 继续堆化
            l = p * 2 + 1;
            r = p * 2 + 2;
        }
    }

    // 堆排序
    private void upBottomHeap(E[] data) {
        int len = data.length;
        for (int i = len / 2 - 1; i >= 0; i--) { //o(nlgn)
            maxHeap(data, i, len);        //
        }
        for (int i = len - 1; i > 0; i--) { //o(nlgn)
            swap(data, 0, i);
            upBottomHeap(data, 0, i);    //这个i能不能理解？因为len~i已经排好序了
        }
    }

}

测试用例

public static void main(String[] args) {
    MyPriorityQueue<Integer> queue = new MyPriorityQueue<>((o1, o2) -> o1 - o2);
    Integer[] datas = {8, 4, 20, 7, 3, 1, 25, 14, 17};
    System.out.println("输入：" + Arrays.toString(datas));
    queue.heapSort(datas);
    System.out.println("堆排序结果：" + Arrays.toString(datas));
    Integer[] datas2 = {8, 4, 20, 7, 3, 1, 25, 14, 17};
    for (int data : datas2) {
        queue.offer(data);
        System.out.println(String.format("插入%s,堆化后%s", data, Arrays.toString(queue.queue)));
    }
    System.out.println("---------------------");
    while (!queue.isEmpty()) {
        Integer poll = queue.poll();
        System.out.println(String.format("取出%s,size=%s,堆化后%s", poll, queue.size, Arrays.toString(queue.queue)));
    }

}

运行结果

输入：[8, 4, 20, 7, 3, 1, 25, 14, 17]
堆排序结果：[25, 20, 17, 14, 8, 7, 4, 3, 1]
插入8,堆化后[8, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null]
插入4,堆化后[4, 8, null, null, null, null, null, null, null, null, null, null, null, null, null, null]
插入20,堆化后[4, 8, 20, null, null, null, null, null, null, null, null, null, null, null, null, null]
插入7,堆化后[4, 7, 20, 8, null, null, null, null, null, null, null, null, null, null, null, null]
插入3,堆化后[3, 4, 20, 8, 7, null, null, null, null, null, null, null, null, null, null, null]
插入1,堆化后[1, 4, 3, 8, 7, 20, null, null, null, null, null, null, null, null, null, null]
插入25,堆化后[1, 4, 3, 8, 7, 20, 25, null, null, null, null, null, null, null, null, null]
插入14,堆化后[1, 4, 3, 8, 7, 20, 25, 14, null, null, null, null, null, null, null, null]
插入17,堆化后[1, 4, 3, 8, 7, 20, 25, 14, 17, null, null, null, null, null, null, null]
---------------------
取出1,size=8,堆化后[3, 4, 17, 8, 7, 20, 25, 14, 1, null, null, null, null, null, null, null]
取出3,size=7,堆化后[4, 7, 17, 8, 14, 20, 25, 3, 1, null, null, null, null, null, null, null]
取出4,size=6,堆化后[7, 8, 17, 25, 14, 20, 4, 3, 1, null, null, null, null, null, null, null]
取出7,size=5,堆化后[8, 20, 17, 25, 14, 7, 4, 3, 1, null, null, null, null, null, null, null]
取出8,size=4,堆化后[14, 20, 17, 25, 8, 7, 4, 3, 1, null, null, null, null, null, null, null]
取出14,size=3,堆化后[17, 20, 25, 14, 8, 7, 4, 3, 1, null, null, null, null, null, null, null]
取出17,size=2,堆化后[20, 25, 17, 14, 8, 7, 4, 3, 1, null, null, null, null, null, null, null]
取出20,size=1,堆化后[25, 20, 17, 14, 8, 7, 4, 3, 1, null, null, null, null, null, null, null]
取出25,size=0,堆化后[25, 20, 17, 14, 8, 7, 4, 3, 1, null, null, null, null, null, null, null]

实现top k问题

实际问题抽象画：TOP K问题，比如给你一串1000万的数字求前k大的数，两种情况

一种是静态的数据
一种是动态的的数据

给你1亿个不重复的数字（整数，1~2^32-1），求出top10。前10大的数字，还可动态添加新数字，但总个数不会超过1亿
如何实现一个用户热门搜索排行榜功能（微博热搜）？给你一个包含1亿关键词的用户检索的日志，如何取出排行前10的关键词。给你的处理机器：2CPU 2G内存一台

Map分治+堆树

统计出现的频率Hash
维护一个大小为10的大顶堆
时间复杂度
空间复杂度。有可能内存爆炸，因为数据太多，放到硬盘
放到硬盘：分治，分成很多份。1亿个我分成 10个文件。分布式，分库分表。我要知道我的数据在哪张表，hash%分表数Hash%10=当前这个词放在哪个文件。分成了10个文件后：分别求top10，然后再把这个top10合起来。也就是有100个数，再求一次

package leetcode;

import datastructure.queue.MyPriorityQueue;

import java.io.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 如何实现一个用户热门搜索排行榜功能（微博热搜）？给你一个包含1亿关键词的用户检索的日志，如何取出排行前10的关键词,还可动态添加新数字。
 * 给你的处理机器：2CPU 2G内存 一台
 *
 * @author zw
 * @create 2023-04-15 23:18
 */
public class TopK {

    private List<String> fileSegments = new ArrayList<>();

    /**
     * 统计词频
     *
     * @param filePath
     * @return
     * @throws Exception
     */
    private Map<String, Integer> wordCount(String filePath) throws Exception {
        Map<String, Integer> wordCountMap = new HashMap<>();
        InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath), "UTF-8");
        BufferedReader br = new BufferedReader(isr);
        String str = null;
        while ((str = br.readLine()) != null) {
            String word = String.valueOf(str);
            if (wordCountMap.containsKey(word)) {
                wordCountMap.put(word, wordCountMap.get(word) + 1);
            } else {
                wordCountMap.put(word, 1);
            }
        }
        return wordCountMap;
    }

    /**
     * 数据文件分片
     *
     * @param filePath 文件路径
     * @param num      分段数
     */
    private void fileSegment(String filePath, int num) throws Exception {
        File file = new File(filePath);
        String name = file.getName().split(".")[0];
        String suffix = file.getName().split(".")[1];

        InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath), "UTF-8");
        BufferedReader br = new BufferedReader(isr);
        String str = null;
        while ((str = br.readLine()) != null) {
            String word = String.valueOf(str);
            int segment = word.hashCode() % num;
            // 写到分片文件中
            String segmentFilePath = file.getParent() + "/" + name + "_" + segment + "." + suffix;
            writeSegmentFile(word, segmentFilePath);
        }
    }

    private void writeSegmentFile(String word, String segmentFilePath) throws Exception {
        File writeFile = new File(segmentFilePath);
        if (!writeFile.exists()) {
            //  // 文件不存在，创建
            writeFile.createNewFile();
            fileSegments.add(segmentFilePath);
        }
        // 写入文件末尾行
        BufferedWriter writer = new BufferedWriter(new FileWriter(writeFile));
        writer.write(word);
        writer.newLine();
    }

    public static void main(String[] args) throws Exception {
        MyPriorityQueue<Map.Entry<String, Integer>> priorityQueue =
                new MyPriorityQueue<Map.Entry<String, Integer>>(10, (o1, o2) -> o1.getValue() - o2.getValue());
        TopK topK = new TopK();
        // 数据分片
        topK.fileSegment("E:\\userhost.txt", 10);
        // 统计每个分段top k
        for (String fileSegment : topK.fileSegments) {
            MyPriorityQueue<Map.Entry<String, Integer>> segmentPriorityQueue =
                    new MyPriorityQueue<Map.Entry<String, Integer>>(10, (o1, o2) -> o1.getValue() - o2.getValue());
            Map<String, Integer> wordCountMap = topK.wordCount(fileSegment);
            for (Map.Entry<String, Integer> entry : wordCountMap.entrySet()) {
                segmentPriorityQueue.offer(entry);
            }
            while (!segmentPriorityQueue.isEmpty()) {
                priorityQueue.offer(segmentPriorityQueue.poll());
            }


        }

        while (!priorityQueue.isEmpty()) {
            Map.Entry<String, Integer> poll = priorityQueue.poll();
            System.out.println(String.format("关键字=%s,词频=%s", poll.getKey(), poll.getValue()));
        }

    }
}