二叉树：树结构

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

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

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

树的术语：

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：

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，在遍历的时候加一层判断，若是已经删除的节点，则不给予遍历，这样的删除方法，虽然在本质上来说被删除的节点依然在树结构中，但是在某种情况下可能会非常的适用，比如树结构用于存储员工的信息，员工虽然已经离职，但是员工的数据应该依然保存下来。！