二叉树遍历应用实例(前序,中序,后序)

1. 思路：

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

2. 代码实现

   package com.hanlin.tree;
   
   public class BinaryTreeDemo {
       public static void main(String[] args) {
           BinaryTree binaryTree = new BinaryTree();
           HeroNode root = new HeroNode(1, "root");
           HeroNode node2 = new HeroNode(2, "node2");
           HeroNode node3 = new HeroNode(3, "node3");
           HeroNode node4 = new HeroNode(4, "node4");
   
           root.setLeft(node2);
           root.setRight(node3);
           node3.setRight(node4);
   
           binaryTree.setRoot(root);
   
           System.out.println("前序遍历结果为：");
           binaryTree.preOrder();
           System.out.println("中序遍历结果为：");
           binaryTree.infixOrder();
           System.out.println("后序遍历结果为：");
           binaryTree.postOrder();
       }
   }
   
   /**
    * 创建一个二叉树对象
    */
   class BinaryTree{
       private HeroNode root;
   
       public void setRoot(HeroNode 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("当前二叉树为空，无法遍历！");
           }
       }
   }
   
   /**
    * 创建一颗树的一个数据节点
    */
   class HeroNode{
       private int no;
       private String name;
       private HeroNode left;
       private HeroNode right;
   
       public HeroNode(int no, String name) {
           this.no = no;
           this.name = name;
       }
   
       @Override
       public String toString() {
           return "HeroNode{" +
                   "no=" + no +
                   ", name='" + name + '\'' +
                   '}';
       }
   
       public int getNo() {
           return no;
       }
   
       public void setNo(int no) {
           this.no = no;
       }
   
       public String getName() {
           return name;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   
       public HeroNode getLeft() {
           return left;
       }
   
       public void setLeft(HeroNode left) {
           this.left = left;
       }
   
       public HeroNode getRight() {
           return right;
       }
   
       public void setRight(HeroNode right) {
           this.right = right;
       }
   
       /**
        * 实现前序遍历
        */
       public void preOrder(){
           //先输入父节点
           System.out.println(this);
           //递归向左子数前序遍历
           if(this.left != null) {
               this.left.preOrder();
           }
           //递归向右子数前序遍历
           if(this.right != null) {
               this.right.preOrder();
           }
       }
   
       /**
        * 实现中序遍历
        */
       public void infixOrder(){
           //1，递归向左子数中序遍历
           if(this.left != null) {
               this.left.infixOrder();
           }
           //2，输出父节点
           System.out.println(this);
           //3，递归向右子数中序遍历
           if(this.right != null) {
               this.right.infixOrder();
           }
       }
   
       /**
        * 实现后序遍历
        */
       public void postOrder(){
           //1，递归向左子树后序遍历
           if(this.left != null) {
               this.left.postOrder();
           }
           //2，递归向右子树后序遍历
           if(this.right != null) {
               this.right.postOrder();
           }
           //3，输出当前节点
           System.out.println(this);
       }
   }