Java 前序中序后序遍历二叉树&查找二叉树的代码实现

1.二叉树的概念

1. 树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树。
2. 二叉树的子节点分为左节点和右节点。
3. 如果该二叉树的所有叶子节点都在最后一层，并且结点总数= 2^n -1 , n 为层数，则我们称为满二叉树。
4. 如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树。
5. 树的遍历
   前序遍历: 先输出父节点，再遍历左子树和右子树
   中序遍历: 先遍历左子树，再输出父节点，再遍历右子树
   后序遍历: 先遍历左子树，再遍历右子树，最后输出父节点
   小结: 看输出父节点的顺序，就确定是前序，中序还是后序
6. 树的查找——查找指定节点
   前序查找：先比较父节点，再遍历左子树和右子树
   中序查找：先遍历左子树，再比较父节点，再遍历右子树
   后序查找：先遍历左子树，再遍历右子树，最后比较父节点

2.前序中序后序遍历二叉树

2.1前序遍历
1.先输出当前节点（初始时是root节点）
2.如果左子节点不为空,则递归继续前序遍历
3.如果右子节点不为空，则递归继续前序遍历

//前序遍历
//1.先输出当前节点（初始时是root节点）
//2.如果左子节点不为空,则递归继续前序遍历
//3.如果右子节点不为空，则递归继续前序遍历
public void preOrder(){
	System.out.println(this);
	if(this.left!=null){
		this.left.preOrder();
	}
	if(this.right!=null){
		this.right.preOrder();
	}
}

2.2中序遍历
1.如果左子节点不为空,则递归继续中序遍历
2.输出当前节点
3.如果右子节点不为空，则递归继续中序遍历

//中序遍历
//1.如果左子节点不为空,则递归继续中序遍历
//2.输出当前节点
//3.如果右子节点不为空，则递归继续中序遍历
public void infixOrder(){
	if(this.left!=null){
		this.left.infixOrder();
	}
	System.out.println(this);
	if(this.right!=null){
		this.right.infixOrder();
	}
}

2.3后序遍历
1.如果左子节点不为空,则递归继续后序遍历
2.如果右子节点不为空，则递归继续后序遍历
3.输出当前节点

//后序遍历
//1.如果左子节点不为空,则递归继续后序遍历
//2.如果右子节点不为空，则递归继续后序遍历
//3.输出当前节点
public void postOrder(){
	if(this.left!=null){
		this.left.postOrder();
	}
	if(this.right!=null){
		this.right.postOrder();
	}
	System.out.println(this);
}

3.前序中序后序查找二叉树

3.1前序查找
1.判断当前结点是否为要查找的结点,如果相等，返回
2.判断左子树是否为空，如果不为空，则递归前序查找
3.判断右子树是否为空，如果不为空，则递归前序查找

//前序查找
//1.判断当前结点是否为要查找的结点,如果相等，返回
//2.判断左子树是否为空，如果不为空，则递归前序查找
//3.判断右子树是否为空，如果不为空，则递归前序查找
public Node preSearch(int val){
	Node resNode=null;
	//判断当前结点
	if(this.val==val){
		return this;
	}
	//在左子树查找
	if(this.left!=null){
		resNode=this.left.preSearch(val);
	}
	//如果在左子树找到，返回
	if(resNode!=null){
		return resNode;
	}
	//在右子树查找
	if(this.right!=null){
		resNode=this.right.preSearch(val);
	}
	//如果在左子树找到，返回
	if(resNode!=null){
		return resNode;
	}
	//若未查找到，返回空
	return null;
}

3.2中序查找
1.判断左子树是否为空，如果不为空，则递归中序查找
2.判断当前结点是否为要查找的结点,如果相等，返回
3.判断右子树是否为空，如果不为空，则递归中序查找

//中序查找
//1.判断左子树是否为空，如果不为空，则递归中序查找
//2.判断当前结点是否为要查找的结点,如果相等，返回
//3.判断右子树是否为空，如果不为空，则递归中序查找
public Node infixSearch(int val){
	Node resNode=null;
	//在左子树查找
	if(this.left!=null){
		resNode=this.left.infixSearch(val);
	}
	//如果在左子树找到，返回
	if(resNode!=null){
		return resNode;
	}
	//判断当前结点
	if(this.val==val){
		return this;
	}
	//在右子树查找
	if(this.right!=null){
		resNode=this.right.infixSearch(val);
	}
	//如果在右子树找到，返回
	if(resNode!=null){
		return resNode;
	}
	//若未查找到，返回空
	return null;
}

3.3后序查找
1.判断左子树是否为空，如果不为空，则递归后序查找
2.判断右子树是否为空，如果不为空，则递归后序查找
3.判断当前结点是否为要查找的结点,如果相等，返回

//后序查找
//1.判断左子树是否为空，如果不为空，则递归后序查找
//2.判断右子树是否为空，如果不为空，则递归后序查找
//3.判断当前结点是否为要查找的结点,如果相等，返回
public Node postSearch(int val){
	Node resNode=null;
	//在左子树查找
	if(this.left!=null){
		resNode=this.left.postSearch(val);
	}
	//如果在左子树找到，返回
	if(resNode!=null){
		return resNode;
	}
	//在右子树查找
	if(this.right!=null){
		resNode=this.right.postSearch(val);
	}
	//如果在右子树找到，返回
	if(resNode!=null){
		return resNode;
	}
	//判断当前结点
	if(this.val==val){
		return this;
	}
	//若未查找到，返回空
	return null;
}

4.具体实现

//定义BinaryTree 二叉树
class BinaryTree{
	private Node root;       //根节点

	public Node getRoot() {
		return root;
	}

	public void setRoot(Node root) {
		this.root = root;
	}
	
	//前序遍历
	public void preOrder(){
		if(this.root!=null){
			this.root.preOrder();
		}
		else{
			System.out.println("当前二叉树为空，无法遍历");
		}
	}
	
	//中序遍历
	public void infixOrder(){
		if(this.root!=null){
			this.root.infixOrder();
		}
		else{
			System.out.println("当前二叉树为空，无法遍历");
		}
	}
	
	//中序遍历
	public void postOrder(){
		if(this.root!=null){
			this.root.postOrder();
		}
		else{
			System.out.println("当前二叉树为空，无法遍历");
		}
	}
	
	//前序查找
	public Node preSearch(int val){
		if(this.root!=null){
			return this.root.preSearch(val);
		}
		else{
			System.out.println("当前二叉树为空，无法遍历");
			return null;
		}
	}
	
	//中序查找
	public Node infixSearch(int val){
		if(this.root!=null){
			return this.root.infixSearch(val);
		}
		else{
			System.out.println("当前二叉树为空，无法遍历");
			return null;
		}
	}
	
	//后序查找
	public Node postSearch(int val){
		if(this.root!=null){
			return this.root.postSearch(val);
		}
		else{
			System.out.println("当前二叉树为空，无法遍历");
			return null;
		}
	}
	
	//删除结点
	public void delNode(int val){
		if(this.root!=null){
			//如果删除的结点是根结点
			if(this.root.getVal()==val){
				this.root=null;
			}
			else{
				this.root.delNode(val);
			}
		}
		else{
			System.out.println("树为空，不能删除");
		}
	}
}

//创建Node结点
class Node{
	private int val;
	private Node left;
	private Node right;
	//构造器
	public Node(int val) {
		super();
		this.val = val;
	}
	public int getVal() {
		return val;
	}
	public void setVal(int val) {
		this.val = val;
	}
	public Node getLeft() {
		return left;
	}
	public void setLeft(Node left) {
		this.left = left;
	}
	public Node getRight() {
		return right;
	}
	public void setRight(Node right) {
		this.right = right;
	}
	@Override
	public String toString() {
		return "Node [val=" + val + "]";
	}
	
	//前序遍历
    //1.先输出当前节点（初始时是root节点）
    //2.如果左子节点不为空,则递归继续前序遍历
    //3.如果右子节点不为空，则递归继续前序遍历
	public void preOrder(){
		System.out.println(this);
		if(this.left!=null){
			this.left.preOrder();
		}
		if(this.right!=null){
			this.right.preOrder();
		}
	}
	
	//中序遍历
	//1.如果左子节点不为空,则递归继续中序遍历
	//2.输出当前节点
	//3.如果右子节点不为空，则递归继续中序遍历
	public void infixOrder(){
		if(this.left!=null){
			this.left.infixOrder();
		}
		System.out.println(this);
		if(this.right!=null){
			this.right.infixOrder();
		}
	}
	
	//后序遍历
	//1.如果左子节点不为空,则递归继续后序遍历
	//2.如果右子节点不为空，则递归继续后序遍历
	//3.输出当前节点
	public void postOrder(){
		if(this.left!=null){
			this.left.postOrder();
		}
		if(this.right!=null){
			this.right.postOrder();
		}
		System.out.println(this);
	}
	
	//前序查找
	//1.判断当前结点是否为要查找的结点,如果相等，返回
	//2.判断左子树是否为空，如果不为空，则递归前序查找
	//3.判断右子树是否为空，如果不为空，则递归前序查找
	public Node preSearch(int val){
		Node resNode=null;
		//判断当前结点
		if(this.val==val){
			return this;
		}
		//在左子树查找
		if(this.left!=null){
			resNode=this.left.preSearch(val);
		}
		//如果在左子树找到，返回
		if(resNode!=null){
			return resNode;
		}
		//在右子树查找
		if(this.right!=null){
			resNode=this.right.preSearch(val);
		}
		//如果在左子树找到，返回
		if(resNode!=null){
			return resNode;
		}
		//若未查找到，返回空
		return null;
	}
	
	//中序查找
	//1.判断左子树是否为空，如果不为空，则递归中序查找
	//2.判断当前结点是否为要查找的结点,如果相等，返回
	//3.判断右子树是否为空，如果不为空，则递归中序查找
	public Node infixSearch(int val){
		Node resNode=null;
		//在左子树查找
		if(this.left!=null){
			resNode=this.left.infixSearch(val);
		}
		//如果在左子树找到，返回
		if(resNode!=null){
			return resNode;
		}
		//判断当前结点
		if(this.val==val){
			return this;
		}
		//在右子树查找
		if(this.right!=null){
			resNode=this.right.infixSearch(val);
		}
		//如果在右子树找到，返回
		if(resNode!=null){
			return resNode;
		}
		//若未查找到，返回空
		return null;
	}
	
	//后序查找
	//1.判断左子树是否为空，如果不为空，则递归后序查找
	//2.判断右子树是否为空，如果不为空，则递归后序查找
	//3.判断当前结点是否为要查找的结点,如果相等，返回
	public Node postSearch(int val){
		Node resNode=null;
		//在左子树查找
		if(this.left!=null){
			resNode=this.left.postSearch(val);
		}
		//如果在左子树找到，返回
		if(resNode!=null){
			return resNode;
		}
		//在右子树查找
		if(this.right!=null){
			resNode=this.right.postSearch(val);
		}
		//如果在右子树找到，返回
		if(resNode!=null){
			return resNode;
		}
		//判断当前结点
		if(this.val==val){
			return this;
		}
		//若未查找到，返回空
		return null;
	}
	
	//递归删除结点
	//1.判断当前结点的左右结点是否满足删除条件,若满足,删除，return
	//2.若左结点不为空，递归删除左子树
	//3.若右结点不为空，递归删除右子树
	public void delNode(int val){
		//如果左子节点不为空且满足删除条件
		if(this.left!=null&&this.left.val==val){
			this.left=null;
			return;
		}
		//如果右子节点不为空且满足删除条件
		if(this.right!=null&&this.right.val==val){
			this.right=null;
			return;
		}
		//如果没有找到，下一层递归删除（左子树，右子树）
		if(this.left!=null){
			this.left.delNode(val);
		}
		if(this.right!=null){
			this.right.delNode(val);
		}
	}
}