自刷代码随想录Day12

定义TreeNode

Definition for a binary tree node.
public class TreeNode {
     int val;
     TreeNode left;
     TreeNode right;
     TreeNode() {}
     TreeNode(int val) { this.val = val; }
     TreeNode(int val, TreeNode left, TreeNode right) {
         this.val = val;
         this.left = left;
         this.right = right;
     }
 }

二叉树的前（中后）序遍历（递归）

lc144. 二叉树的前序遍历（简单）

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Traversal(root, res);
        return res;
    }

    public void Traversal (TreeNode root, List<Integer> res) {
        if (root == null)
            return ; 
        res.add(root.val);
        Traversal(root.left, res);
        Traversal(root.right, res);
    }
}

跟着就是他们的中序遍历和后序遍历，没有啥大的差别。

中序遍历

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Traversal(root, res);
        return res;
    }

    public void Traversal (TreeNode root, List<Integer> res) {
        if (root == null)
            return ; 
        Traversal(root.left, res);
        res.add(root.val);
        Traversal(root.right, res);
    }
}

后序遍历

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Traversal(root, res);
        return res;
    }

    public void Traversal (TreeNode root, List<Integer> res) {
        if (root == null)
            return ; 
        Traversal(root.left, res);
        Traversal(root.right, res);
        res.add(root.val);
    }
}

---

二叉树的层序遍历

lc102. 二叉树的层序遍历（）

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        if (root == null) 
            return new ArrayList<>();
        Queue<TreeNode> que = new LinkedList<TreeNode>();
        List<List<Integer>> res = new ArrayList<>();
        que.add(root);
        while (!que.isEmpty()) {
            int count = que.size();
            List<Integer> list =  new ArrayList<Integer>();
            while (count > 0) {
                TreeNode node = que.poll();
                list.add(node.val);
                if (node.left != null) {
                    que.add(node.left);
                }
                if (node.right != null) {
                    que.add(node.right);
                }
                count--;
            }
            res.add(list);
        }
        return res;
    }
}

二叉树的层序遍历需要借助于队列来实现，这道题还有个需要注意的就是我们的返回值类型是List<List<Integer>>

---

翻转二叉树

lc226. 翻转二叉树（简单）

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if (root == null) 
            return root;
        TreeNode cur = root;
        swap(cur, cur.left, cur.right);
        invertTree(cur.left);
        invertTree(cur.right);
        return root;
    }

    public void swap(TreeNode root, TreeNode node1, TreeNode node2) {
        root.left = node2;
        root.right = node1;
    }
}

使用递归法翻转二叉树，注意一下只有前序和后序遍历可以翻转二叉树，不能使用中序遍历翻转二叉树（甚至层次遍历都可以）。