二叉树操作篇 -- 二叉树遍历

二叉树遍历

二叉树的遍历方式主要有四种：

1. 前序遍历：按照“根左右”的顺序遍历
2. 中序遍历：按照“左根右”的顺序遍历。二叉树的特点是左子树小于根，右子树大于根，因此中序遍历的结果是有序排列的
3. 后序遍历：按照“左右根”的顺序遍历
4. 层次遍历：按照每一层进行遍历

如下图所示二叉树：

前序遍历：1 2 4 5 3 6 7
中序遍历：4 2 5 1 6 3 7
后序遍历：4 5 2 6 7 3 1
层次遍历：1 2 3 4 5 6 7

JAVA实现

定义二叉树节点

public class TreeNode {
   int val = 0;
   TreeNode left = null;
   TreeNode right = null;
 }

实现四种遍历

1. 递归法实现前序、中序和后序

/**-----------递归实现--------------------------------*/
// 前序遍历
public void preOrder(TreeNode root,List<Integer> ans){
    if(root == null){
        return ;
    }
    ans.add(root.val);
    preOrder(root.left,ans);
    preOrder(root.right,ans);
}
// 中序遍历
public void inOrder(TreeNode root,List<Integer> ans){
    if(root == null){
        return ;
    }        
    inOrder(root.left,ans);
    ans.add(root.val);
    inOrder(root.right,ans);
}
// 后序遍历
public void postOrder(TreeNode root,List<Integer> ans){
    if(root == null){
        return ;
    }
    postOrder(root.left,ans);
    postOrder(root.right,ans);
    ans.add(root.val);
}

2. 迭代法实现前序、中序和后序

/**-----------迭代实现--------------------------------*/
// 前序遍历
public List<Integer> preorderTraversal(TreeNode root) {
    List<Integer> res = new ArrayList<Integer>();
    Deque<TreeNode> stk = new LinkedList<TreeNode>();
    while (root != null || !stk.isEmpty()) {
        while (root != null) {
            res.add(root.val);
            stk.push(root);
            root = root.left;
        }
        root = stk.pop();
        root = root.right;
    }
    return res;
}
// 中序遍历
public List<Integer> inorderTraversal(TreeNode root) {
    List<Integer> res = new ArrayList<Integer>();
    Deque<TreeNode> stk = new LinkedList<TreeNode>();
    while (root != null || !stk.isEmpty()) {
        while (root != null) {
            stk.push(root);
            root = root.left;
        }
        root = stk.pop();
        res.add(root.val);
        root = root.right;
    }
    return res;
}
// 后序遍历
public List<Integer> postorderTraversal(TreeNode root) {
    List<Integer> res = new ArrayList<Integer>();
    Deque<TreeNode> stk = new LinkedList<TreeNode>();
    while (root != null || !stk.isEmpty()) {
        while (root != null) {
            stk.push(root);
            res.add(0,root.val);
            root = root.right;
        }
        root = stk.pop();
        root = root.left;
    }
    return res;
}

3. 层次遍历

采用BFS，使用栈结构实现遍历

例如如下二叉树

层次遍历结果是[
[3],
[9,20],
[15,7]
]

/**
* 每一层节点保存在一个列表中，最终遍历结果存储在二维列表中
*/
public ArrayList<ArrayList<Integer>> levelOrder (TreeNode root) {
        // 保存遍历结果
        ArrayList<ArrayList<Integer>> ans = new ArrayList<>();
        // 定义栈
        Queue<TreeNode> queue = new LinkedList<>();
        if(root == null){
            return ans;
        }
        queue.offer(root);
        int size = 0;
        while(!queue.isEmpty()){
            size = queue.size();
            ArrayList<Integer> level = new ArrayList<>();
            for(int i = 0;i < size;i++){
                TreeNode node = queue.poll();
                level.add(node.val);
                if(node.left != null){
                    queue.offer(node.left);
                }
                if(node.right != null){
                    queue.offer(node.right);
                }
            }
            ans.add(level);
        }
        return ans;
    }