刷题第15天 | 102.二叉树的层序遍历、226.翻转二叉树、101. 对称二叉树

Zeekai

已于 2022-11-09 21:51:00 修改

阅读量152

点赞数

文章标签：算法 leetcode 数据结构

于 2022-11-09 21:45:12 首次发布

本文链接：https://blog.csdn.net/xuzhikai725/article/details/127777352

版权

102. Binary Tree Level Order Traversal

题目链接：102.二叉树的层序遍历
思路链接：代码随想录二叉树-二叉树的层序遍历

思路

迭代法：利用queue。
递归法：

需要处理以及返回的参数：当前节点、result、depth；返回空值
结束条件：当当前节点为空时，return
递归操作：如果result的size与depth相等，就在result中加入空list，为下一步add元素做准备。然后在该层对应的list中加入当前节点元素，更新depth，继续递归左子节点、右子节点。

心路历程

看了视频，自己实现很容易。

Code

/**
 * 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;
 *     }
 * }
 */
import java.util.List;
import java.util.ArrayList;
import java.util.Queue;
import java.util.ArrayDeque;

class Solution {
	// 迭代法 利用queue来辅助
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        Queue<TreeNode> que = new ArrayDeque<>();
        if (root == null) {
            return result;
        }
        que.add(root);
        while (!que.isEmpty()) {
        	// 每遍历一个level，就要更新一次size
            int size = que.size();
            List<Integer> currResult = new ArrayList<>();
            while (size != 0) {
                TreeNode curr = que.poll();
                if (curr.left != null) {
                    que.add(curr.left);
                }
                if (curr.right != null) {
                    que.add(curr.right);
                }
                currResult.add(curr.val);
                size--;
            }
            result.add(currResult);
        }
        return result;
    }
}

/**
 * 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;
 *     }
 * }
 */
import java.util.List;
import java.util.ArrayList;

class Solution {
    // 递归法
    public void levelOrderHelper(TreeNode curr, List<List<Integer>> result, int depth) {
    	// 递归结束条件，如果curr为空，那么返回
		if (curr == null) {
            return;
        }
        // 如果result size与当前depth相等，那么在result中加入空list，为之后加入元素做准备
        if (result.size() == depth) {
            List<Integer> ls = new ArrayList<>();
            result.add(ls);
        }
        // 加入当前节点的值
        // 中
        result.get(depth).add(curr.val);
        // 更新depth
        depth++;
        // 左
        levelOrderHelper(curr.left, result, depth);
        // 右
        levelOrderHelper(curr.right, result, depth);
    }
    
    
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        int depth = 0;
        levelOrderHelper(root, result, depth);
        return result;
    }
}

Invert Binary Tree

226. Invert Binary Tree

题目链接：226.翻转二叉树
思路链接：代码随想录二叉树-翻转二叉树

思路

递归法：前后序遍历，中序遍历不行，因为会导致同一子节点翻转两次
迭代法：还是利用queue

心路历程

看了视频，自己实现很容易。

Code

/**
 * 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 void invertTreeHelper(TreeNode curr) {
        if (curr == null) {return;}
        TreeNode temp = curr.left;
        curr.left = curr.right;
        curr.right = temp;
        invertTreeHelper(curr.left);
        invertTreeHelper(curr.right);
    }
    
    public TreeNode invertTree(TreeNode root) {
        invertTreeHelper(root);
        return 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 void invertTreeHelper(TreeNode curr) {
        if (curr == null) {return;}
        invertTreeHelper(curr.left);
        invertTreeHelper(curr.right);
        TreeNode temp = curr.left;
        curr.left = curr.right;
        curr.right = temp;
    }
    
    public TreeNode invertTree(TreeNode root) {
        invertTreeHelper(root);
        return 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;
 *     }
 * }
 */
import java.util.Queue;
import java.util.ArrayDeque;

class Solution {
	// 迭代法
    public TreeNode invertTree(TreeNode root) {
        if (root == null) {
            return null;
        }
        Queue<TreeNode> que = new ArrayDeque<>();
        que.add(root);
        while (!que.isEmpty()) {
            TreeNode curr = que.poll();
            TreeNode temp = curr.left;
            curr.left = curr.right;
            curr.right = temp;
            if (curr.left != null) {
                que.add(curr.left);
            }
            if (curr.right != null) {
                que.add(curr.right);
            }
        }
        return root;
    }
}

101. Symmetric Tree

题目链接：101. 对称二叉树
思路链接：代码随想录二叉树-对称二叉树

思路

迭代法：利用queue，利用两个指针指向左右两侧对称节点，然后判断
递归法：后序遍历

需要处理以及返回的参数：左节点、右节点；返回boolean
结束条件：判断是否对称的条件，左右为空，左右都不为空，左空右不空，左不空右空
递归操作：左节点递归，右节点递归，然后返回中

心路历程

看了视频，自己实现很容易。

Code

/**
 * 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;
 *     }
 * }
 */
import java.util.List;
import java.util.ArrayList;
import java.util.Queue;
import java.util.ArrayDeque;

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

/**
 * 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;
 *     }
 * }
 */
import java.util.Queue;
import java.util.LinkedList;

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;
            }
            que.offer(leftNode.left);
            que.offer(rightNode.right);
            que.offer(leftNode.right);
            que.offer(rightNode.left);
        }
        return true;
    }
}