【死磕算法系列】二叉树的前序中序后序的递归和非递归遍历

一、二叉树的数据结构

1.1 定义树节点

public class TreeNode {
    String val;
    TreeNode left;
    TreeNode right;

    public TreeNode(String val) {
        this.val = val;
    }

    public String getVal() {
        return val;
    }

    public void display() {
        System.out.print(val + "\t");
    }

}

1.2 定义二叉树

public class BinaryTree {

    private TreeNode root = null;

    public BinaryTree(String val) {
        root = new TreeNode(val);
        root.left = null;
        root.right = null;
    }
    public void inOrderTraverse(TreeNode node) {}
    public void preOrderTraverse(TreeNode node) {}
    public void postOrderTraverse(TreeNode node) {}
    public void inOrderByStack(TreeNode node) {}
    public void preOrderByStack(TreeNode node) {}
    public void postOrderByStack(TreeNode node) {}
   }

先序遍历的顺序：根、左、右；
中序遍历的顺序：左、根、右；
后序遍历的顺序：左、右、根 .

二、递归遍历

2.1 中序递归遍历

    public void inOrderTraverse(TreeNode node) {
        if (node == null) {
            return;
        }
        inOrderTraverse(node.left);
        node.display();
        inOrderTraverse(node.right);
    }

2.2 前序递归遍历

    public void preOrderTraverse(TreeNode node) {
        if (node == null) {
            return;
        }
        node.display();
        preOrderTraverse(node.left);
        preOrderTraverse(node.right);
    }

2.3 后序递归遍历

    public void postOrderTraverse(TreeNode node) {
        if (node == null) {
            return;
        }
        postOrderTraverse(node.left);
        postOrderTraverse(node.right);
        node.display();
    }

三、非递归遍历

3.1 中序非递归遍历

    public void inOrderByStack(TreeNode node) {

       if(node == null){ return;}
       Stack<TreeNode> stack = new Stack<TreeNode>();
       while(!stack.isEmpty() || node!=null){
           if(node!=null){ 
               stack.push(node);
               node=head.left;
           }else{ 
               node = stack.pop();
               System.out.print(node.val+"\t")
               node = node.right;
           }
       }

    }

3.2 前序非递归遍历

    public void preOrderByStack(TreeNode node) {
        if(node == null){ 
           return ;
        }
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.add(node);
        TreeNode cur=null;
        while(!stack.isEmpty()){
            cur = stack.pop();
            System.out.println(cur.val);
            if(cur.right != null){
               stack.add(cur.right);
            }
            if(cur.left !=null ){ 
               stack.add(cur.left)
            }
        }
    }

3.3 后序非递归遍历

    public void postByStack(TreeNode node) {
         if (node == null) {
            return;
        }
        Stack<TreeNode> s1 = new Stack<TreeNode>();
        Stack<TreeNode> s2 = new Stack<TreeNode>();
        s1.push(node);
        while (!s1.isEmpty()) {
            node = s1.pop();
            s2.push(node);
            if(node.left!=null){
                s1.push(node.left);
            }

            if(node.right!=null){
                s1.push(node.right);
            }
        }

        while(!s2.isEmpty()){
            System.out.print(s2.pop().val+"\t");
        }
    }

四、测试

构造如下二叉树：

            a
          /   \
          b      c
        /   \   /  \    
       d    e  f    g
           /
          h
            \
              i

public class Main1 {

    public static void main(String[] args) {

        BinaryTree btree = new BinaryTree("a");

        TreeNode node1 = new TreeNode("b");
        TreeNode node2 = new TreeNode("c");
        TreeNode node3 = new TreeNode("d");
        TreeNode node4 = new TreeNode("e");
        TreeNode node5 = new TreeNode("f");
        TreeNode node6 = new TreeNode("g");
        TreeNode node7 = new TreeNode("h");
        TreeNode node8 = new TreeNode("i");

        btree.root.left = node1;
        btree.root.right = node2;
        node1.left = node3;
        node1.right = node4;
        node2.left = node5;
        node2.right = node6;
        node4.left = node7;
        node7.right = node8;

        System.out.println("中序非递归遍历:");
        btree.inOrderTraverse(btree.root);

        System.out.println("\n中序递归遍历:");
        btree.inOrderByStack(btree.root);

        System.out.println("\n前序非递归遍历:");
        btree.preOrderTraverse(btree.root);
        System.out.println("\n前序递归遍历:");
        btree.preOrderByStack(btree.root);

        System.out.println("\n后序非递归遍历:");
        btree.postOrderTraverse(btree.root);
        System.out.println("\n后序递归遍历:");
        btree.postByStack(btree.root);
    }
}

输出结果:

中序非递归遍历:
d   b   h   i   e   a   f   c   g   
中序递归遍历:
d   b   h   i   e   a   f   c   g   
前序非递归遍历:
a   b   d   e   h   i   c   f   g   
前序递归遍历:
a   b   d   e   h   i   c   f   g   
后序非递归遍历:
d   i   h   e   b   f   g   c   a   
后序递归遍历:
d   i   h   e   b   f   g   c   a   

截个图：