二叉树与堆

二叉树有哪几种存储方式？哪种适合于用数组来存储？
node
数组存储？

两种特殊二叉树
满二叉树：除了叶子节点之外，每个节点都有左右两个子节点
完全二叉树：叶子节点都在最底下两层，最后一层的叶子节点都靠左排列，并且除了最后一层，其他层的节点个数都要达到最大

节点的高度：节点到叶子节点的最长路径
节点的深度：根节点到这个节点的边的个数，从0开始
节点的层数：节点的深度加1，从1开始
树的高度：根节点的高度

树结构的存储：
1）链式存储法：节点=数据+左节点指针+右节点指针
2）数组存储法：
如果是完全二叉树：根节点存储在下标为1，那左子节点存储在下标 2 * i = 2 的位置，右子节点存储在 2 * i + 1 = 3 的位置。
如果节点 X 存储在数组中下标为 i 的位置，下标为 2 * i 的位置存储的就是左子节点，下标为 2 * i + 1 的位置存储的就是右子节点。反过来，下标为 i/2 的位置存储就是它的父节点。通过这种方式，我们只要知道根节点存储的位置（一般情况下，为了方便计算子节点，根节点会存储在下标为 1 的位置），这样就可以通过下标计算，把整棵树都串起来。

二叉树的遍历：
前序遍历
中序遍历
后序遍历

二叉查找树：
任意一个节点，其左子树中的每个节点的值，都要小于这个节点的值，而右子树节点的值都大于这个节点的值
查找：类似二分查找
插入：也是先查找，然后一般放入叶子节点
删除：没有子节点，父节点指向节点的指针置空即可；只有一个子节点，只要将父节点的指向被删除数据的指针指向子节点即可；
有两个子节点，那就用右子树的最小节点替换被删除节点；并且删除该最小节点。

带有重复值的二叉查找树
存储方案：
1）每个节点存储链表，相同值的放到一起
2）将相同的值当做比当前值大的数据来处理，放到右侧子节点中，
查找：找到与当前节点相同的值时并不停止，一直查询
删除：找到与当前节点相同的值时并不停止，继续删除

二叉查找树可能退化成链表，所以出现了：
平衡二叉树

有了散列表 为什么还需要二叉查找树？
1）散列表无序且不保存真实的范围值，查询范围值无法处理
2）散列表需要定时扩容，不稳定
3）散列表较为复杂，需要解决散列冲突、扩容等问题
4）负载因子不能过大，会浪费空间

平衡二叉树的严格定义是这样的：二叉树中任意一个节点的左右子树的高度相差不能大于 1。

但是平衡二叉树的要求有点太高了，本质上只要树的高度不必log2n大很多就可以，所以引出红黑树。

红黑树中的节点，一类被标记为黑色，一类被标记为红色。除此之外，一棵红黑树还需要满足这样几个要求：
根节点是黑色的；
每个叶子节点都是黑色的空节点（NIL），也就是说，叶子节点不存储数据；
任何相邻的节点都不能同时为红色，也就是说，红色节点是被黑色节点隔开的
每个节点，从该节点到达其可达叶子节点的所有路径，都包含相同数目的黑色节点；

根黑 叶黑空 红不连 节点到叶的黑路径跟相同

学习数据结构和算法，要学习它的由来、特性、适用的场景以及它能解决的问题。对于红黑树，也不例外。
红黑树是一种平衡二叉查找树。它是为了解决普通二叉查找树在数据更新的过程中，复杂度退化的问题而产生的。
红黑树的高度近似 log2n，所以它是近似平衡，插入、删除、查找操作的时间复杂度都是 O(logn)。
因为红黑树是一种性能非常稳定的二叉查找树，所以，在工程中，但凡是用到动态插入、删除、查找数据的场景，都可以用到它。不过，它实现起来比较复杂，如果自己写代码实现，难度会有些高，这个时候，我们其实更倾向用跳表来替代它。

编程求二叉树准确高度？
遍历所有节点获取高度？
第一种是深度优先思想的递归，分别求左右子树的高度。当前节点的高度就是左右子树中较大的那个+1；
第二种可以采用层次遍历的方式，每一层记录都记录下当前队列的长度，这个是队尾，每一层队头从0开始。然后每遍历一个元素，队头下标+1。直到队头下标等于队尾下标。这个时候表示当前层遍历完成。每一层刚开始遍历的时候，树的高度+1。最后队列为空，就能得到树的高度。

二叉查找树中查、增、删节点

递归树求解归并算法的时间复杂度
归并排序  树的结构是满二叉树，假设n个数据，高度是log2n，每一层的时间都花在归并上，归并的数量一样，所以都记为n，那整体的时间复杂度就是O(nlogn)

递归树求斐波那契数列的时间复杂度
f(n) = f(n-1) + f(n-2);
f(1)=1;
f(2)=2;

每层的节点个数，2的n次幂减一，每一层都需要相加，
假设每次减1，最长路径为n 总和 2的n次方-1；
假设每次减2，最长路径为n/2;  2的n/2次方-1；

练习 ：
前中后遍历代码
非递归实现前序？
层级遍历？

利用先序与中序结果构造二叉树？
先序第一个是根节点，然后从中序定位根位置，该位置左为左子树，该位置右为右子树
递归调用；
结束条件为：先序结果为 null，一个节点直接返回root；

二叉树最大与最小深度？f(n) = max(f(n.l),f(n.r)) + 1;
路径总和等于特定值？
节点空，fasle
节点无子节点且sum==value true
否则递归 ： f(n,sum) = f(n.l,sum-valeu) || f(n.r,sum-valeu)

1 2 3 4 5 一种有多少种二叉树？
形态数 * 排列数
【卡塔兰数】：https://en.wikipedia.org/wiki/Catalan_number

走楼梯问题的解决，斐波那契数求解？
递归，边界条件如下：
f(n) = f(n-1) + f(n-2);
f(1)=1;
f(2)=2;

题目：1个细胞，每1小时分裂成2个，分裂3次之后，本体会死掉。n个小时之后，有多少个细胞？
f(n) = 2*f(n-1)-f(n-4)

堆

堆：
完全二叉树
节点大于等于子树中每个节点的值

堆的存储：采用数组，i节点，左节点为2*1，右节点为2*1+1，父节点为i/2

堆中的操作：
1插入元素，如果插入后不再满足对的要求，则进行堆化调整；
堆化：堆化非常简单，就是顺着节点所在的路径，向上或者向下，对比，然后交换。

删除栈顶元素
假设我们构造的是大顶堆，堆顶元素就是最大的元素。当我们删除堆顶元素之后，就需要把第二大的元素放到堆顶，那第二大元素肯定会出现在左右子节点中。然后我们再迭代地删除第二大节点，以此类推，直到叶子节点被删除。

基于堆实现排序
1）建堆
尽管数组中包含 n 个数据，但是我们可以假设，起初堆中只包含一个数据，就是下标为 1 的数据。然后，我们调用前面讲的插入操作，将下标从 2 到 n 的数据依次插入到堆中。这样我们就将包含 n 个数据的数组，组织成了堆。
第二种实现思路，跟第一种截然相反，也是我这里要详细讲的。第一种建堆思路的处理过程是从前往后处理数组数据，并且每个数据插入堆中时，都是从下往上堆化。而第二种实现思路，是从后往前处理数组，并且每个数据都是从上往下堆化。此时，建堆过程的时间复杂度是 O(n)。
2）排序
建堆结束之后，数组中的数据已经是按照大顶堆的特性来组织的。
数组中的第一个元素就是堆顶，也就是最大的元素。我们把它跟最后一个元素交换，那最大元素就放到了下标为 n 的位置。这个过程有点类似上面讲的“删除堆顶元素”的操作，当堆顶元素移除之后，我们把下标为 n 的元素放到堆顶，然后再通过堆化的方法，将剩下的 n−1 个元素重新构建成堆。
堆化完成之后，我们再取堆顶的元素，放到下标是 n−1的位置，一直重复这个过程，直到最后堆中只剩下标为 1 的一个元素，排序工作就完成了。

堆排序 ？？ O(nlogn)
堆排序与快排的比较
1）实现逻辑更复杂，需要建堆，排序，而且都比较难搞，并且总的交换次数更高
2）堆排序的数据访问方式没有快速排序好，因为堆排序都是跳着访问，而不是像快速排序那样，局部顺序访问，所以，这样对 CPU 缓存是不友好的。

堆的应用：
优先级队列 :一般的队列先进先出，优先级队列则是优先级最高的先出列，以优先级为标准建立堆即可实现，
实例：java中的优先级队列，PriorityQueue，底层是数组，实际维护了一个堆结构，
堆本质上是完全二叉树，以大顶堆为例，同时要求某一节点的值必须大于等于子节点的值

优先级队列的使用:
场景一：假设我们有 100 个小文件，每个文件的大小是 100MB，每个文件中存储的都是有序的字符串。我们希望将这些 100 个小文件合并成一个有序的大文件。
维护一个length为100的数组，从每个文件读取一个字符串放入数组，选择最小的放入大文件中；然后数组中删除该字符串，并从该字符串所在的文件中读取下一个字符串存入数组；循环处理所有文件即可。
每次从数组中获取最小值（O(n)），会非常耗时，可以将数组维护成堆结构，那么每次存入和删除时间复杂度都是O(logn)

场景二：
有一个定时器，定时器中维护了很多定时任务，每个任务都设定了一个要触发执行的时间点。定时器每过一个很小的单位时间（比如 1 秒），就扫描一遍任务，看是否有任务到达设定的执行时间。如果到达了，就拿出来执行。
每过 1 秒就扫描一遍任务列表的做法比较低效，主要原因有两点：
第一，任务的约定执行时间离当前时间可能还有很久，这样前面很多次扫描其实都是徒劳的；
第二，每次都要扫描整个任务列表，如果任务列表很大的话，势必会比较耗时。
用优先级队列来解决。我们按照任务设定的执行时间，将这些任务存储在优先级队列中，队列首部（也就是小顶堆的堆顶）存储的是最先执行的任务。这样，定时器就不需要每隔 1 秒就扫描一遍任务列表了。它拿队首任务的执行时间点，与当前时间点相减，得到一个时间间隔 T。这个时间间隔 T 就是，从当前时间开始，需要等待多久，才会有第一个任务需要被执行。这样，定时器就可以设定在 T 秒之后，再来执行任务。从当前时间点到（T-1）秒这段时间里，定时器都不需要做任何事情。当 T 秒时间过去之后，定时器取优先级队列中队首的任务执行。执行后删除任务，然后再计算新的队首任务的执行时间点与当前时间点的差值，把这个值作为定时器执行下一个任务需要等待的时间。

定时监测很多表是否导数完成，维护一个优先对列。0点维护结构，挂掉检测到对列不存在则重新构建；

获取topN:
静态数据，如何在一个包含 n 个数据的数组中，查找前 K 大数据呢？我们可以维护一个大小为 K 的小顶堆，顺序遍历数组，从数组中取出数据与堆顶元素比较。如果比堆顶元素大，我们就把堆顶元素删除，并且将这个元素插入到堆中；如果比堆顶元素小，则不做处理，继续遍历数组。这样等数组中的数据都遍历完之后，堆中的数据就是前 K 大数据了。

针对动态数据求得TopK就是实时TopK。怎么理解呢？我举一个例子。一个数据集合中有两个操作，一个是添加数据，另一个询问当前的前K大数据。如果每次询问前K大数据，我们都基于当前的数据重新计算的话，那时间复杂度就是 O(nlogK)，n 表示当前的数据的大小。实际上，我们可以一直都维护一个 K 大小的小顶堆，当有数据被添加到集合中时，我们就拿它与堆顶的元素对比。如果比堆顶元素大，我们就把堆顶元素删除，并且将这个元素插入到堆中；如果比堆顶元素小，则不做处理。

求中位数：
中位数，顾名思义，就是处在中间位置的那个数。如果数据的个数是奇数，把数据从小到大排列，那第n/2+1 个数据就是中位数（注意：假设数据是从0开始编号的）；如果数据的个数是偶数的话，那处于中间位置的数据有两个，第n/2个和第n/2+1个数据，这个时候，我们可以随意取一个作为中位数，比如取两个数中靠前的那个，就是第n/2 个数据。

对于一组静态数据，中位数是固定的，我们可以先排序，第n/2个数据就是中位数。每次询问中位数的时候，我们直接返回这个固定的值就好了。所以，尽管排序的代价比较大，但是边际成本会很小。

如果是动态数据，就很需要每次查询每次排序，那就麻烦了，可以通过维护两个堆，一个大顶堆，一个小顶堆来实现。大顶堆维护前半部分数据，有n/2或n/2+1个元素，小顶堆维护n/2个元素，且小顶堆的元素都大于等于大顶堆的元素。每次大顶堆的最大元素就是中部。

插入新的元素，如果小于大顶堆，则将大顶堆的堆顶移到小顶堆，然后新元素插入大顶堆。

如果上面求解第80%大的元素呢？
也是维护两个堆，不过堆得大小比例是80：20；

有一个包含 10 亿个搜索关键词的日志文件，如何快速获取到 Top 10 最热门的搜索关键词呢？
一般解法：
散列表存储，key：关键词 value：次数
然后求topn

10 亿的关键词还是很多的。我们假设 10 亿条搜索关键词中不重复的有 1 亿条，如果每个搜索关键词的平均长度是 50 个字节，那存储 1 亿个关键词起码需要 5GB 的内存空间，而散列表因为要避免频繁冲突，不会选择太大的装载因子，所以消耗的内存空间就更多了。而我们的机器只有 1GB 的可用内存空间，所以我们无法一次性将所有的搜索关键词加入到内存中。这个时候该怎么办呢？

分到10个文件处理？每个文件分别求top10？ 10个文件的top10综合的结果。
前提是必须将相同关键词放到一个文件中，否则是没有意义的，放的方式就是对关键字hash，利用相同数据经过哈希算法得到的哈希值是一样的原理，对hash结果对10取余，分别放到0-9个文件中。

有一个访问量非常大的新闻网站，我们希望将点击量排名 Top 10 的新闻摘要，滚动显示在网站首页 banner 上，并且每隔 1 小时更新一次。如果你是负责开发这个功能的工程师，你会如何来实现呢？

理解近一小时的top10
日志存储：如果近一个小时的新闻数太多，可以分片，例如分10片，即10个文件，对新闻标题取hash，然后对10取余，将新闻存储到对应的文件中。
获取每个文件的访问次数： 散列表存储，key:新闻唯一标识 value：访问次数
每个文件获取top10：分别维护一个size为10的小顶堆
最后一分钟维护一个整体最小顶堆，遍历散列表

近3小时的top10，每小时更新
4小时数据保存 时间 id 次数，
维护散列表    id 次数，时间向后推1小时的时候加入最近一小时访问量，减去向前的第4小时访问量
维护size为10的最小顶堆，访问上面的散列表

 

public class TreeTest {

    public static void main(String[] args) {
//        System.out.println(stairs((4)));

        Node node4 = new Node(4, null, null);
        Node node5 = new Node(5, null, null);
        Node node6 = new Node(6, null, null);
        Node node8 = new Node(8, null, null);
        Node node7 = new Node(7, null, node8);

        Node node2 = new Node(2, node4, node5);
        Node node3 = new Node(3, node6, node7);
        Node node1 = new Node(1, node2, node3);

        ArrayList arrayList = new ArrayList();
        midTraversalNew(node1, arrayList);
        for(int i=0; i<arrayList.size(); i++ ){
            System.out.print(arrayList.get(i));
        }
//        System.out.println(getMaxDepth(node1));
//        System.out.println(hasPathSum(node1, 8));
//        System.out.println(hasPathSum(node1, 9));
//        System.out.println(hasPathSum(node1, 19));
    }



    /**
     * desc:  走楼梯问题，一共n阶楼梯，可以一次走1阶或一次走2阶，共走几次 <br>
     *分析:假设当前在第n层，那第一次可以走1阶，此时还剩n-1层；也可以走2阶，那此时还有n-2阶，所以：
     * f(n) = f(n-1) + f(n-2);本质上是斐波那契数列
     * @param n： 楼梯数
     */
    public static  int  stairs(int n){
        // 校验0的处理
        if(n <= 0){
            return 0;
        }else if(n == 1){
            return 1;
        }else if(n == 2){
            return 2;
        }else{
            return stairs(n-1) + stairs(n-2);
        }
    }

    /**
     * desc:前序遍历-递归
     */
    public static ArrayList befroeTraversal(Node node, ArrayList list){
        if(node == null){
            return list;
        }else{
            list.add(node.getValue());
            befroeTraversal(node.getLeft(),list);
            befroeTraversal(node.getRight(),list);
        }
        return list;
    }

    /**
     * desc:前序遍历-非递归
     */
    public static ArrayList befroeTraversalNew(Node node, ArrayList list){
        if(node == null){
            return list;
        }
        ArrayDeque<Node> stack=new ArrayDeque<Node>();

        while(node != null || stack.size()!=0){
            if(node != null){
                list.add(node.value);
                stack.push(node);
                node = node.left;
            }else{
                node = stack.pop();
                node = node.right;
            }
        }
        return list;
    }

    /**
     * desc:中序遍历-非递归
     */
    public static ArrayList midTraversalNew(Node node, ArrayList list){
        if(node == null){
            return list;
        }
        ArrayDeque<Node> stack=new ArrayDeque<Node>();

        while(node != null || stack.size()!=0){
            // 中序遍历
            if(node != null){
                stack.push(node);
                node = node.left;
            }else{
                node = stack.pop();
                list.add(node.value);
                node = node.right;
            }
        }
        return list;
    }



    public static ArrayList middleTraversal(Node node, ArrayList list){
        if(node == null){
            return list;
        }else{
            middleTraversal(node.getLeft(),list);
            list.add(node.getValue());
            middleTraversal(node.getRight(),list);
        }
        return list;
    }

    public static ArrayList afterTraversal(Node node, ArrayList list){
        if(node == null){
            return list;
        }else{
            afterTraversal(node.getLeft(),list);
            afterTraversal(node.getRight(),list);
            list.add(node.getValue());
        }
        return list;
    }

    /**
     * desc:获取最大深度
     */
    public static int getMaxDepth(Node node){
        if(null == node){
            return 0;
        }
        if(node.left == null && node.right==null){
            return 1;
        }
        int depthL = getMaxDepth(node.left);
        int depthR = getMaxDepth(node.right);
        return depthL > depthR ? depthL+1: depthR+1;
    }

    /**
     * desc:问题：判断是否有从根节点到叶子节点和为sum的路径
     * 思路：注意题意是找一条“从根节点到叶子结点”的路径和，所以到每一个结点判断是否值对的同时，还要判断是否没有孩子结点，如果有，还需要继续往下找。
     */
    public static boolean hasPathSum(Node node, int sum){
        if(node == null ){
            return false;
        }
        if(node.left == null && node.right == null && sum == node .value){
            return true;
        }else{
            sum = sum - node.value;
            return hasPathSum(node.left, sum) || hasPathSum(node.right, sum);
        }
    }

    static class Node implements Comparable{
        int value;
        Node left;
        Node right;
        public  Node(){

        }
        public  Node(int value, Node left, Node right){
            this.value = value;
            this.left = left;
            this.right = right;
        }

        public int getValue() {
            return value;
        }

        public void setValue(int value) {
            this.value = value;
        }

        public Node getLeft() {
            return left;
        }

        public void setLeft(Node left) {
            this.left = left;
        }

        public Node getRight() {
            return right;
        }

        public void setRight(Node right) {
            this.right = right;
        }

        @Override
        public int compareTo(Object o) {
            return 0;
        }
    }
}