Java 排序树实验（实现插入，查找，删除，广义表表示，中序遍历）

实现二叉排序树上的查找算法。具体实现要求：

1. 用二叉链表做存储结构，输入键值序列，建立一棵二叉排序树。
2. 用广义表表示所建二叉树。
3. 按中序遍历这棵二叉排序树。
4. 在二叉排序树上插入结点。
5. 删除二叉排序树上的结点。
6. 在二叉排序树上实现查找算法。

class Node {
	int data;
	Node left;
	Node right;

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

public class Tree {
	Node root;

	// 建树
	public Tree(Node root) {
		this.root = root;
	}

	// 添加结点
	public void add(int data) {
		Node current = root;
		while (true) {
			if (data >= current.data) {
				if (current.right == null) {
					current.right = new Node(data);
					break;
				}
				current = current.right;
			} else {
				if (current.left == null) {
					current.left = new Node(data);
					break;
				}
				current = current.left;
			}
		}
	}

	// 广义表显示二叉树
	public void displayGenList() {
		this.generalList(this);
		System.out.println();
	}// 包装方法

	private void generalList(Tree t) {
		if (t.root != null) {
			System.out.print(t.root.data);
			if (t.root.left != null || t.root.right != null) {
				System.out.print("(");
				generalList(new Tree(t.root.left));
				if (t.root.right != null)
					System.out.print(",");
				generalList(new Tree(t.root.right));
				System.out.print(")");
			}
		}
	}

	// 中序遍历二叉树
	public void displayMidTree() {
		this.midTree(this);
		System.out.println();
	}// 包裝方法

	private void midTree(Tree t) {
		if (t.root != null) {
			if (t.root.left != null || t.root.right != null)
				midTree(new Tree(t.root.left));
			System.out.print(t.root.data + " ");
			if (t.root.right != null)
				midTree(new Tree(t.root.right));
		}
	}

	// 查找算法
	public void find(int target) {
		if (this.find(this, target).root == null)
			System.out.println("找不到");
		else {
			System.out.print("找到了：");
			this.find(this, target).displayGenList();
		}
	}// 包裝方法

	private Tree find(Tree t, int target) {
		if (t.root == null || t.root.data == target)
			return t;
		if (t.root.data > target)
			return t.find(new Tree(t.root.left), target);
		else
			return t.find(new Tree(t.root.right), target);
	}

	// 删除算法
	public void delete(int target) {
		this.delete(this.root, target);
	}

	private Node delete(Node root, int key) {

		if (root == null) {
			return root;
		}
		if (key < root.data) {
			root.left = delete(root.left, key);
			return root;
		}
		if (key > root.data) {
			root.right = delete(root.right, key);
			return root;
		}
		// 开始执行删除操作
		// (1)删除根节点
		if (root.left == null && root.right == null) {
			root = null;
			return root;
		}
		// (2)只有一个child,只有右子树
		if (root.left == null && root.right != null) {
			root = root.right;
			return root;
		}
		// (2)只有一个child,只有左子树
		if (root.right == null && root.left != null) {
			root = root.left;
			return root;
		}
		// (3)有两个child
		if (root.left != null && root.right != null) {
			// 挑选左子树中最大的或者右子树中最小的，替换当前节点，再将替换的节点置空
			int val = findMaxInLeftTree(root.left);
			root.data = val;
			root.left = delete(root.left, val);
			return root;
		}
		return root;

	}

	// 找到左子树中最大的值
	private int findMaxInLeftTree(Node left) {
		if (left.right == null) {
			return left.data;
		}
		return findMaxInLeftTree(left.right);
	}
}

删除部分代码参考自 SUN123565