【数据结构】：二叉树的非递归遍历

二叉树的递归遍历

先序遍历：

中序遍历：

后序遍历：

package 二叉树的非递归遍历;

import java.util.Stack;

/**
 * @version 1.0
 * @Author XuHeng
 * @Date 2021/4/1 23:12
 */
class TreeNode {
    char  val;
    TreeNode left;
    TreeNode right;

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

public class Tree {
    public static TreeNode buildTree() {
        // 先构造结点
        TreeNode a = new TreeNode('A');
        TreeNode b = new TreeNode('B');
        TreeNode c = new TreeNode('C');
        TreeNode d = new TreeNode('D');
        TreeNode e = new TreeNode('E');
        TreeNode f = new TreeNode('F');
        TreeNode g = new TreeNode('G');
        TreeNode h = new TreeNode('H');
        TreeNode i = new TreeNode('I');
        TreeNode j = new TreeNode('J');


        a.left = b;
        a.right = c;

        b.left = d;
        b.right = null;

        c.left = e;
        c.right = f;

        d.left = g;
        d.right = h;

        e.left = null;
        e.right = i;

        f.left = null;
        f.right = null;

        g.left = null;
        g.right = null;

        h.left = null;
        h.right = null;

        i.left = null;
        i.right = null;

        return a;
    }
    //先序遍历
    public static void preOrderNoR(TreeNode root) {
        if (root == null) {
            return;
        }
        // 1. 先搞一个栈
        Stack<TreeNode> stack = new Stack<>();
        // 2. 把根节点入栈
        stack.push(root);
        // 3. 循环取栈顶元素并出栈
        while (!stack.isEmpty()) {
            TreeNode cur = stack.pop();
            // 访问该元素
            System.out.print(cur.val);
            // 把右子树入栈
            if (cur.right != null) {
                stack.push(cur.right);
            }
            // 把左子树入栈
            if (cur.left != null) {
                stack.push(cur.left);
            }
        }
        System.out.println();
    }
    //中序遍历
    public static void inOrderNoR(TreeNode root) {
        // 1. 先搞一个栈
        Stack<TreeNode> stack = new Stack<>();
        // 2. 创建一个 cur 从 root 开始执行
        TreeNode cur = root;
        // 3. 第一层循环. 负责从栈里取元素
        while (true) {
            // 第二层循环. 负责往栈里插入元素
            while (cur != null) {
                stack.push(cur);
                cur = cur.left;
            }
            if (stack.isEmpty()) {
                // 如果栈为空, 就直接结束循环
                break;
            }
            // 栈不为空, 就取出栈顶元素并访问
            TreeNode top = stack.pop();
            System.out.print(top.val);

            // 让 cur 指向 top 的右子树, 继续重复执行上述过程
            cur = top.right;
        }
        System.out.println();
    }
    //后序遍历
    public static void postOrderNoR(TreeNode root) {
        if (root == null) {
            return;
        }
        // 先创建一个栈
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        TreeNode prev = null;  // 记录后序遍历中的前一个节点
        while (true) {
            // 让 cur 出发一路往左走, 遇到非空节点都入栈
            while (cur != null) {
                stack.push(cur);
                cur = cur.left;
            }
            // cur 为空的时候, 取栈顶元素看看能不能访问
            if (stack.isEmpty()) {
                break;
            }
            // 栈顶元素不一定能访问. 真正访问的时候再出栈
            // 此时只是通过 peek 来取到这个元素即可
            TreeNode top = stack.peek();
            if (top.right == null || prev == top.right) {
                // 此时这个 top 是可以访问的
                System.out.print(top.val);
                stack.pop();
                prev = top;

                // 如果要是该节点能被访问, 此时 cur 没有变化(仍然是 null)
                // 下一轮循环就仍然是从栈顶这里取一个元素, 判定能不能访问
            } else {
                // 如果访问不了~, 就继续从 top 的右子树出发
                // 重复刚才的过程
                cur = top.right;
            }
        }
        System.out.println();
    }
}

测试： 

package 二叉树的非递归遍历;

import static 二叉树的非递归遍历.Tree.buildTree;

/**
 * @version 1.0
 * @Author XuHeng
 * @Date 2021/4/1 23:27
 */
public class TraversalTest {
    public interface TraversalMethod{
        String TraversalName();
        void Traversal(TreeNode root);
    }
    public static class 先序遍历 implements TraversalMethod{

        @Override
        public String TraversalName() {
            return "先序遍历";
        }

        @Override
        public void Traversal(TreeNode root) {
            Tree.preOrderNoR(root);
        }
    }
    public static class 中序遍历 implements TraversalMethod{

        @Override
        public String TraversalName() {
            return "中序遍历";
        }

        @Override
        public void Traversal(TreeNode root) {
            Tree.inOrderNoR(root);
        }
    }
    public static class 后序遍历 implements TraversalMethod{

        @Override
        public String TraversalName() {
            return "后序遍历";
        }

        @Override
        public void Traversal(TreeNode root) {
            Tree.postOrderNoR(root);
        }
    }

    public static void main(String[] args) {
        TreeNode root= buildTree();
        TraversalMethod[] methods={
          new 先序遍历(),
          new 中序遍历(),
          new 后序遍历()
        };

        for (TraversalMethod traversalMethod : methods){

            System.out.println(traversalMethod.TraversalName()+"的结果是：");
              traversalMethod.Traversal(root);
        }
    }
}

测试结果：