数据结构 No.11 删除二叉树

引言

       删除节点是二叉树操作中最复杂的。在删除之前首先要查找要删除的点。找到节点后，这个要删除的节点可能会有三种情况需要考虑。

1、这个节点是叶子节点，没有子节点。
	这个时候要删除叶子节点，只需要改变改节点的父节点的引用值，将指向该节点的引用设置为null。就可以了
2、该节点有一个子节点。
	改变父节点的引用，将其直接指向要删除节点的子节点
3、该节点有两个子节点
	要删除有两个子节点的节点。就需要使用的它的中序后继来替代该节点

正文

       下面提到的关于插入、查找、中序遍历方法这里就不过多的阐述了，需要了解的，请参考我的上几篇文章。这里主要讲的就是二叉树的删除。

        删除节点：

       有点类似于查找的方法。current = node，也就是从根节点开始遍历，current变量用于记录当前正在使用的节点，parent为当前节点的父节点，主要用于删除节点后维护被删除节点的父子关系。isLeftChild用于记录当前节点是根节点的左子节点还是右子节点。

        下面的while方法的作用就是查找到要删除的节点。循环的条件就是当前节点的数据域是否等于要删除的值，首先把当前节点的保存到parent父节点。然后比较，因为是二叉树，所有比这个节点小的数，在左子树，比这个节点大的数，在右子树。所有如果目标值大于当前值，就将右子节点也就是比当前值大的值赋值给当前值。反之，将左子节点赋值给当前值。然后将对应的isLeftChild赋值。找不到返回false。

         找到这个删除的节点之后，接下来就是删除了。删除分为三种情况，

1. 删除叶子节点：也就是该节点没有子节点。删除叶子节点又分为三种情况：

   是否为根节点	如果是根节点只需要将根节点置为null。
   是否为左子节点	如果是左子节点，就将父节点的左孩子置为null，脱离整个树结构即可
   是否为右子节点	如果是右子节点，就将父节点的右孩子置为null，脱离树结构。注意，这里为删除叶子节点

2. 删除只有一个叶子节点的情况，这里分为只有左子节点和只有右子节点两种情况，每种情况又分为三小种情况。这里只说明，单叶子节点为左子节点，也就是右子节点为null的情况，右子节点的情况和这种相同，只需要将“左”字换成“右”字。
   

   是否为根节点	如果是根节点，就将此节点的左孩子节点赋值给根节点
   是否为左子节点	如果是左子节点，就将此节点的左子节点赋值给当前节点的左子节点
   是否为右子节点	如果是右子节点，就将此节点的右子节点赋值给当前节点的右子节点

3. 删除两个子节点的情况。这里情况比较特殊，删除这个节点之后需要使用这个节点的中序后继节点来替代它，具体中序后继的方法就是找它的右子节点的左孩子的左孩子的左孩子。。。也就是找此二叉树中比当前节点大的最少的那个节点。这里也分为三种情况
   

   是否为根节点	如果是根节点，就将此节点的中序后继节点赋值给此节点
   是否为左子节点	如果是左子节点，就将此节点的中序后继节点赋值给此节点的左子节点
   是否为右子节点	如果是右子节点，就将此节点的中序后继节点赋值给此节点的右子节点

/*
 * 二叉树类
 */
public class Tree {
	// 根节点
	public Node root;

	/**
	 * 插入节点
	 * 
	 * @param value
	 */
	public void insert(long value, String sValue) {
		// 封装节点
		Node newNode = new Node(value, sValue);
		// 引用当前节点
		Node current = root;
		// 引用父节点
		Node parent;
		// 如果root为null，也就是第一插入的时候
		if (root == null) {
			root = newNode;
			return;
		} else {
			while (true) {
				// 父节点指向当前节点
				parent = current;
				// 如果当前指向的节点数据比插入的要大,则向左走
				if (current.data > value) {
					current = current.leftChild;
					if (current == null) {
						parent.leftChild = newNode;
						return;
					}
				} else {
					current = current.rightChild;
					if (current == null) {
						parent.rightChild = newNode;
						return;
					}
				}
			}
		}
	}

	/**
	 * 查找节点
	 * 
	 * @param value
	 */
	public Node find(long value) {
		// 引用当前节点，从根节点开始
		Node current = root;
		// 循环，只要查找值不等于当前节点的数据项
		while (current.data != value) {
			// 进行比较，比较查找值和当前节点的大小
			if (current.data > value) {
				current = current.leftChild;
			} else {
				current = current.rightChild;
			}
			// 如果查找不到
			if (current == null) {
				return null;
			}
		}
		return current;
	}

	/**
	 * 删除节点
	 * 
	 * @param value
	 */
	public boolean delete(long value) {
		// 引用当前节点，从根节点开始
		Node current = root;

		// 应用当前节点的父节点
		Node parent = root;
		// 是否为左节点
		boolean isLeftChild = true;

		while (current.data != value) {
			parent = current;
			// 进行比较，比较查找值和当前节点的大小
			if (current.data > value) {
				current = current.leftChild;
				isLeftChild = true;
			} else {
				current = current.rightChild;
				isLeftChild = false;
			}
			// 如果查找不到
			if (current == null) {
				return false;
			}
		}

		if (current.leftChild == null && current.rightChild == null) {
			// 删除叶子节点，也就是该节点没有子节点
			if (current == root) {
				root = null;
			} else if (isLeftChild) {
				parent.leftChild = null;
			} else {
				parent.rightChild = null;
			}
		} else if (current.rightChild == null) {
			// 删除只有一个叶子节点的情况
			if (current == root) {
				root = current.leftChild;
			} 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;
			}
		} 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;
	}

	/**
	 * 中序遍历
	 */
	public void inOrder(Node localNode) {
		if (localNode != null) {
			// 中序遍历左子树
			inOrder(localNode.leftChild);
			// 访问根节点
			System.out.println(localNode.data + ", " + localNode.sData);
			// 中旬遍历右子树
			inOrder(localNode.rightChild);
		}
	}

	/**
	 * 获得中序后继节点
	 * 
	 * @return
	 */
	private Node getSuccessor(Node delNode) {
		Node successor = delNode;
		Node successorParent = 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;
	}
}

测试类

public class TestTree {
	public static void main(String[] args) {
		Tree tree = new Tree();
		tree.insert(10,"James");
		tree.insert(20,"YAO");
		tree.insert(15,"Kobi");
		tree.insert(3,"Mac");
		tree.insert(4, "Zhangsan");
		tree.insert(90, "Lisi");
		
		tree.delete(3);
		tree.inOrder(tree.root);
	}
}

判断是否为根节点