哈希表与树笔记（四）

haffman树

    路径：从树中一个节点到另一个节点之间的分支构成两个节点之间的路径

    路径长度：路径上的分支数目称作路径长度，

     整个树的路径长度：是从树根到每一节点的路径长度之和

     带权路径长度（WPL）：

     带权路径最小的树就是haffman树

 

生成haffman树

  先权重排序，再以最小俩数据对比，再权重排序。。。。

 

平衡二叉树树（AVL）：是一种二叉排序树，其中每一节点的左子树和右子树的高度差至多等于1

平衡因子（BF）：二叉树上节点的左子树深度减右子树深度

最小不平衡子树：距离插入点最近的且平衡因子的绝对值大于1的节点为根的子树

左旋

右旋

代码实现左旋右旋

 public class AVLTree<E extends Comparable<E>> {
        Node<E> root;
        int size;


        private void leftRotate(Node<E> t) {
            if (t == null) {
                return;
            }
            if (t.right != null) {
                //1，
                Node<E> y = t.right;
                t.right = y.left;
                if (y.left != null) {
                    y.left.parent = t;
                }
                //2，
                y.parent = t.parent;
                if (t.parent == null) {
                    root = y;
                } else {
                    if (t.parent.left == t) {
                        t.parent.left = y;
                    } else if (t.parent.right == t) {
                        t.parent.right = y;
                    }
                }
                //3,
                t.parent = y;
                y.left = t;
            }

        }

        private void rightRotate(Node<E> t) {
            if (t == null) {
                return;
            }
            if (t.left != null) {
                Node<E> x = t.left;
                //1；
                t.left = x.right;
                if (x.right != null) {
                    x.right.parent = t;
                }

                //2
                x.parent = t.parent;
                if (t.parent == null) {
                    root = x;
                } else {
                    if (t.parent.left == t) {
                        t.parent.left = x;
                    } else if (t.parent.right == t) {
                        t.parent.right = x;
                    }
                }
                //3,
                t.parent = x;
                x.right = t;

            }
        }

        public class Node<E extends Comparable<E>> {
            E element;

            Node<E> left;
            Node<E> right;
            Node<E> parent;

            public Node(E element, Node<E> parent) {
                this.element = element;
                this.parent = parent;
            }

        }
    }