数据结构与算法-树-遍历

数据结构与算法-树-遍历

由于我现在主要使用的是java，以下题目所以均由java实现
提示：注意空树的情况

层次遍历

题目：102. 二叉树的层次遍历
地址：https://leetcode-cn.com/problems/binary-tree-level-order-traversal/submissions/

public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if (root == null) {
          return result;
        }
        
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int cnt = 1;
        List<Integer> l = new ArrayList<>();
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            l.add(node.val);
            if(node.left!=null){
                queue.offer(node.left);
            }
            if(node.right!=null){
                queue.offer(node.right);
            }
            cnt--;
            if(cnt==0){
                result.add(l);
                l = new ArrayList<>();
                cnt = queue.size();
            }
        }
        return result;
    }

前序遍历

题目：144. 二叉树的前序遍历
地址：https://leetcode-cn.com/problems/binary-tree-preorder-traversal/submissions/
递归实现

    /**
      * Definition for a binary tree node.
      * public class TreeNode {
      *     int val;
      *     TreeNode left;
      *     TreeNode right;
      *     TreeNode(int x) { val = x; }
      * }
      */
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if(root==null){
            return result;
        }
        result.add(root.val);
        result.addAll(preorderTraversal(root.left));
        result.addAll(preorderTraversal(root.right));
        return result;
    }

非递归实现

public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if(root==null){
            return result;
        }
        Deque<TreeNode> stack = new ArrayDeque<>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            result.add(node.val);
            if(node.right!=null){
                stack.push(node.right);
            }
            if(node.left!=null){
                stack.push(node.left);
            }
        }
        return result;
    }

中序遍历

题目：94. 二叉树的中序遍历
地址：https://leetcode-cn.com/problems/binary-tree-inorder-traversal/
递归实现

    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if(root==null){
            return result;
        }
        result.addAll(inorderTraversal(root.left));
        result.add(root.val);
        result.addAll(inorderTraversal(root.right));
        return result;
    }

非递归实现
先将每个节点的左节点放入栈，在依次取出，再放入当前节点的右节点及其左子树

public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if(root==null){
            return result;
        }
        Deque<TreeNode> stack = new ArrayDeque<>();
        stack.push(root);
        while(root.left!=null){
            stack.push(root.left);
            root=root.left;
        }
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            result.add(node.val);
            if(node.right!=null){
                node=node.right;
                stack.push(node);
                while(node.left!=null){
                   stack.push(node.left);
                    node=node.left;
                }
            }
            
        }
        return result;
    }

后序遍历

题目：145. 二叉树的后序遍历
地址：https://leetcode-cn.com/problems/binary-tree-postorder-traversal/submissions/
递归实现

	public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if(root==null){
            return result;
        }
        result.addAll(postorderTraversal(root.left));
        result.addAll(postorderTraversal(root.right));
        result.add(root.val);
        return result;
    }

非递归实现

public List<Integer> postorderTraversal(TreeNode root) {
        LinkedList<Integer> result = new LinkedList<>();
        if (root == null) {
          return result;
        }
        Deque<TreeNode> stack = new ArrayDeque<>();
        stack.push(root);
        while (!stack.isEmpty()) {
          TreeNode node = stack.pollLast();
          result.addFirst(node.val);
          if (node.left != null) {
            stack.add(node.left);
          }
          if (node.right != null) {
            stack.add(node.right);
          }
        }
        return result;
    }