二叉树遍历小结

声明

文章均为本人技术笔记，转载请注明出处：
[1] https://segmentfault.com/u/yzwall
[2] blog.csdn.net/j_dark/

0 二叉树遍历概述

二叉树遍历：按照既定序，对每个节点仅访问一次；
二叉树非递归遍历思想：参考这篇博文，核心思想是存在重合元素的局部有序保证整体有序，由于二叉树的结构特点，二叉树中的每个节点（除根节点和叶子节点）均属于两个局部的重合元素。对于任一重合元素，保证所在两个局部遍历有序，保证实现整体遍历有序；

• 重合元素所在局部：
  
  • 局部全部有序，遍历该元素并出栈；
  • 局部未全部有序，将未有序局部元素全部入栈。由于栈是LIFO，局部元素按照逆序入栈；

二叉树节点TreeNode声明

public class TreeNode {    public int val;    public TreeNode left, right;    public TreeNode(int val) {        this.val = val;        this.left = this.right = null;    }}

1 前序遍历

• lintcode 二叉树的前序遍历

1.1 非递归实现

public class Solution {    private class Pair {        public TreeNode node;        public boolean isVisited;        public Pair(TreeNode node, boolean isVisited) {            this.node = node;            this.isVisited = isVisited;        }    }    public ArrayList<Integer> preorderTraversal(TreeNode root) {        ArrayList<Integer> list = new ArrayList<Integer>();        if (root == null) {            return list;        }        ArrayDeque<Pair> stack = new ArrayDeque<Pair>();        stack.push(new Pair(root, false));        while (!stack.isEmpty()) {            Pair top = stack.pop();            // 重合节点完成所有局部有序，弹出            if (top.isVisited) {                list.add(top.node.val);            } else {                // reverse: right -> left -> root                if (top.node.right != null) {                    stack.push(new Pair(top.node.right, false));                }                               if (top.node.left != null) {                    stack.push(new Pair(top.node.left, false));                }                stack.push(new Pair(top.node, true));            }        }        return list;    }}

1.2 递归实现

public class Solution {    public ArrayList<Integer> preorderTraversal(TreeNode root) {        ArrayList<Integer> list = new ArrayList<Integer>();        if (root == null) {            return list;        }        traverse(list, root);        return list;    }    private void traverse(ArrayList<Integer>list, TreeNode root) {        if (root == null) {            return;        }        list.add(root.val);        traverse(list, root.left);        traverse(list, root.right);    }}

2 中序遍历

• lintcode 二叉树的中序遍历

2.1 非递归实现

public class Solution {    private class Pair {        public TreeNode node;        public boolean isVisited;        public Pair(TreeNode node, boolean isVisited) {            this.node = node;            this.isVisited = isVisited;        }    }    public ArrayList<Integer> inorderTraversal(TreeNode root) {        ArrayList<Integer> list = new ArrayList<Integer>();        if (root == null) {            return list;        }        ArrayDeque<Pair> stack = new ArrayDeque<Pair>();        stack.push(new Pair(root, false));        while (!stack.isEmpty()) {            Pair top = stack.pop();            if (top.isVisited) {                list.add(top.node.val);            } else {                // reverse: right -> root -> left                if (top.node.right != null) {                     stack.push(new Pair(top.node.right, false));                }                stack.push(new Pair(top.node, true));                if (top.node.left != null) {                     stack.push(new Pair(top.node.left, false));                }            }        }        return list;    }}

2.2 递归实现

public class Solution {    public ArrayList<Integer> inorderTraversal(TreeNode root) {        ArrayList<Integer> list = new ArrayList<Integer>();        if (root == null) {            return list;        }        traverse(list, root);        return list;    }    private void traverse(ArrayList<Integer>list, TreeNode root) {        if (root == null) {            return;        }        traverse(list, root.left);        list.add(root.val);        traverse(list, root.right);    }}

3 后序遍历

• lintcode 二叉树的后序遍历

3.1 非递归实现

public class Solution {    private class Pair {        public TreeNode node;        public boolean isVisited;        public Pair(TreeNode node, boolean isVisited) {            this.node = node;            this.isVisited = isVisited;        }    }    public ArrayList<Integer> postorderTraversal(TreeNode root) {        ArrayList<Integer> list = new ArrayList<Integer>();        if (root == null) {            return list;        }        ArrayDeque<Pair> stack = new ArrayDeque<Pair>();        stack.push(new Pair(root, false));        while (!stack.isEmpty()) {            Pair top = stack.pop();            if (top.isVisited) {                list.add(top.node.val);            } else {                // reverse: root -> right -> left                stack.push(new Pair(top.node, true));                if (top.node.right != null) {                     stack.push(new Pair(top.node.right, false));                }                if (top.node.left != null) {                     stack.push(new Pair(top.node.left, false));                }            }        }        return list;    }}

3.2 递归实现

public class Solution {    public ArrayList<Integer> postorderTraversal(TreeNode root) {        ArrayList<Integer> list = new ArrayList<Integer>();        if (root == null) {            return list;        }        traverse(list, root);        return list;    }    private void traverse(ArrayList<Integer> list, TreeNode root) {        if (root == null) {            return;        }        traverse(list, root.left);        traverse(list, root.right);        list.add(root.val);    }}

4 层序遍历

• lintcode 二叉树的层序遍历，BFS按层遍历实现

public class Solution {    public ArrayList<ArrayList<Integer>> levelOrder(TreeNode root) {        ArrayDeque<TreeNode> queue = new ArrayDeque<TreeNode>();        ArrayList<ArrayList<Integer>> list = new ArrayList<ArrayList<Integer>>();        if (root == null) {            return list;        }        queue.offer(root);        while (!queue.isEmpty()) {            int level = queue.size();            ArrayList<Integer> levelList = new ArrayList<Integer>();            // 按层BFS遍历            for (int i = 0; i < level; i++) {                TreeNode head = queue.poll();                levelList.add(head.val);                if (head.left != null) {                    queue.offer(head.left);                }                 if (head.right != null) {                    queue.offer(head.right);                }            }            list.add(levelList);        }        return list;    }}