二叉树:顾名思义就是每个节点都只能有两个子节点的树结构。
为什么要使用树这种结构呢?
树结构通常结合了另外两种数据结构的优点:一种是有序数组,另外一种是链表。 树结构的查询的速度和有序数组一样快,树结构的插入数据和删除数据的速度也和链表一样快。
树的术语:
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,在遍历的时候加一层判断,若是已经删除的节点,则不给予遍历,这样的删除方法,虽然在本质上来说被删除的节点依然在树结构中,但是在某种情况下可能会非常的适用,比如树结构用于存储员工的信息,员工虽然已经离职,但是员工的数据应该依然保存下来。