二叉树

二叉树：顾名思义就是每个节点都只能有两个子节点的树结构。

为什么要使用树这种结构呢？

树结构通常结合了另外两种数据结构的优点：一种是有序数组，另外一种是链表。 树结构的查询的速度和有序数组一样快，树结构的插入数据和删除数据的速度也和链表一样快。

树的术语：

Name	Function
路径	顺着连接点的边从一个节点走向另一个节点，所经过的节点的顺序排列就称为路径。
根	树顶端的节点就称为根，一棵树只有一个根，如果要把一个节点和边的集合定义为树，那么从根到其他任何一个节点都必须有一条路径。
父节点	每个节点（除了根）都恰好有一条边向上连接到另一个节点，上面的节点就称为下面节点的“父节点”。
子节点	每个节点都可能有一条或多条边向下连接其他节点，下面的这些节点就称为它的“子节点”。
叶节点	没有子节点的节点称为“叶子节点”或简称“叶节点”。树只能有一个根，但是可以有很多叶节点。
子树	每个节点都可以作为子树的根，它和它所有的子节点，子节点的子节点等都含在子树中。
访问	当程序控制流程到达某个节点的时候，就称为“访问”这个节点，通常是为了在这个节点处执行某种操作，例如查看节点某个数据字段的值或者显示节点。
遍历	遍历树意味着要遵循某种特定的顺序访问树中的所有节点。
层	一个节点的层数是指从根开始到这个节点有多少“代”。
关键字	可以看到，对象中通常会有一个数据域被指定为关键字值。这个值通常用于查询或者其他操作。
二叉树	如果树中的每个节点最多只能有两个子节点，这样的树就称为“二叉树”。

---

节点对象

一个节点对象的类，这些对象包含数据，数据代表要存储的内容，而且还有指向节点的两个子节点的引用。

class Node {
    int iData;
    double dData;
    Node leftChild;
    Node rightChild;

    public void displayNode() {
        System.out.println("{" + iData + ", " + dData +  "}");
    }
}

二叉树的查找节点

首先在树结构中，每个节点下的两条子路中，左边的索引值是要比右边的小的。根据这个原理，它提供了如下代码：

public Node find(int key) {
    Node current = root;
    while (current.iData != key) { // 当前节点的索引值不等于 要查找的索引值
        if (key < current.iData)   // 如果要查找的索引值比 当前的索引值大
            current = current.leftChild; // 向当前节点的右边查找
        else                            // 否则
            current = current.rightChild;  // 向当前节点的左边查找
        if (current == null) // 如果找到没有节点了   那么就代表该树结构中没有要查找的内容
            return null;    // 返回空
    }
    return current;    // 找到了 返回相应的节点
}

我觉得在这里的查询的原理在某种程度上和链表是一样的，不过是多了判断，往下进行的时候有了选择。首先，它同样是在内部维护了一个 current 表示当前所查看的节点，然后根据值的比较选择不同的路径继续走，找到返回对应的节点，没有的话就返回NULL。

插入一个节点

在插入的过程中，首先要找到要插入的地方，然后在进行插入操作。

public void insert(int id, double dd) {
    Node newNode = new Node();    // 创建要添加的节点
    newNode.iData = id;
    newData.dData = dd;
    if (root == null)      // 如果该树在插入之前没有其他的子节点
        root = newNode;    // 直接使用根节点指向新的节点
    else {
        Node current = root;    // 维护一个当前节点的变量
        Node parent;            // 维护一个父节点的变量
        while (true) {
            parent = current;   // 首先让父节点保存当前节点的状态
            if (id < current.iData) {  // 如果要插的数据 比当前节点的值小
                current = current.leftChild;  // 向左走
                if (current == null) {  // 走到当前的节点为空时 着说明其父节点应该为一个子叶节点 可直接插入
                    parent.leftChild = newNode;  // 使用当前节点的父节点 让其左子叶的引用指向 要插入的节点
                    return;    // 插入后返回
                }
            } else {    // 和上面类似
                current = current.rightChild;
                if (current == null) {
                    parent.rightChile = newNode;
                    return;
                }
            }
        }
    }
}

在上面的插入节点的代码中，我们可以看出，其基本原理其实和查询差不多，只不过是在查询中，我们遇到了空节点，要返回空，而在这里我们遇到空节点，就要进行插入操作。在这个过程中，维护了两个节点对象，一个是当前所在的节点，一个是其父节点，这么做就是因为，当发现子节点为空的时候，我们就要早父节点上进行数据插入的操作。

遍历树

在对树的遍历中存在着三种方法，它们是：前序(preorder)、中序(inorder)、后序(postorder)。在二叉树中，岁常使用的是中序遍历。

中序遍历：用该种方法遍历二叉树会使所有的节点按关键字值升序被访问到，如果希望在二叉树中创建有序的数据序列，这是一种方法。使用这种方法只需要做三件事：

    1. 调用自身来遍历节点的左子树
    2. 访问这个节点
    3. 掉用自身来遍历节点的右子树

 private void inOrder(Node localRoot) {
    if (localRoot != null) {
        inOrder(localRoot.leftChild);    // 递归调用其左子节点
        System.out.print(localRoot.iData + " ");    // 显示此节点
        inOrder(localRoot.rightChild);    // 递归调用其右子节点
    }
}

剩下的两种遍历方式，前序和后序，可能在含义上没有中序那么好理解，下面是其代码：

// 前序
private void perOrder(Node localRoot) {
    if (localRoot != null) {
        System.out.println(localRoot.iData + " ");
        perOrder(localRoot.leftChild);
        perOrder(localRoot,rightChild);
    } 
}
// 后序
private void postOrder(Node localRoot) {
    if (localRoot != null) {
        postOrder(localRoot.leftChild);
        postOrder(localRoot.rightChild);
        System.out.println(localRoot.iData + " ");
    }
}

在树结构中查找最大最小值

public Node minimum() {
    Node current, last;
    current = root;
    while (current != null) {
        last = current;
        current = current.leftChild;
    }
    return last;
}

在树结构中删除一个节点（比较难）

在删除之前需要找到要删的那个节点，这个节点找到之后，可能会有三种情况出现在你面前：
1. 该节点是叶节点、没有子节点
2. 该节点有一个子节点
3. 该节点有两个子节点

对于情况1：

public boolean delete(int key) {
    // 查找要删除的节点
    Node current = root;    // 记录当前的节点
    Node parent = root;    // 记录当前节点的父节点
    boolean isLeftChild = true;    // 是否为左子节点的标志位
    while (current.iData != key) {
        parent = current;
        if (key < current.iData) {
            isLeftChid = true;
            current = current.leftChild;
        } else {
            isLeftChid = false;
            current = current.rightChild;
        }
        if (current = null)
            return false;
    }
    // 如果没有子节点
    if (current.leftChild == null && current.rightChild == null) {
        if (current == root)    // 如果是根节点 
            root = null;
        else if (isLeftChild)    // 如果这个节点在左边
            parent.leftChild = null;    // 将其父节点的左节点的索引置为null
        else
            parent.rightChild = null;    // 否则将其父节点的右节点的索引置为null
    }
}

处理情况1：找到要删除的节点，此节点没有子叶节点 ，直接将该节点的父节点对其的引用置为null。

对于情况2：

// 连接上面的 delete 方法
else if(current.rightChild == null) {    // 如果这个节点的右边为空，左边还有相应的连接
    if (current == root)                 // 如果这个节点为 根节点
        root = current.lefeChild;        // 那么直接将根节点替换为 原根节点的左子节点
    else if (isLeftChild)                // 如果这个节点为一个左子节点
        parent.leftChild = current.leftChild;    // 让其父节点对于左子节点的连接直接连向要删除节点的左子节点
    else                                 // 这是一个右子节点
        parent.rightChild = current.leftChild;   // 让其父节点对于右子节点的连接直接连向要伤处节点的左子节点
} else if (current.leftChild == null) {  // 如果这个节点的左边为空，右边还有相应的连接
    if (current == root)                 // ----->   同上
        root = current.rightChild;
    else if  (isLeftChild)
        parent.leftChild = current.rightChild;
    else
        parent.rightChild = current.rightChild;
}

处理情况2：由于要删除的节点还存在有一个子叶节点，所以直接将父节对其的引用，变到其的子叶节点。（简单讲就是让其的一个子节点代替他）

对于情况3：（最复杂）

// 连接上面的delete代码 
else {
     Node successor = getSuccessor(current);    // 在这获取到后继节点
     if (current == root)    // 如果要删除的节点为 根，那么直接让后继节点代替根
         root = successor;
     else if (isLeftChild)    // 如果要删除的节点在 当前节点的左边 那么让其父节点对左子节点的引用 直接指向后继节点
         parent.leftChild = successor;
     else                    // 否则 父节点应该将对右子节点的引用 直接指向后继节点
         parent.rightChild = successor;
     successor.leftChild = current.leftChild; // 统一处理后继节点的左边子树：让后继节点的左引用 直接与删除节点的左子树相连
    }
    return true;
}

// 获取后继节点的方法
private Node getSuccessor (Node delNode) {
    // 后继节点的父节点
    Node successorParent = delNode;
    // 后继节点
    Node successor = delNode;
    // 当前节点
    Node current = delNode.rightChild;
    while (current != null) {
        // 后继节点父节点首先保存后继节点的状态
        successorParent = successor;
        // 后继节点 不断的向左更新
        successor = current;
        current = current.leftChild;
    }
    // 假如我们找到的后继节点不直接是 要删除节点的右节点  而是在其右节点那条子树上面最小的一个节点
    if (successor != delNode.rightChild) {
        // 后继节点的父节点断开其与后继节点左边的引用，重新连接上后继节点的右子节点（因为后继节点是没有左子节点的，锁以要保存之前树的状态，还要把后继节点的右子节点处理一下，不管 其存在不存在）
        successorParent.leftChild = successor.rightChild;
        // 这时候后继节点的右边已经空了 上一条语句已经将其给了自己父节点的左子节点    然后让后继节点的右边 连接要删除节点的右子树
        successor.rightChild = delNode.rightChild;
    }
    return successor;    
}

处理情况3：对于要删除的节点有两个子叶节点的，这个删除的过程中，比较复杂的过程就是寻找代替要删除节点的后继节点，这个节点具有的特征就是，这个节点要比被删除的节点大，但是在比被删除节点大的节点中，这个节点应该是最小的。在寻找后继节点分过程中，涉及到一种算法，也可以说是一种思维方式，首先，找到被删除节点的右子节点（绝对可以找到，因为这个节点是由两个子节点的），这个顺理成章，因为右子节点和其下可能存在的右子树的所有值，绝对比要删除的节点的值大，但是要在这些所有比较大的值中找到最小的那个，所以继续向被删除节点的右子节点的左子节点查找，一直找左子节点，知道没有左子节点的时候，那么那个节点就是我们要找的后继节点，但是这时候还是有两种情况，第一种是：被删除的节点的右子节点直接是后继节点，因为它没有字节的左子节点；还有一种就是，我们在要删除的节点的右子节点的子树上找到那棵树上最小的值；针对这两种不同的情况，要采取不同的方式去应对。

---

对于二叉树的删除数据的问题，有的程序员还有另外一种处理方式，就是在编写 Node 节点类的时候，在其中维护一个标志位–>这个节点是否已经被删除

class Node {
    public int iData;
    public double dData;
    public Node leftChild;
    public Node rightChild;
    public boolean isDeleted;
}

如果树中的某个节点已经要被删除，则将该标志位置为true，在遍历的时候加一层判断，若是已经删除的节点，则不给予遍历，这样的删除方法，虽然在本质上来说被删除的节点依然在树结构中，但是在某种情况下可能会非常的适用，比如树结构用于存储员工的信息，员工虽然已经离职，但是员工的数据应该依然保存下来。