【专题三】二叉树

1.二叉查找树的创建

1.1二叉树的结点类

根据对图的观察，我们发现二叉树其实就是由一个一个的结点及其之间的关系组成的，按照面向对象的思想，我们设计一个结点类来描述结点这个事物。
结点类API设计：

类名	Node<Key,Value>
构造方法	Node(Key key, Value value, Node left, Node right)：创建Node对象
成员变量	1.public Node left:记录左子结点 2.public Node right:记录右子结点 3.public Key key:存储键 4.public Value value:存储值

代码实现：

private class Node<Key,Value>{
        //存储键
        public Key key;
        //存储值
        private Value value;
        //记录左子结点
        public Node left;
        //记录右子结点
        public Node right;
        public Node(Key key, Value value, Node left, Node right) {
            this.key = key;
            this.value = value;
            this.left = left;
            this.right = right;
        }
}

1.2.二叉查找树API设计

类名	BinaryTree,Value value>
构造方 法	BinaryTree()：创建BinaryTree对象
成员变 量	1.private Node root:记录根结点 2.private int N:记录树中元素的个数
成员方 法	1. public void put(Key key,Value value):向树中插入一个键值对 2.private Node put(Node x, Key key, Value val)：给指定树x上，添加键一个键值对，并返回添 加后的新树 3.public Value get(Key key):根据key，从树中找出对应的值 4.private Value get(Node x, Key key):从指定的树x中，找出key对应的值 5.public void delete(Key key):根据key，删除树中对应的键值对 6.private Node delete(Node x, Key key):删除指定树x上的键为key的键值对，并返回删除后的 新树 7.public int size():获取树中元素的个数

package cn.itcast.algorithm.Demo.tree;


import cn.itcast.algorithm.linear.Queue;
import cn.itcast.algorithm.tree.BinaryTree;

import java.security.Key;

public class BinaryTreeDemo<key extends Comparable<key>, Value> {
    //成员变量
    //1.private Node root:记录根结点
    //2.private int N:记录树中元素的个数
    private Node root;
    private int N;

    public class Node {

        //1.public Node left:记录左子结点
        //2.public Node right:记录右子结点
        //3.public Key key:存储键
        //4.public Value value:存储值
        public Node left;
        public Node right;
        public Key key;
        public Value value;

        public Node(Key key, Value value, Node left, Node right) {
            this.key = key;
            this.value = value;
            this.left = left;
            this.right = right;
        }
        //BinaryTree()：创建BinaryTree对象

        //成员方法
        //1. public void put(Key key,Value value):向树中插入一个键值对
        public void put(Key key, Value value) {
            root = put(root, key, value);

        }

        //2.private Node put(Node x, Key key, Value val)：给指定树x上，添加键一个键值对，并返回添加后的新树
        private Node put(Node x, Key key, Value value) {
           /*
           插入方法put实现思想：
                1.如果当前树中没有任何一个结点，则直接把新结点当做根结点使用
                2.如果当前树不为空，则从根结点开始：
                2.1如果新结点的key小于当前结点的key，则继续找当前结点的左子结点；
                2.2如果新结点的key大于当前结点的key，则继续找当前结点的右子结点；
                2.3如果新结点的key等于当前结点的key，则树中已经存在这样的结点，替换该结点的value值即可。
            */
            //如果x子树为空，
            if (x == null) {
                N++;
                return new Node(key, value, null, null);
            }
            //如果x子树不为空
            //比较x结点的键和key的大小：
            int cmp = key.compareTo(x.key);
            if (cmp > 0) {
                //如果key大于x结点的键，则继续找x结点的右子树
                x.right = put(x.right, key, value);
            } else if (cmp < 0) {
                //如果key小于x结点的键，则继续找x结点的左子树
                x.left = put(x.left, key, value);
            } else {
                //如果key等于x结点的键，则替换x结点的值为value即可
                x.value = value;
            }
            return x;
        }

        //3.public Value get(Key key):根据key，从树中找出对应的值
        public Value get(Key key) {
            return get(root, key);
        }

        //4.private Value get(Node x, Key key):从指定的树x中，找出key对应的值
        private Value get(Node x, Key key) {
            /*
            查询方法get实现思想：
                从根节点开始：
                1.如果要查询的key小于当前结点的key，则继续找当前结点的左子结点；
                2.如果要查询的key大于当前结点的key，则继续找当前结点的右子结点；
                3.如果要查询的key等于当前结点的key，则树中返回当前结点的value。
             */

            //x树为null
            if (x == null) {
                return null;
            }

            //x树不为null

            //比较key和x结点的键的大小
            int cmp = key.compareTo(x.key);
            if (cmp > 0) {
                //如果key大于x结点的键，则继续找x结点的右子树
                return get(x.right, key);

            } else if (cmp < 0) {
                //如果key小于x结点的键，则继续找x结点的左子树
                return get(x.left, key);
            } else {
                //如果key等于x结点的键，就找到了键为key的结点，只需要返回x结点的值即可
                return x.value;
            }
        }

        //5.public void delete(Key key):根据key，删除树中对应的键值对
        public void delete(Key key) {
            delete(root, key);
        }

        //6.private Node delete(Node x, Key key):删除指定树x上的键为key的键值对，并返回删除后的新树
        private Node delete(Node x, Key key) {
            /*
            删除方法delete实现思想：
            1.找到被删除结点；
            2.找到被删除结点右子树中的最小结点minNode
            3.删除右子树中的最小结点
            4.让被删除结点的左子树称为最小结点minNode的左子树，让被删除结点的右子树称为最小结点minNode的右子树
            5.让被删除结点的父节点指向最小结点minNode
             */

            //x树为null
            if (x == null) {
                return null;
            }

            //x树不为null
            //比较key和x结点的键的大小
            int cmp = key.compareTo(x.key);
            if (cmp > 0) {
                //如果key大于x结点的键，则继续找x结点的右子树
                return delete(x.right, key);
            } else if (cmp < 0) {
                //如果key小于x结点的键，则继续找x结点的左子树
                return delete(x.left, key);
            } else {
                //如果key等于x结点的键，完成真正的删除结点动作，要删除的结点就是x；

                //让元素个数-1
                N--;
                //得找到右子树中最小的结点
                if (x.right == null) {
                    return x.left;
                }
                if (x.left == null) {
                    return x.right;
                }

                Node minNode = x.right;
                while (minNode != null) {
                    minNode = x.left;
                }

                //删除右子树中最小的结点
                Node n = x.right;
                while (n.left != null) {
                    if (n.left.left == null) {
                        n.left = null;
                    } else {
                        //变换n结点即可
                        n = n.left;
                    }
                }
                //让x结点的左子树成为minNode的左子树
                minNode.left = x.left;
                //让x结点的右子树成为minNode的右子树
                minNode.right = x.right;
                //让x结点的父结点指向minNode
                x = minNode;
            }
            return x;
        }

        //7.public int size():获取树中元素的个数
        public int size() {
            return N;
        }

        //8.找出整个树中最小的键
        public Key min() {
            return min(root).key;
        }

        //找出指定树x中最小的键所在的结点
        private Node min(Node x) {
            if (x.left == null) {
                return min(x.left);
            } else {
                return x;
            }
        }

        //9.找出整个树中最大的键
        public Key max() {
            return max(root).key;
        }

        //找出指定树x中最小的键所在的结点
        private Node max(Node x) {
            if (x.left == null) {
                return max(x.left);
            } else {
                return x;
            }
        }

        //10.前序遍历
        //使用前序遍历，获取整个树中的所有键
        public Queue<Key> preErgodic() {
            Queue<Key> keys = new Queue<>();
            preErgodic(root, keys);
            return keys;
        }

        //使用前序遍历，把指定树x中的所有键放入到keys队列中
        private void preErgodic(Node x, Queue<Key> keys) {
            if (x == null) {
                return;
            }
            //把x结点的key放入到keys中
            keys.enqueue(x.key);
            //递归遍历x结点的左子树
            if (x.left != null) {
                //递归
                preErgodic(x.left, keys);
            }

            //递归遍历x结点的右子树
            if (x.right != null) {
                preErgodic(x.right, keys);
            }
        }

    }
}

测试代码：

package cn.itcast.algorithm.test;

import cn.itcast.algorithm.tree.BinaryTree;

public class BinaryTreeTest {
    public static void main(String[] args) {
        //创建二叉查找树对象
        BinaryTree<Integer, String> tree = new BinaryTree<>();

        //测试插入
        tree.put(1,"张三");
        tree.put(2,"李四");
        tree.put(3,"王五");
        System.out.println("插入完毕后元素的个数："+tree.size());

        //测试获取
        System.out.println("键2对应的元素是："+tree.get(2));

        //测试删除

        tree.delete(3);
        System.out.println("删除后的元素个数："+tree.size());
        System.out.println("删除后键3对应的元素:"+tree.get(3));


    }

}

 

2.二叉树的实际应用（应用场景）

1. 哈夫曼编码，来源于哈夫曼树（给定n个权值作为n个叶子结点，构造一棵二叉树，若带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为赫夫曼树(Huffman tree)。即带权路径长度最短的树），在数据压缩上有重要应用，提高了传输的有效性，详见《信息论与编码》。
2. 海量数据并发查询，二叉树复杂度是O(K+LgN)。二叉排序树就既有链表的好处，也有数组的好处， 在处理大批量的动态的数据是比较有用。
3. C++ STL中的set/multiset、map，以及Linux虚拟内存的管理，都是通过红黑树去实现的。查找最大（最小）的k个数，红黑树，红黑树中查找/删除/插入，都只需要O(logk)。
4. B-Tree，B+-Tree在文件系统中的目录应用。
5. 路由器中的路由搜索引擎。