Java数据结构——二叉排序树

二叉排序树：

二叉排序树（Binary Sort Tree），又称二叉查找树

对于一棵树，若具有如下性质：

（1）若左子树不空，则左子树上所有节点的值均小于它的根节点的值

（2）若右子树不空，则右子树上所有节点的值均大于它的根节点的值

（3）左、右子树也分别为二叉排序树

则称该树为二叉排序树

对于二叉排序树来说，进行中序遍历，所得到的节点序列恰好是按照升序排列的

对于二叉排序树，并没有严格的定义，故如果二叉排序树中存在值相同的节点，可以将其按照实际需求，放在左子树或右子树中，不做严格要求

---

实现思路：

节点类BinarySortTreeNode中保存数据和指向左右孩子的指针

二叉排序树类BinarySortTree中保存二叉排序树根节点

添加节点：

首先判断根节点是否为空，若为空，则直接将该节点设置为根节点即可，若根节点不为空，则从根节点开始进行递归，每次比较待添加节点值与当前节点值的大小关系，若待添加节点值小于当前节点值，则判断当前节点的左子树是否为空，若为空，则将待添加节点作为当前节点的左孩子，否则从当前节点的左孩子开始进行递归添加，若待添加节点值大于当前节点值，则对右孩子进行类似判断即可

删除节点：

对于节点的删除，可以分为三种情况

（1）待删除节点为叶子节点

（2）待删除节点有一个孩子

（3）待删除节点有两个孩子

对于第一种情况，由于待删除节点为叶子节点，删除后无需对其孩子进行相关调整，故只需要找到该节点的父节点，修改父节点的左右指针即可，这里无需考虑整棵树中只有一个根节点，且根节点即为待删除节点的情况，在具体的删除方法中有特殊处理

对于第二种情况，首先要判断其父节点是否存在，若不存在，则显然待删除结点为根节点，只需将根节点指向对应的左孩子或右孩子即可，若存在，则将其父节点的对应左孩子或右孩子指向待删除节点的左孩子或右孩子即可

对于第三种情况，由于待删除节点有两个孩子，故首先需要对其右子树进行搜索，从右子树根节点开始，向左递归直到无左孩子，即可找到右子树中值最小的节点，用临时变量保存该节点的值，删除该节点，并将刚刚待删除节点的值用该节点替换，该步骤实际上是在右子树中找到一个合适的节点替换待删除结点，也可在左子树中找到最大的节点，寻找方法为从左子树的根节点开始，向右递归

综上所述，对于节点的删除，需查找待删除节点以及待删除节点的父节点，故单独编写这两个方法

对于查找节点，首先传入节点值，从根节点开始递归查找，将传入节点与当前节点进行比较，按照大小关系不同，对左右孩子进行递归查找，直到查找结束返回

对于查找节点的父节点，思路与查找节点类似，只需对递归出口条件稍作更改即可

对于整个删除方法，首先判断根节点是否为空，若为空即二叉树为空，直接返回，否则查找待删除结点，若查找失败则直接返回，否则进一步判断是否根节点的左右孩子均为空，若均为空，意味着待删除结点恰好为根节点，只需将根节点直接置空即可，否则查找待删除结点的父节点，并依次进行三种情况的处理

---

代码实现：

节点类BinarySortTreeNode：

public class BinarySortTreeNode {
	public int data;
	public BinarySortTreeNode left;
	public BinarySortTreeNode right;

	public BinarySortTreeNode(int data) {
		this.data = data;
	}

	//添加节点
	public void add(BinarySortTreeNode node) {
		if (node == null) {
			return;
		}
		if (node.data < this.data) {
			if (this.left == null) {
				this.left = node;
			} else {
				this.left.add(node);
			}
		} else {
			if (this.right == null) {
				this.right = node;
			} else {
				this.right.add(node);
			}
		}
	}

	//查找待删除的节点
	public BinarySortTreeNode search(int data) {
		if (data == this.data) {
			return this;
		} else if (data < this.data) {
			if (this.left == null) {
				return null;
			}
			return this.left.search(data);
		} else {
			if (this.right == null) {
				return null;
			}
			return this.right.search(data);
		}
	}

	//查找待删除节点的父节点
	public BinarySortTreeNode searchParent(int data) {
		if (this.left != null && this.left.data == data || this.right != null && this.right.data == data) {
			return this;
		} else {
			if (this.left != null && data < this.data) {
				return this.left.searchParent(data);
			} else if (this.right != null && data >= this.data) {
				return this.right.searchParent(data);
			} else {
				return null;
			}
		}
	}
	
	//中序遍历
	public void inOrder() {
		if (this.left != null) {
			this.left.inOrder();
		}
		System.out.println(this);
		if (this.right != null) {
			this.right.inOrder();
		}
	}

	@Override
	public String toString() {
		return "BinarySortTreeNode{" + "data=" + data + '}';
	}
}

二叉排序树类BinarySortTree：

public class BinarySortTree {
	public BinarySortTreeNode root;

	//添加节点
	public void add(BinarySortTreeNode node) {
		if (root == null) {
			root = node;
		} else {
			root.add(node);
		}
	}

	//查找待删除的节点
	public BinarySortTreeNode search(int data) {
		if (root == null) {
			return null;
		} else {
			return root.search(data);
		}
	}

	//查找待删除节点的父节点
	public BinarySortTreeNode searchParent(int data) {
		if (root == null) {
			return null;
		} else {
			return root.searchParent(data);
		}
	}

	//查找以node为根节点的二叉排序树的最小节点的值
	public int deleteRightTreeMin(BinarySortTreeNode node) {
		BinarySortTreeNode targetNode = node;
		while (targetNode.left != null) {
			targetNode = targetNode.left;
		}
		delete(targetNode.data);
		return targetNode.data;
	}

	//删除节点
	public void delete(int data) {
		if (root == null) {
			return;
		} else {
			BinarySortTreeNode targetNode = search(data);
			if (targetNode == null) {
				return;
			}
			if (root.left == null && root.right == null) {
				root = null;
				return;
			}
			BinarySortTreeNode parentNode = searchParent(data);
			if (targetNode.left == null && targetNode.right == null) {
				if (parentNode.left != null && parentNode.left.data == data) {
					parentNode.left = null;
				} else if (parentNode.right != null && parentNode.right.data == data) {
					parentNode.right = null;
				}
			} else if (targetNode.left != null && targetNode.right != null) {
				targetNode.data = deleteRightTreeMin(targetNode.right);
			} else {
				if (targetNode.left != null) {
					if (parentNode != null) {
						if (parentNode.left.data == data) {
							parentNode.left = targetNode.left;
						} else {
							parentNode.right = targetNode.left;
						}
					} else {
						root = targetNode.left;
					}
				} else {
					if (parentNode != null) {
						if (parentNode.left.data == data) {
							parentNode.left = targetNode.right;
						} else {
							parentNode.right = targetNode.right;
						}
					} else {
						root = targetNode.right;
					}
				}
			}
		}
	}

	//中序遍历
	public void inOrder() {
		if (this.root != null) {
			this.root.inOrder();
		} else {
			System.out.println("二叉树为空");
		}
	}
}