leetcode 102 二叉树层序遍历 101 对称二叉树 226 翻转二叉树

- leetcode 102 二叉树层序遍历 medium

题目链接: leetcode.com/problems/bi…

思路:

递归:

class Solution {
    List<List<Integer>> resultList = new ArrayList<List<Integer>>();
    public List<List<Integer>> levelOrder(TreeNode root) {
        recursion(root, 0);
        return resultList;
    }
    public void recursion (TreeNode root, Integer deep) {
        if (root == null) return;
        deep++;

        if (resultList.size() < deep) {
            List<Integer> item = new ArrayList<Integer>();
            resultList.add(item);
        }
        resultList.get(deep - 1).add(root.val);
        
        recursion(root.left, deep);
        recursion(root.right, deep);
    }
}

迭代:

class Solution {
    List<List<Integer>> resultList = new ArrayList<List<Integer>>();
    public List<List<Integer>> levelOrder(TreeNode root) {
        funcQue(root);
        return resultList;
    }
    public void funcQue (TreeNode root) {
        if (root == null) return;
        Queue<TreeNode> que = new LinkedList<TreeNode>();
        que.offer(root);
        
        while (!que.isEmpty()) {
            List<Integer> itemList = new ArrayList<Integer>();
            int len = que.size();
            
            while (len > 0) {
                TreeNode cur = que.poll();
                itemList.add(cur.val);
                if (cur.left != null) que.offer(cur.left);
                if (cur.right != null) que.offer(cur.right);
                len--;
            }
        resultList.add(itemList);
        }
    }
}

- leetcode 101 对称二叉树 easy

题目链接: leetcode.com/problems/sy…

思路:

递归:

class Solution {
    public boolean isSymmetric(TreeNode root) {
        return compare(root.left, root.right);
    }
    public boolean compare (TreeNode left, TreeNode right) {
        if (left == null && right != null) return false;
        else if (left != null && right == null) return false;
        else if (left == null && right == null) return true;
        else if (left.val != right.val) return false;
        else return compare(left.left, right.right) && compare(left.right, right.left);
    }
}

迭代:

class Solution {
    public boolean isSymmetric(TreeNode root) {
        Queue<TreeNode> que = new LinkedList<>();
        que.offer(root.left);
        que.offer(root.right);
        
        while (!que.isEmpty()) {
            TreeNode leftNode = que.poll();
            TreeNode rightNode = que.poll();
            if (leftNode == null && rightNode == null) {
                continue;
            } else if (leftNode != null && rightNode == null) {
                return false;
            } else if (leftNode == null && rightNode != null) {
                return false;
            } else if (leftNode.val != rightNode.val) {
                return false;
            } else {
                que.offer(leftNode.left);
                que.offer(rightNode.right);
                que.offer(leftNode.right);
                que.offer(rightNode.left);
            }
        }
        return true;
    }
}

- leetcode 226 翻转二叉树 easy

题目链接: leetcode.com/problems/sy…

思路:

递归:

class Solution {
    public TreeNode invertTree(TreeNode root) {
        invert(root);
        return root;
    }
    public void invert (TreeNode node) {
        if (node == null) return;
        invert(node.left);
        invert(node.right);
        swapChildren(node);
    }
    public void swapChildren (TreeNode node) {
        TreeNode tmp = node.left;
        node.left = node.right;
        node.right = tmp;
    }
}

迭代:

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if (root == null) {
            return null;
        }
        ArrayDeque<TreeNode> deque = new ArrayDeque<>();
        deque.offer(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            while (size > 0) {
                TreeNode node = deque.poll();
                swap(node);
                if (node.left != null) {
                    deque.offer(node.left);
                }
                if (node.right != null) {
                    deque.offer(node.right);
                }
                size--; 
            }
        }
        return root;
    }
    public void swap(TreeNode node) {
        TreeNode tmp = node.left;
        node.left = node.right;
        node.right = tmp;
    }
}