二叉树的前、中、后序遍历

一、二叉树举例

//       A
//     /   \
//    B     C
//  /  \     \
// D    E     F

二、二叉树实现

public class BinTree {

      static BinTreeNode<String> D = new BinTreeNode<>("D", null, null);

      static BinTreeNode<String> E = new BinTreeNode<>("E", null, null);

      static BinTreeNode<String> F = new BinTreeNode<>("F", null, null);

      static BinTreeNode<String> B = new BinTreeNode<>("B", D, E);

      static BinTreeNode<String> C = new BinTreeNode<>("C", null, F);

      static BinTreeNode<String> A = new BinTreeNode<>("A", B, C);

        static class BinTreeNode<T> {

        /**
         * 数据节点
         */
        T data;

        /**
         * 左节点
         */
        BinTreeNode<T> left;

        /**
         * 右节点
         */
        BinTreeNode<T> right;

        public BinTreeNode(T data, BinTreeNode left, BinTreeNode right) {
            this.data = data;
            this.left = left;
            this.right = right;
        }

        @Override
        public String toString() {
            return data.toString();
        }

        }

}

三、递归实现二叉树遍历

        1）、先序遍历

        public static void preOrder(BinTreeNode<String> root, List<String> list) {

            if (root == null) {
                return;
            }
            list.add(root.data);
            preOrder(root.left, list);
            preOrder(root.right, list);
        }

        2）中序遍历

        public static void middleOrder(BinTreeNode<String> root, List<String> list) {
            if (root == null) {
                return;
            }
            middleOrder(root.left, list);
            list.add(root.data);
            middleOrder(root.right, list);
        }

        3）后序遍历

        public static void backOrder(BinTreeNode<String> root, List<String> list) {
            if (root == null) {
                return;
            }
            backOrder(root.left, list);
            backOrder(root.right, list);
            list.add(root.data);
        }

四、非递归方式实现二叉树遍历

        1）、先序遍历

        public static void preOrder(BinTreeNode<String> root, List<String> list) {
            BinTreeNode<String> p = root;
            Stack<BinTreeNode<String>> stack = new Stack<>();
            while (p != null || !stack.empty()) {
                while (p != null) {
                    list.add(p.data);
                    stack.push(p);
                    p = p.left;
                }

                if (!stack.isEmpty()) {
                    p = stack.pop();
                    p = p.right;
                }
            }
        }

       2）中序遍历

        public static void middleOrder(BinTreeNode<String> root, List<String> list) {
            Stack<BinTreeNode<String>> stack = new Stack<>();
            while (root != null || !stack.isEmpty()) {
                while (root != null) {
                    stack.push(root);
                    root = root.left;
                }

                if (!stack.isEmpty()) {
                    root = stack.pop();
                    list.add(root.data);
                    root = root.right;
                }
            }
        }

    3）后续遍历

        public static void backOrder(BinTreeNode<String> root, List<String> list) {
            Stack<BinTreeNode<String>> stack = new Stack<>();
            BinTreeNode<String> prevNode = null, currNode = root;

            while (currNode != null || !stack.isEmpty()) {
                while (currNode != null) {
                    stack.push(currNode );
                    currNode = currNode.left;
                }
                currNode = stack.peek();

                if (currNode.right == null || currNode.right == prevNode ) {
                    stack.pop();
                    list.add(currNode.data);
                    prevNode = currNode ;
                    currNode = null;
                } else {
                    currNode = currNode.right;
                }
            }
        }