代码随想录算法训练营第十五天| 层序遍历 226 翻转二叉树 101 对称二叉树

目录

层序遍历

102 二叉树的层序遍历

递归

迭代

107 二叉树的层序遍历 ||

 递归

迭代

199 二叉树的右视图

637 二叉树的层平均值

429 N叉树的层序遍历

515 在每个树行中寻找最大值

116 填充每个节点的下一个右侧节点指针

 117 填充每个节点的下一个右侧节点||

 104 二叉树的最大深度

 111 二叉树的最小深度

 226 翻转二叉树

递归

迭代

101 对称二叉树

递归

迭代

---

层序遍历

102 二叉树的层序遍历

递归

class Solution {
    List> resList = new ArrayList>();
    public List> levelOrder(TreeNode root) {
        int depth = 0;
        check(root,depth);
        return resList;
    }
    private void check(TreeNode root,Integer depth){
        if(root == null)return;
        depth++;
        if(resList.size() < depth){
            List newList = new ArrayList<>(); 
            resList.add(newList);
        }
        resList.get(depth - 1).add(root.val);
        check(root.left,depth);
        check(root.right,depth);
    }
}

时间复杂度O(n)

空间复杂度O(h)h为二叉树的高度

迭代

class Solution {
    public List> levelOrder(TreeNode root) {
        List>res = new ArrayList>();
        if(root == null)return res;
        Dequest = new LinkedList<>();
        st.add(root);
        while(!st.isEmpty()){
            ListnewList = new ArrayList<>();
            int siz = st.size();
            for(int i = 0;i < siz;i++){
                TreeNode cur = st.pollFirst();
                newList.add(cur.val);
                if(cur.left != null)st.add(cur.left);
                if(cur.right != null)st.add(cur.right);
            }
            res.add(newList);
        }
        return res;
    }
}

时间复杂度O(n)

空间复杂度O(n)为栈所需空间

107 二叉树的层序遍历 ||

 递归

class Solution {
    List>resList = new ArrayList>();
    public List> levelOrderBottom(TreeNode root) {
        int depth = 0;
        check(root,depth);
        List>res = new ArrayList>();
        for(int i = resList.size() - 1;i >= 0;i--){
            res.add(resList.get(i));
        }
        return res;
    }
    private void check(TreeNode root,Integer depth){
        if(root == null)return;
        depth++;
        if(resList.size() < depth){
            ListnewList = new ArrayList<>();
            resList.add(newList);
        }
        resList.get(depth - 1).add(root.val);
        check(root.left,depth);
        check(root.right,depth);
    }
}

时间复杂度O(n)

空间复杂度O(n)  h为二叉树的高度,n为resList的大小,任何情况下都满足 h≤n,所以为O(n)

迭代

class Solution {
    public List> levelOrderBottom(TreeNode root) {
        List>res = new ArrayList>();
        if(root == null)return res;
        Dequest = new LinkedList();
        st.add(root);
        while(!st.isEmpty()){
            int siz = st.size();
            ListnewList = new ArrayList<>();
            for(int i = 0;i < siz;i++){
                TreeNode cur = st.pollFirst();
                if(cur.left != null)st.add(cur.left);
                if(cur.right != null)st.add(cur.right);
                newList.add(cur.val);
            }
            res.add(newList);
        }
        List>ares = new ArrayList>();
        for(int i = res.size() - 1;i >= 0;i--){
            ares.add(res.get(i));
        }
        return ares;
    }
}

时间复杂度O(n)

空间复杂度O(n)

199 二叉树的右视图

class Solution {
    public List rightSideView(TreeNode root) {
        Listres = new ArrayList<>();
        Dequest = new LinkedList<>();
        if(root == null)return res;
        st.addLast(root);
        while(!st.isEmpty()){
            int siz = st.size();
            for(int i = 0;i < siz;i++){
                TreeNode cur = st.pollFirst();
                if(cur.left != null)st.addLast(cur.left);
                if(cur.right != null)st.addLast(cur.right);
                if(i == siz - 1)res.add(cur.val);
            }
        }
        return res;
    }
}

时间复杂度O(n)

空间复杂度O(n)每个节点最多入栈一次

637 二叉树的层平均值

class Solution {
    public List averageOfLevels(TreeNode root) {
        Listres = new ArrayList<>();
        Deque st = new LinkedList<>();
        if(root == null)return res;
        st.add(root);
        while(!st.isEmpty()){
            Double sum = 0.0;
            int siz = st.size();
            for(int i = 0;i < siz;i++){
                TreeNode cur = st.poll();
                sum += cur.val;
                if(cur.left != null)st.add(cur.left);
                if(cur.right != null)st.add(cur.right);
            }
            res.add(sum / siz);
        }
        return res;
    }
}

时间复杂度O(n)

空间复杂度O(n)  

429 N叉树的层序遍历

class Solution {
    public List> levelOrder(Node root) {
        List>res = new ArrayList>();
        Dequest = new LinkedList<>();
        if(root == null)return res;
        st.add(root);
        while(!st.isEmpty()){
            ListnewList = new ArrayList<>();
            int siz = st.size();
            for(int i = 0;i < siz;i++){
                Node cur = st.poll();
                newList.add(cur.val);
                Listchildrens = cur.children;
                if(childrens == null || childrens.size() == 0)continue;
                for(Node node : childrens){
                    if(node != null)st.add(node);
                }
            }
            res.add(newList);
        }
        return res;
    }
}

时间复杂度O(n)

空间复杂度O(n)  即队列需要的空间大小，最坏情况下树为两层，第二层有n - 1个节点

515 在每个树行中寻找最大值

class Solution {
    public List largestValues(TreeNode root) {
        Listres = new ArrayList();
        Dequest = new LinkedList<>();
        if(root == null)return res;
        st.add(root);
        while(!st.isEmpty()){
            int siz = st.size();
            int mn = Integer.MIN_VALUE;
            for(int i = 0;i < siz;i++){
                TreeNode cur = st.pollFirst();
                mn = Math.max(mn,cur.val);
                if(cur.left != null)st.add(cur.left);
                if(cur.right != null)st.add(cur.right);
            }
            res.add(mn);
        }
        return res;
    }
}

时间复杂度O(n)

空间复杂度O(n) 

116 填充每个节点的下一个右侧节点指针

class Solution {
    public Node connect(Node root) {
        Dequest = new LinkedList<>();
        if(root == null)return null;
        st.add(root);
        while(!st.isEmpty()){
            int siz = st.size();
            Node cur = st.pollFirst();
            if(cur.left != null)st.add(cur.left);
            if(cur.right != null)st.add(cur.right);
            for(int i = 1;i < siz;i++){//cur已经取出，下标从1开始
                Node next = st.pollFirst();
                if(next.left != null)st.add(next.left);
                if(next.right != null) st.add(next.right);
                cur.next = next;
                cur = next;
            }
        }
        return root;
    }
}

时间复杂度O(n)

空间复杂度O(n) 

 117 填充每个节点的下一个右侧节点||

class Solution {
    public Node connect(Node root) {
        Dequest = new LinkedList<>();
        if(root == null)return null;
        st.add(root);
        while(!st.isEmpty()){
            int siz = st.size();
            Node cur = st.pollFirst();
            if(cur.left != null)st.add(cur.left);
            if(cur.right != null)st.add(cur.right);
            for(int i = 1;i < siz;i++){
                Node next = st.pollFirst();
                if(next.left != null)st.add(next.left);
                if(next.right != null)st.add(next.right);
                cur.next = next;
                cur = next;
            }
        }
        return root;
    }
}

时间复杂度O(n)

空间复杂度O(n) 

 104 二叉树的最大深度

class Solution {
    public int maxDepth(TreeNode root) {
        int depth = 0;
        Dequest = new LinkedList<>();
        if(root == null)return depth;
        st.add(root);
        while(!st.isEmpty()){
            int siz = st.size();
            for(int i = 0;i < siz;i++){
                TreeNode cur = st.pollFirst();
                if(cur.left != null)st.add(cur.left);
                if(cur.right != null)st.add(cur.right);
            }
            depth++;
        }
        return depth;
    }
}

时间复杂度O(n)

空间复杂度O(n) 

 111 二叉树的最小深度

class Solution {
    public int minDepth(TreeNode root) {
        int depth = 0;
        Dequest = new LinkedList<>();
        if(root == null)return 0;
        st.add(root);
        while(!st.isEmpty()){
            int siz = st.size();
            depth++;
            for(int i = 0;i < siz;i++){
                TreeNode cur = st.pollFirst();
                if(cur.left == null && cur.right == null)return depth;
                if(cur.left != null)st.add(cur.left);
                if(cur.right != null)st.add(cur.right);
            }
        } 
        return -1;
    }
}

时间复杂度O(n)

空间复杂度O(n) 

 226 翻转二叉树

递归

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

时间复杂度O(n)

空间复杂度O(n) 使用的空间由递归栈的深度决定，最坏情况下二叉树为链状，此时为O(n)

迭代

class Solution {
    public TreeNode invertTree(TreeNode root) {
        Dequest = new LinkedList<>();
        if(root == null)return null;
        st.add(root);
        while(!st.isEmpty()){
            int siz = st.size();
            for(int i = 0;i < siz;i++){
                TreeNode cur = st.pollFirst();
                TreeNode temp = cur.right;
                cur.right = cur.left;
                cur.left = temp;
                if(cur.left != null)st.add(cur.left);
                if(cur.right != null)st.add(cur.right);
            }
        }
        return root;
    }
}

时间复杂度O(n)

空间复杂度O(n) 

101 对称二叉树

递归

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

时间复杂度O(n)

空间复杂度O(n) 

迭代

class Solution {
    public boolean isSymmetric(TreeNode root) {
        Dequedeque = new LinkedList<>();
        deque.offerFirst(root.left);
        deque.offerLast(root.right);
        while(!deque.isEmpty()){
            TreeNode l = deque.pollFirst();
            TreeNode r = deque.pollLast();
            if(l == null && r == null)continue;
            if(l == null && r != null)return false;
            if(l != null && r == null)return false;
            if(l.val != r.val)return false;
            deque.offerFirst(l.left);
            deque.offerFirst(l.right);
            deque.offerLast(r.right);
            deque.offerLast(r.left);
        }
        return true;
    }
}

时间复杂度O(n)

空间复杂度O(n)