Tree

Tree可以通过多种方式定义。常见的方式是通过递归，一个Tree是多个Nodes的集合，这个集合可以是空集。因此Tree是由一个独一无二的root（根节点），空或者非空的子树T₁，T₂，T₃，……，这些子树有一条边和r节点连接。
每一个子树也被称为r的孩子，r是每一个子树根节点的父节点。通过递归定义方式，我们发现一个Tree是一个N个Nodes的集合，其中一个被称为root，同时有N-1条edges。

Tree实现

一种tree的实现方式是每一个节点都由数据、连接所有孩子的边组成。但是，因为每一个节点的孩子数量可以非常大，并且不能提前知道，我们不能存储所有节点的连接，可以通过将所有孩子节点存储为一个list来解决。

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

Binary Tree

二叉树是一个只允许有两个孩子节点的树。

class BinaryNode {
 Object element;
 BinaryNode left;
 BinaryNode right;
}

The Search Tree ADT

二叉树的重要应用之一是查找。我们假设每一个节点存储一个元素，我们暂时假设他们是int类型，同时不存在相等的。二叉树能够实现查找的重要属性是对于节点X，左子树的所有元素都小于它，右子树的所有元素都大于它。因此二分查找树要求所有元素是有序的。

private static class BinaryNode {
  BinaryNode(AnyType theElement) {
    this(theElement, null, null)
}
  BinaryNode(AnyType theElement, BinaryNode lt, BinaryNode rt) {
    element = theElement;
    left = lt;
    right = rt;
}

AnyType element;
BinaryNode left;
BinaryNode right;
}

以上为BinaryNode类，类似于在链表中的node节点一样是一个嵌套类。

/**
 * Copyright (C), 2015-2019, XXX有限公司
 * FileName: BinarySearchTree
 * Author:   dalu
 * Date:     2019/7/28 23:28
 * Description:
 * History:
 *                               
 * 作者姓名           修改时间           版本号              描述
 */

import java.nio.BufferUnderflowException;

/**
 * 〈一句话功能简述〉
 
 * 〈〉
 *
 * @author dalu
 * @create 2019/7/28
 * @since 1.0.0
 */
public class BinarySearchTree> {
    private static class BinaryNode {
        BinaryNode(AnyType theElement) {
            this(theElement, null, null);
        }

        BinaryNode(AnyType theElement, BinaryNode lt, BinaryNode rt) {
            element = theElement;
            left = lt;
            right = rt;
        }

        AnyType element;
        BinaryNode left;
        BinaryNode right;

    }

    private BinaryNode root;

    public  BinarySearchTree() {
        root = null;
    }

    public void makeEmpty() {
        root = null;
    }

    public boolean isEmpty() {
        return root = null;
    }

    public boolean contains(AnyType x) {
        return contains(x, root);
    }

    public AnyType findMin() {
        if(isEmpty()) throw  new BufferUnderflowException();
        return findMin(root).element;
    }

    public AnyType findMax() {
        if(isEmpty()) throw  new BufferUnderflowException();
        return findMax(root).element;
    }

    public void insert(AnyType x) {
        root = insert(x, root);
    }

    public void remove(AnyType x) {
        root = remove(x, root);
    }

    public void printTree() {

    }

    private boolean contains(AnyType x, BinaryNode t) {
        if(t == null) {
            return false;
        }

        int compareResult = x.compareTo(t.element);

        if (compareResult < 0) {
            return contains(x, t.left);
        }
        else if (compareResult > 0) {
            return contains(x, t.right);
        }
        else {
            return true;
        }

    }

    private BinaryNode findMin(BinaryNode t) {
        if (t == null) {
            return null;
        } else if (t.left == null)
            return t;
        return findMin(t.left);
    }

    private BinaryNode findMax(BinaryNode t) {
        if (t != null) {
            while(t.right != null) {
                t = t.right;
            }
        }
        return t;
    }


    private BinaryNode insert(AnyType x, BinaryNode 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 {

        }
        return t;

    }

    private BinaryNode remove(AnyType x, BinaryNode 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;
    }

    private void printTree(BinaryNode t) {

    }


}

以上为二分查找树的基本结构，单一数据字段关联root节点，public方法调用私有的递归方法。

contains

这个操作返回true，当X元素在树中时。当X元素不在T中或者T为空时，我们返回false。查找时，我们会递归的访问T的子树，根据X和根节点的大小关系左或者右。
一定要注意首先需要判断是否为空，同时，递归很容易被while循环改写，这里由于栈的深度，我们可以简单的使用递归的方法。

findMin and findMax

这些私有方法返回树中最小和最大的元素的节点。findMin从root节点一直往左找最终的节点；findMax则向右。

insert

这个方法比较简单，将X插入树T，这里需要调用contains方法，当X在其中时，更新或者不做任何事情。否则，将X插入到查找路径的最后一个点。

remove

类似于其他数据结构，remove方法是比较复杂的。当我们找到需要删除的点后，我们需要考虑几种情况。
加入这个节点是叶子节点，可以直接被删除。加入这个节点有一个孩子节点，需要连接它的父节点和它的子节点。比较复杂的例子是有两个孩子节点的节点。
一般的策略是用右子树最小的节点替换这个节点，然后删除这个节点，因为在右子树中最小的节点不会有左子树。如下图所示,删除2后的变化。

image.png

文中实现的删除是比较低效的，因为他需要找到并且删除右子树的最小节点，当我们删除的数量不多时，比较流行的策略是lazy deletion，当元素被删除时，我们仅仅标记为被删除,尤其是当有重复元素时，字段存储出现的频率可以被递减。