算法与数据结构的复习——遍历二叉树、删除节点

/**
 * 
 */
package ch10;
public class Tree {

	// 树根节点
	public Node root;

	// 插入节点
	public void insert(long value) {
		Node node = new Node(value);
		Node current = root;
		Node parent;
		// 判断一下是不是第一次插入
		if (current == null) {
			root = node;
		} else {
			while (true) {
				// 记录上一个节点的引用
				parent = current;
				if (current.data > value) {
					current = current.leftNode;
					if (current == null) {
						parent.leftNode = node;
						return;
					}
				} else {
					current = current.rightNode;
					if (current == null) {
						parent.rightNode = node;
						return;
					}
				}
			}
		}
	}

	public Node find(long value) {
		Node current = root;
		while (true) {
			if (current.data != value) {
				if (current.data > value) {
					current = current.leftNode;
					if (current == null) {
						return null;
					}
				} else {
					current = current.rightNode;
					if (current == null) {
						return null;
					}
				}
			} else {
				return current;
			}
		}
	}

	// 前序遍历递归实现
	public void frontOrder(Node localNode) {
		if (localNode != null) {
			System.out.print(localNode.data + " ");
			frontOrder(localNode.leftNode);
			frontOrder(localNode.rightNode);
		}
	}

	// 中序遍历递归实现
	public void middleOrder(Node localNode) {
		if (localNode != null) {
			middleOrder(localNode.leftNode);
			System.out.print(localNode.data + " ");
			middleOrder(localNode.rightNode);
		}
	}

	// 后序遍历递归实现
	public void endOrder(Node localNode) {
		if (localNode != null) {
			endOrder(localNode.leftNode);
			endOrder(localNode.rightNode);
			System.out.print(localNode.data + " ");
		}
	}

	// 删除二叉树节点（删除叶子节点）
	public boolean delete(long value) {

		// 引用当前节点
		Node current = root;
		// 引用当前节点的父节点
		Node parent = root;
		// 判断当前节点是否为父节点的左子节点
		boolean isLeftChildren = true;

		// 查找当前节点
		while (current.data != value) {
			if (value < current.data) {
				parent = current;
				current = current.leftNode;
				isLeftChildren = true;
			} else {
				parent = current;
				current = current.rightNode;
				isLeftChildren = false;
			}
			// 差找不到数据
			if (current == null) {
				return false;
			}
		}

		// 当删除的节点为叶子节点时
		if (current.leftNode == null && current.rightNode == null) {
			if (isLeftChildren) {
				parent.leftNode = null;
			} else {
				parent.rightNode = null;
			}
		} else if (current.rightNode == null) {
			// 如果当前节点为根节点
			if (current == root) {
				root = null;
			}

			// 有一个左子节点
			if (isLeftChildren) {
				parent.leftNode = current.leftNode;
			} else {
				parent.rightNode = current.leftNode;
			}
		} else if (current.leftNode == null) {
			// 如果当前节点为根节点
			if (current == root) {
				root = null;
			}
			// 有一个左子节点
			if (isLeftChildren) {
				parent.leftNode = current.rightNode;
			} else {
				parent.rightNode = current.rightNode;
			}
		} else {
			System.out.println("第三项");
			// 当要删除的节点有两个子节点，需要找到当前节点的中序后继节点
			Node successor = findSuccessor(current);
			if (current == root) {
				root = successor;
			} else if (isLeftChildren) {
				parent.leftNode = successor;
			} else {
				parent.rightNode = successor;
			}
		}

		return true;
	}

	// 查找当前要删除的节点的中序后继节点
	public Node findSuccessor(Node delNode) {
		Node successor = delNode;
		Node successorParent = delNode;
		Node current = delNode.rightNode;
		while (current != null) {
			successorParent = current;
			successor = current;
			current = current.leftNode;
		}

		// 当所查找的中序后继节点不是要删除节点的右子节点时
		if (delNode.rightNode != successor) {
			// 将中序后继节点的右子节点赋给中序后继节点的父节点的左子节点
			successorParent.leftNode = successor.rightNode;
			delNode.rightNode = delNode.rightNode;
		}
		return successor;
	}
}