二叉树的前中后序排序和查找

二叉树

分为
完全二叉树：最后一层的叶子节点从左往右连续，倒数第二层叶子节点从左往右连续

满二叉树：叶子完整的树，节点数为2^n-1,(n为层数)

平衡二叉树：又叫平衡搜索二叉树，节点的高度差不会超过1，子节点也可以看作是二叉树

二叉树代码实现前中后排序

二叉树 代码

package com.how2java.tmallweb_springboot.test;

/**
 * 二叉树实现前中后排序
 */
public class Tree {

    //根节点
   HeroNode root;
   public Tree(HeroNode root){
       this.root = root;
   }

   //前序遍历(中间节点最先遍历)
    public void firstOrder(HeroNode node){
       //首先输出中间节点
        System.out.println(node.name);
       //递归输出左边节点的(递归就是将左边节点一次性前序遍历结束)
       if(node.left != null){
           firstOrder(node.left);
       }
       //从左边节点尾部又开始右边子节点的输出
        if(node.right != null){
           firstOrder(node.right);
        }
    }

   //中序遍历
   public void midOrder(HeroNode node){
        //一直走到最底层的左叶子
        if(node.left != null){
            midOrder(node.left);
        }
        //中间节点
       System.out.println(node.name);
       //再是右子树
       if(node.right != null){
           midOrder(node.right);
       }
   }

   //后序遍历(中间节点放在最后遍历)
    public void lastOrder(HeroNode node){
       if(node.left != null){
           lastOrder(node.left);
       }
       if(node.right != null){
           lastOrder(node.right);
       }
        System.out.println(node.name);
    }

}

/**
 * 节点类
 */
class HeroNode{
    int age;//年龄
    String name;//名字
    HeroNode left;//左子节点
    HeroNode right;//右子节点
    public HeroNode(String name,int age){
        this.age = age;
        this.name = name;
    }
}

测试代码

    public static void main(String[] args) {
        HeroNode hero1 = new HeroNode("1",21);
        HeroNode hero2 = new HeroNode("2",20);
        HeroNode hero3 = new HeroNode("3",22);
        HeroNode hero4 = new HeroNode("4",23);
        HeroNode hero5 = new HeroNode("5",24);
        hero1.left = hero2;
        hero1.right = hero3;
        hero2.left = hero4;
        hero2.right = hero5;
        Tree tree = new Tree(hero1);
        //前序遍历
        tree.firstOrder(tree.root);//1 2 4 5 3
        System.out.println("**********");

        //中序遍历
        tree.midOrder(tree.root);
        System.out.println("**********");//4 2 5 1 3
        
        //后续遍历
        tree.lastOrder(tree.root);//4 5 2 3 1
    }

二叉树的前中后序查找

重点：回溯
递归结束之后需要用一个HeroNode来保存下一次遍历的结果，并满足条件时返回来。
就是下面这两行代码：
HeroNode resHero = null;
resHero = this.right.findLastOrder(no);
resHero = this.left.findFirstOrder(no);

步骤：

class HeroNode{
	private int no;
	private String name;
	private HeroNode left;
	private HeroNode right;
	
	//前序遍历
	public void firstOrder(){
		System.out.println(this);//输出中间的节点
		//向左递归
		if(this.left != null){//输出左节点
			this.left.firstOrder();
		}
	    //向右递归
		if(this.right != null){//输出右节点
			this.right.firstOrder();
		}
	}
	//中序遍历
	public void midOrder(){
		//向左递归
		if(this.left != null){
			this.left.midOrder();
		}
		System.out.println(this);//输出中间的节点
	    //向右递归
		if(this.right != null){
			this.right.midOrder();
		}
	}
	//后序遍历
	public void lastOrder(){
		//向左递归
		if(this.left != null){
			this.left.lastOrder();
		}
		//向右递归
		if(this.right != null){
			this.right.lastOrder();
		}
		System.out.println(this);//输出中间的节点
	}
	
	//前序查找
	public HeroNode findFirstOrder(int no){
		if(this.no == no){//查看中间的是否为要找的
			return this;
		}
		HeroNode resHero = null;
		if(this.left != null){//查看左边是否为要找的(左边为空时跳过)
			resHero = this.left.findFirstOrder(no);
		}
		if(resHero != null){//这里是一旦找到就会沿着回溯将找到的返回到最开始的递归
			return resHero;//如果左边的是要找的，就不会是null，就要返回
		}
		if(this.right != null){//查找右边那个是不是要找的(左边查找完开始右边查找)
			resHero = this.right.findFirstOrder(no);
		}
		return resHero;
	}
	//中序查找
	public HeroNode findMidOrder(int no){
		HeroNode resHero = null;
		if(this.left != null){//从左边的节点开始
			resHero = this.left.findMidOrder(no);//这个是为了一路递归使用
		}
		if(resHero != null){//如果左边找到了就直接沿着回溯一路将值返回回去
			return resHero;
		}
		if(this.no == no){//查看当前中间节点是否为要找的节点
			return this;
		}
		if(this.right != null){//如果左边节点没有，就会从最左边最下面的节点开始从右节点开始遍历
			resHero = this.right.findMidOrder(no);
		}
		return resHero;//这里也是给右节点回溯用
	}
	//后序查找
	public HeroNode findLastOrder(int no){
		HeroNode resHero = null;
		if(this.left != null){//将节点跳转到最左边
			resHero = this.left.findLastOrder(no);
		}
		if(resHero != null){
			return resHero;//左节点的回溯
		}
		if(this.right != null){//将节点跳到此节点的最右边节点
			resHero = this.right.findLastOrder(no);
		}
		if(resHero != null){
			return resHero;//右节点的回溯
		}
		if(this.no == no){
			return this;
		}
		return resHero;//回溯(在整个都没有找到的情况下)
	}
}