[代码随想录] 第十三天
226.翻转二叉树[https://leetcode.cn/problems/invert-binary-tree/description/]
递归：递归三部曲：①确定递归函数的参数和返回值 ②确定终止条件 ③确定单层递归的逻辑
/**
* 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 TreeNode invertTree(TreeNode root) {
if (root == null) {
return null;
}
swap(root);
invertTree(root.left);
invertTree(root.right);
return root;
}
public void swap(TreeNode p) {
TreeNode q = p.left;
p.left = p.right;
p.right = q;
}
}
迭代：直接套用迭代前序遍历模板即可，将visit()调整为swap()即可。
/**
* 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 TreeNode invertTree(TreeNode root) {
if (root == null) {
return null;
}
Stack<TreeNode> sc = new Stack<>();
sc.push(root);
TreeNode p;
while (!sc.isEmpty()) {
while (!sc.isEmpty()) {
p = sc.pop();
swap(p);//此处就是visit(p);
if (p.right != null) {
sc.push(p.right);
}
if (p.left != null) {
sc.push(p.left);
}
}
}
return root;
}
public void swap(TreeNode p) {
TreeNode q = p.left;
p.left = p.right;
p.right = q;
}
}
**-----------------------分割线-------------------------**
102.二叉树的层序遍历[https://leetcode.cn/problems/binary-tree-level-order-traversal/]
思路：与迭代前序遍历类似，重点在于int loop = que.size();使用loop记录当前数组大小，使用for一次性弹出多个元素出栈记录，入栈非空孩子节点
/**
* 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) {
List<List<Integer>> ans = new ArrayList<>();
if (root == null) {
return ans;
}
Queue<TreeNode> que = new LinkedList<>();
que.offer(root);
while (!que.isEmpty()) {
List<Integer> list = new ArrayList<>();
int loop = que.size();
for (int i = 0; i < loop; i++) {
TreeNode temp = que.poll();
list.add(temp.val);
if (temp.left != null) {
que.offer(temp.left);
}
if (temp.right != null) {
que.offer(temp.right);
}
}
ans.add(list);
}
return ans;
}
}
**-----------------------分割线-------------------------**
199.二叉树的右视图[https://leetcode.cn/problems/binary-tree-right-side-view/]
思路：层次遍历二叉树的扩展，重点在于使用loop循环遍历元素，退出循环时，p所指向的元素就是每一层最右边的元素，故👉ans.add(p.val);
/**
* 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<Integer> rightSideView(TreeNode root) {
Queue<TreeNode> que = new LinkedList<>();
List<Integer> ans = new ArrayList<>();
TreeNode p = root;
if (root == null) {
return ans;
}
que.offer(root);
while (!que.isEmpty()) {
int loop = que.size();
for (int i = 0; i < loop; i++) {
p = que.poll();
if (p.left != null) {
que.offer(p.left);
}
if (p.right != null) {
que.offer(p.right);
}
}
ans.add(p.val);
}
return ans;
}
}
**-----------------------分割线-------------------------**
429.N叉树的层次遍历[https://leetcode.cn/problems/n-ary-tree-level-order-traversal/submissions/498054658/]
思路：套用层次遍历模板，重点在于loop遍历加入队列时，不是简单的加入左右孩子，而是遍历孩子集合。for(Node n:temp.children){que.offer(n);}此处使用增强for快捷方便。
/*
// Definition for a Node.
class Node {
public int val;
public List<Node> children;
public Node() {}
public Node(int _val) {
val = _val;
}
public Node(int _val, List<Node> _children) {
val = _val;
children = _children;
}
};
*/
class Solution {
public List<List<Integer>> levelOrder(Node root) {
List<List<Integer>> ans = new ArrayList<>();
if (root == null) {
return ans;
}
Queue<Node> que = new LinkedList<>();
que.offer(root);
while (!que.isEmpty()) {
List<Integer> list = new ArrayList<>();
int loop = que.size();
for (int i = 0; i < loop; i++) {
Node temp = que.poll();
list.add(temp.val);
for (Node n : temp.children) {
que.offer(n);
}
}
ans.add(list);
}
return ans;
}
}
**-----------------------分割线-------------------------**
515.在每个树中找最大值[https://leetcode.cn/problems/find-largest-value-in-each-tree-row/description/]
/**
* 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<Integer> largestValues(TreeNode root) {
List<Integer> ans = new ArrayList<>();
if (root == null) {
return ans;
}
Queue<TreeNode> que = new LinkedList<>();
que.offer(root);
while (!que.isEmpty()) {
int loop = que.size();
int max = que.peek().val;
for (int i = 0; i < loop; i++) {
TreeNode temp = que.poll();
max = temp.val > max ? temp.val : max;
if (temp.left != null) {
que.offer(temp.left);
}
if (temp.right != null) {
que.offer(temp.right);
}
}
ans.add(max);
}
return ans;
}
}
**-----------------------分割线-------------------------**
116.填充每个节点的下一个右侧结点指针[https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/description/]
思路：同上，loopint loop = que.size();``for (int i = 0; i < loop; i++)循环中temp.next = que.peek();在退出循环时，temp所指向的就是最右边节点，temp.next = null;
/*
// Definition for a Node.
class Node {
public int val;
public Node left;
public Node right;
public Node next;
public Node() {}
public Node(int _val) {
val = _val;
}
public Node(int _val, Node _left, Node _right, Node _next) {
val = _val;
left = _left;
right = _right;
next = _next;
}
};
*/
class Solution {
public Node connect(Node root) {
if (root == null) {
return null;
}
Node temp = null;
Queue<Node> que = new LinkedList<>();
que.offer(root);
while (!que.isEmpty()) {
int loop = que.size();
for (int i = 0; i < loop; i++) {
temp = que.poll();
temp.next = que.peek();
if (temp.left != null) {
que.offer(temp.left);
}
if (temp.right != null) {
que.offer(temp.right);
}
}
temp.next = null;
}
return root;
}
}
**-----------------------分割线-------------------------**
104.二叉树的最大深度[https://leetcode.cn/problems/maximum-depth-of-binary-tree/]
/**
* 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 int maxDepth(TreeNode root) {
int x = 0;
if (root == null) {
return 0;
}
Queue<TreeNode> que = new LinkedList<>();
que.offer(root);
while (!que.isEmpty()) {
List<Integer> list = new ArrayList<>();
int loop = que.size();
for (int i = 0; i < loop; i++) {
TreeNode temp = que.poll();
if (temp.left != null) {
que.offer(temp.left);
}
if (temp.right != null) {
que.offer(temp.right);
}
}
x++;
}
return x;
}
}
**-----------------------分割线-------------------------**
111.二叉树的最小深度[https://leetcode.cn/problems/minimum-depth-of-binary-tree/]
/**
* 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 int minDepth(TreeNode root) {
int x = 1;
if (root == null) {
return 0;
}
Queue<TreeNode> que = new LinkedList<>();
que.offer(root);
while (!que.isEmpty()) {
int loop = que.size();
for (int i = 0; i < loop; i++) {
TreeNode temp = que.poll();
if (temp.left != null) {
que.offer(temp.left);
}
if (temp.right != null) {
que.offer(temp.right);
}
if(temp.right==null && temp.left==null){
return x;
}
}
x++;
}
return x;
}
}
**-----------------------分割线-------------------------**
101.对称二叉树[https://leetcode.cn/problems/symmetric-tree/]
思路：可以编写一个递归判断方法，判定根节点的左子树和右子树是不是对称的，判定是否对称和判定是否相同是一样的逻辑，
判定是否相同时，同时调入左孩子或右孩子。判定是否对称时，一个调入左孩子另一个调入右孩子。
/**
* 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 boolean isSymmetric(TreeNode root) {
return isSame(root.left,root.right);
}
boolean isSame(TreeNode n1,TreeNode n2){
if(n1==null&&n2!=null){return false;}
if(n2==null&&n1!=null){return false;}
if (n1== null && n2 == null) {return true; }
if(n1.val!=n2.val){return false;}
return isSame(n1.right,n2.left)&&isSame(n1.left,n2.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;
* }
* }
*/
class Solution {
public boolean isSymmetric(TreeNode root) {
Queue<TreeNode> que = new LinkedList<>();
que.offer(root.left);
que.offer(root.right);
while (!que.isEmpty()) {
TreeNode left = que.poll();
TreeNode right = que.poll();
if (left == null && right == null) {
continue;
}
if (left == null || right == null || left.val != right.val) {
return false;
}
que.offer(left.right);
que.offer(right.left);
que.offer(right.right);
que.offer(left.left);
}
return true;
}
}
今天终于结束了！！
浙公网安备 33010602011771号