二叉搜索树、二叉查找树、二叉排序树

基本的二叉树结构可点此查看

二叉搜索树，又称二叉查找树、二叉排序树
对于树结构中不合理的根节点选取，可能会导致此树形结构退化为链表结构，因此有更进一步的自平衡二叉树，如红黑树等，本文不做探讨。

本示例二叉树结构如下图：

树结构代码如下：

package structure;

// 节点类
class Node {
	int data;
	Node left = null;
	Node right = null;

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

	@Override
	public String toString() {
		return "Node [data=" + data + ", left=" + left.data + ", right=" + right.data + "]";
	}
}

// 二叉树结构类
public class BinarySearchTree {
	// 根节点
	Node root = null;

	// 添加节点
	private Node addNode(Node node, int data) {

		if (node == null) {
			return new Node(data);
		}

		if (data < node.data) {
			node.left = addNode(node.left, data);
		}

		if (data > node.data) {
			node.right = addNode(node.right, data);
		}

		// 最终为root节点
		return node;
	}

	// 重载，暴露给外界的添加方法
	public void addNode(int data) {
		this.root = addNode(this.root, data);
	}

	// 前序遍历
	private void perEachTree(Node node) {
		if (node != null) {
			System.out.print(node.data + " ");
			perEachTree(node.left);
			perEachTree(node.right);
		}
	}

	// 重载，暴露给外界的前序遍历
	public void perEachTree() {
		this.perEachTree(this.root);
		System.out.println();
	}

	// 中序遍历
	private void midEachTree(Node node) {
		if (node != null) {
			;
			midEachTree(node.left);
			System.out.print(node.data + " ");
			midEachTree(node.right);
		}
	}

	// 重载，暴露给外界的中序遍历
	public void midEachTree() {
		this.midEachTree(this.root);
		System.out.println();
	}

	// 后序遍历
	private void endEachTree(Node node) {
		if (node != null) {
			endEachTree(node.left);
			endEachTree(node.right);
			System.out.print(node.data + " ");
		}
	}

	// 重载，暴露给外界的后序遍历
	public void endEachTree() {
		this.endEachTree(this.root);
		System.out.println();
	}

	// 查找结点
	private Node findNode(Node node, int data) {

		if (node == null) {
			return null;
		}

		if (data == node.data) {
			return node;
		}

		return data < node.data ? findNode(node.left, data) : findNode(node.right, data);
	}
	
	// 重载 暴露给外界的节点查找
	public void findNode(int data) {
		Node node = findNode(this.root,data);
		
		if(node != null) {
			System.out.println(node);
		}else {
			System.out.println("未找到");
		}
	}
	
	/**
	 * 删除节点	有三种情况
	 * 1.删除的节点没有子节点
	 * 2.删除的节点有一个子节点
	 * 3.删除的节点有两个子节点
	 * 
	 * 本方法采用前序删除
	 * 
	 * @param node	从哪个节点开始查找删除
	 * @param data	要删除的数据
	 * @return Node 返回的是根节点
	 */
	private Node deleteNode(Node node, int data) {
		
		if(node == null) {
			return null;
		}
		
		// 找到了  执行删除
		if(data == node.data) {
			// 1.删除的节点没有子节点
			if(node.left == null && node.right == null) {
				return null;
			}
			
			// 2.删除的节点有一个子节点
			if(node.left == null) {
				return node.right;
			}

			if(node.right == null) {
				return node.left;
			}

			// 3.1 删除的节点有两个子节点
			// 查找右子树中最小值
			int minData = findSmallValue(node.right);
			
			// 3.2 变量值替换
			node.data = minData;
			
			// 3.3 递归以第一或第二种情况进一步清除数据
			node.right = deleteNode(node.right, minData);
			
		}
		
		// 没找到 接着找
		if(data < node.data) {
			node.left = deleteNode(node.left, data);
		}

		// 没找到 接着找
		if(data > node.data) {
			node.right = deleteNode(node.right, data);
		}

		// 返回节点
		return node;
	}
	
	
	/**
	 * 寻找某节点下的最小值
	 * 
	 * @param node 	开始查找的节点
	 * @return	最小的值
	 */
	private int findSmallValue(Node node) {
		while(node.left != null) {
			// 值最小的节点赋值
			node = node.left;
		}
		
		return node.data;
	}
	
	/**
	 * 重载 暴露给外界的删除节点方法
	 * @param data
	 * @return
	 */
	public void deleteNode(int data) {
		this.deleteNode(this.root, data);
	}
}

测试用例如下：

package structure;

public class BinarySearchTreeTest {

	public static void main(String[] args) {
		BinarySearchTree bTree = new BinarySearchTree();
	
		bTree.addNode(100);
		bTree.addNode(50);
		bTree.addNode(200);
		bTree.addNode(300);
		bTree.addNode(10);
		bTree.addNode(80);
		bTree.addNode(70);
		bTree.addNode(90);
	
		
		// 只有中序遍历才能实现排序打印
		bTree.midEachTree();

		// 查找节点
		bTree.findNode(50);
		bTree.findNode(1000);
		
		// 删除节点
		bTree.deleteNode(70);
		
		// 遍历验证
		bTree.midEachTree();
	}

}

附测试用例执行结果如下：

10 50 70 80 90 100 200 300
Node [data=50, left=10, right=80]
未找到
10 50 80 90 100 200 300