二叉树的遍历、查找、删除Java实现

二叉树

1、二叉树遍历
1）前序遍历
（1）输出当前节点；
（2）若当前节点的左子节点不为空，则递归前序遍历左子树；
（3）若当前节点的右子节点不为空，则递归前序遍历右子树
2）中序遍历
（1）若当前节点的左子节点不为空，则递归中序遍历左子树；
（2）输出当前节点；
（3）若当前节点的右子节点不为空，则递归中序遍历右子树；
3）后序遍历
（1）若当前节点的左子节点不为空，则递归中序遍历左子树；
（2）若当前节点的右子节点不为空，则递归中序遍历右子树；
（3）输出当前节点；
2、二叉树查找
1）前序查找
（1）判断当前节点是否为查找节点，若是，则返回当前节点；
（2）若不是，则判断当前节点的左子节点是否为空；
（3）若不为空，则前序遍历查找左子树；
（4）若找到，则返回该节点；
（5）若找不到，则判断当前节点的右子节点是否为空；
（6）若不为空，则前序遍历查找右子树；
（7）最后，输出右子树遍历结果。
2）中序查找
3）后续查找
3、二叉树删除
1）规则：
若为叶子节点，则删除节点；若为非叶子节点，则删除子树；
2）实现过程
（1）判断根节点是否为空，若为空，则无法删除；
（2）若不为空，则判断根节点是否为删除节点，若是则把根节点置为空；
（3）若根节点不是删除节点，则把根节点作为当前节点；
（4）判断当前节点的左子节点和右子节点是否为删除节点，若是，则将其左子节点或右子节点置为空；
（5）若不是，则先后遍历删除左子树和右子树。

class BinaryTree{
	Node root;
	// 遍历
	public void preOrder(){
		if(this.root != null){
			this.root.preOrder();
		}else{
			System.out.println("二叉树为空");
		}
	}
	public void midOrder(){
		if(this.root != null){
			this.root.midOrder();
		}else{
			System.out.println("二叉树为空");
		}
	}
	public void postOrder(){
		if(this.root != null){
			this.root.postOrder();
		}else{
			System.out.println("二叉树为空");
		}
	}
	// 查找
	public Node preOrderSearch(int no){
		if(root != null){
			return root.preOrderSearch(no);
		}else{
			return null;
		}
	}
	public Node midOrderSearch(int no){
		if(root != null){
			return root.midOrderSearch(no);
		}else{
			return null;
		}
	}
	public Node postOrderSearch(int no){
		if(root != null){
			return root.postOrderSearch(no);
		}else{
			return null;
		}
	}
	public void delete(int no){
		if(root != null){
			if(root.no == no){
				root = null;
			}else{
				root.delete(no);
			}
		}else{
			System.out.println("二叉树为空");
		}
	}
}

class Node{
	int no;
	String name;
	public Node(int no, String name){
		this.no = no;
		this.name = name;
	}
	public String toString(){
		return "Node=[no=" + no +", name=" + name +"]";
	}
	// 前序遍历
	public void preOrder(){
		System.out.println(this);
		if(this.left != null){
			this.left.preOrder();
		}
		if(this.right != null){
			this.right.preOrder();
		}
	}
	// 中序遍历
	public void midOrder(){
		if(this.left != null){
			this.left.midOrder();
		}
		System.out.println(this);
		if(this.right != null){
			this.right.midOrder();
		}
	}
	// 后序遍历
	public void postOrder(){
		if(this.left != null){
			this.left.postOrder();
		}
		if(this.right != null){
			this.right.postOrder();
		}
		System.out.println(this);
	}
	// 前序遍历查找
	public Node preOrderSearch(int no){
		if(this.no == no){
			return this;
		}
		Node newNode = null;
		if(this.left != null){
			newNode = this.left.preOrderSearch(no);
		}
		if(newNode != null){
			return newNode;
		}
		if(this.right != null){
			newNode = this.right.preOrderSearch(no);
		}
		return newNode;
	}
	// 中序遍历查找
	public Node midOrderSearch(int no){
		Node newNode = null;
		if(this.left != null){
			newNode = this.left.midOrderSearch(no);
		}
		if(newNode != null){
			return newNode;
		}
		if(this.no == no){
			return this;
		}
		if(this.right != null){
			newNode = this.right.midOrderSearch(no);
		}
		return newNode;
	}
		// 后序遍历查找
	public Node postOederSearch(int no){
		Node newNode = null;
		if(this.left != null){
			newNode = this.left.postOrderSearch(no);
		}
		if(newNode != null){
			return newNode;
		}
		if(this.right != null){
			newNode = this.right.postOrderSearch(no);
		}
		if(newNode != null){
			return newNode;
		}
		if(this.no == no){
			return this;
		}
		return newNode;
	}
	// 删除节点
	public void delete(int no){
		if(this.left != null && this.left.no == no){
			this.left = null;
			return;
		}
		if(this.right != null && this.right.no == no){
			this.right = null;
			return;
		}
		if(this.left != null){
			this.left.delete(no);
		}
		if(this.right != null){
			this.right.delete(no);
		}
	}
}