java 知识树算法

树

---

树的定义（递归方式）

树的实现

class TreeNode{
    Object element;
    TreeNode firstChild;
    TreeNode nextSibling;
}

树的遍历

先序遍历（preorder travelsal)

设我们想要列出目录中所有文件的名字。输出格式将是：深度为 $d_i$ 的文件将被 $d_i$ 次跳格（tab）缩进后打印其名。伪码如下：

private void listAll(int depth) {
        printName(depth);
        if (isDirectory) {
            for each file c in this directory( for each child)
            c.listAll(depth + 1);
        }
    }
    public void listAll() {
        listAll(0);
    }

这种策略叫做先序遍历（preorder travelsal)
展示如下：

后序遍历（postorder travelsal）

计算一个目录大小的伪码历程

public int size() {
        int totalSize = sizeOfThisFile();
        if (isDirectory())
            for each file c in this directory( for each child)
                totalSize += c.size();

        return totalSize;
    }

二叉树

---

二叉树的实现

public class BinaryNode {
    Object element;   //the data in the node
    BinaryNode left;   //Left child
    BinaryNode right;  //right child
}

例子：表达式树

二叉树的主要用处之一是在编译器的设计领域

查找树ADT——二叉查找树

二叉查找树的性质是，对于树中的每个节点X，它的左子树中所有项的值小于X中的项，而它的右子树中所有项大于X中的项。

insert 方法

在二叉查找树中 insert 方法必定会插在叶子节点上，利用递归的方式，将节点x插入到适当的子树中，代码如下：

private BinaryNode<E> insert(E x, BinaryNode<E> t) {
        if (t == null) {
            return new BinaryNode<>(x, null, null);
        }
        int compareResult = x.compareTo(t.element);
        if (compareResult < 0)
            t.left = insert(x, t.left);
        else if (compareResult > 0)
            t.right = insert(x, t.right);
        else ;//Duplicate;do nothing
        return t;
    }

remove 方法

最困难的操作是 remove（删除）。

• 如果是叶子节点，那么立即删除
• 如果节点有一个儿子，该节点直接替换为这个儿子 t = (t.left != null) ? t.left : t.right;
• 如果节点有二个儿子。一般的删除策咯是用其右子树的最小的数据（用findMin函数找到）代替该节点的数据并递归地删除那个最小数据的节点。

private BinaryNode<E> remove(E x, BinaryNode<E> t) {
        if (t == null)
            return t;
        int compareResult = x.compareTo(t.element);
        if (compareResult < 0)
            t.left = remove(x, t.left);
        else if (compareResult > 0)
            t.right = remove(x, t.right);
        else if (t.left != null && t.right != null) {
            t.element = findMin(t.right).element;
            t.right = remove(t.element, t.right);  //核心代码
        } else
            t = (t.left != null) ? t.left : t.right;
        return t;
    }

上述的删除工作效率并不高，因为它沿该树进行两趟收索以查找和删除右子树中的最小的节点，很明显右子树的删除可以写一个特殊的 removeMin 方法改变这种效率。
如果删除的次数不多，通常使用的策咯是 懒惰删除(lazy deletion)：当一个元素要被删除时，它仍留在树中，而只是被标记为删除。这特别是在有重复项时很常用，因为此时记录出现频率数的域可以减1.如果树中的实际节点树和“被删除”的节点数相同，那么树的深度预计只上升一个小的常数，因此，存在一个与懒惰删除相关的非常小的时间损耗。再有，如果被删除的项是重新插入的，那么分配一个新单元的开销就避免了。

二叉树github

AVL树

单旋转

下面 假设从初始的空AVL树开始插入关键字 3、2和1，然后依序插入4~7。在插入1时第一个问题出现，AVL性质在根处被破坏。我们在根与其左儿子之间实行单旋转修正这个问题。

图中虚线连接的两个节点，它们是旋转的主体。下面我们插入关键字4的节点，这没有问题，但插入5会破坏在节点3处的AVL性质，通过单旋转将其改正。

下面插入6，因为左边子树的高度为0而右子树的高度为2，因此在根处2和4之间实施一次单旋转

旋转结果使得2是4的一个儿子，而4原来的左子树变成节点2的新的右子树。下面插入一个关键字7，它导致另外的旋转。

private AvlNode<E> rotateWithLeftChild(AvlNode<E> k2) {
        AvlNode<E> lChild = k2.left;
        k2.left = lChild.right;
        lChild.right = k2;
        k2.height = Math.max(height(k2.left), height(k2.right)) + 1;
        lChild.height = Math.max(height(lChild.left), k2.height) + 1;
        return lChild;
    }
    private AvlNode<E> rotateWithRightChild(AvlNode<E> k2) {
        AvlNode<E> rChild = k2.right;
        k2.right = rChild.left;
        rChild.left = k2;
        k2.height = Math.max(height(k2.left), height(k2.right)) + 1;
        rChild.height = Math.max(height(rChild.right), k2.height) + 1;
        return rChild;
}

双旋转

单旋转对于某些情形并没有减低他的深度。这时需要双旋转。

继续前面的例子基础上以倒序插入关键字10~16，接着插入8，9。插入16简单

，并没有破坏性质，但插入15后会引起节点7处的高度不平衡。需要通过右-左旋转解决。

下面插入14，也需要一个双旋转。此时需要右-左旋转。

下面插入 13，那么会在根处产生一个不平衡。由于13不在4和7之间，因此一次单旋转就能完成修正工作。

插入12、11都需要单旋转结果如下

最后插入9演示双旋转的对称情形。

private AvlNode<E> doubleWithLeftChild(AvlNode<E> k3) {
        k3.left = rotateWithRightChild(k3.left);
        return rotateWithLeftChild(k3);
    }

    private AvlNode<E> doubleWithRightChild(AvlNode<E> k1) {
        k1.right = rotateWithLeftChild(k1.right);
        return rotateWithRightChild(k1);
    }

平衡树操作

平衡的操作很简单，首先判断节点是否失去平衡（左子树与右子树的高度查大于*ALLOW_IMBLANCE = 1 * ，并判断其需要进行旋转的类型进行相应的旋转操作,最后不要忘记重新计算树的高度。操作很清晰

private AvlNode<E> balance(AvlNode<E> t) {
        if (t == null) return t;
        if (height(t.left) - height(t.right) > ALLOWED_IMBLANCE)
            if (height(t.left.left) >= height(t.left.right))
                t = rotateWithLeftChild(t);
            else
                t = doubleWithLeftChild(t);
        else if (height(t.right) - height(t.left) > ALLOWED_IMBLANCE)
            if (height(t.right.right) >= height(t.right.left))
                t = rotateWithRightChild(t);
            else
                t = doubleWithRightChild(t);
        t.height = Math.max(height(t.left), height(t.right)) + 1;
        return t;
    }

插入操作

插入操作都是插入到节点，最主要的是插入后的调节平衡，需要从下向上进行调节平衡操作。

private AvlNode<E> insert(E x, AvlNode<E> t) {
        if (t==null)
            return new AvlNode<>(x,null,null);
        int compareResult=x.compareTo(t.element);
        if (compareResult>0)
            t=insert(x,t.right);
        else if (compareResult<0)
            t=insert(x,t.left);
        else ;
        return balance(t);
}

删除操作

删除操作最为复杂，首先找到要删除的节点，判断是否含有左右子树，若含有左右子树，通常取右子树的最小的节点接替本节点，需要调用findMin()函数,如下：

private AvlNode<E> findMin(AvlNode<E> t) {
        if (t == null) {
            return t;
        }
        while (t.left != null) t = t.left;
        return t;
    }

当含有左子树，将右子树作为本节点。否则将左子树作为本节点（包括左右节点都不存在）。
t=(t.left!=null)?t.left:t.right;

remove()全部代码：

private AvlNode<E> remove(E x, AvlNode<E> t) {
        if (t==null)return t;
        int compareResult=x.compareTo(t.element);
        if (compareResult>0)
            t=remove(x,t.right);
        else if (compareResult<0)
            t=remove(x,t.left);
        else if (t.left!=null&&t.right!=null){
            t.element=findMin(t.right).element;
            t.right=remove(t.element,t.right);
        }else
            t=(t.left!=null)?t.left:t.right;
        return balance(t);
    }

AVL树的github代码