目录
1、LeetCode#226.翻转二叉树
题目简介
给你一棵二叉树的根节点 root ,翻转这棵二叉树,并返回其根节点。
示例一
输入:root = [4,2,7,1,3,6,9]
输出:[4,7,2,9,6,3,1]
4 4
/ \ / \
2 7 ------> 7 2
/ \ / \ / \ / \
1 3 6 9 9 6 3 1
示例二
输入:root = [2,1,3]
输出:[2,3,1]
2 2
/ \ ------> / \
1 3 3 1
示例三
输入:root = []
输出:[]
思想逻辑
- 实现: 二叉树 (先序遍历,后序遍历,中序遍历,层序遍历)
- 逻辑: 把每一个节点的左右孩子翻转一下,就可以达到整体翻转的效果
代码如下
- 递归法
//先序遍历
class Solution {
public TreeNode invertTree(TreeNode root) {
if(root == null) {
return root;
}
swap(root);
invertTree(root.left);
invertTree(root.right);
return root;
}
public void swap(TreeNode Root){
TreeNode test = Root.left;
Root.left = Root.right;
Root.right = test;
}
}
//后序遍历
class Solution {
public TreeNode invertTree(TreeNode root) {
if(root == null) {
return root;
}
invertTree(root.left);
invertTree(root.right);
swap(root);
return root;
}
public void swap(TreeNode Root){
TreeNode test = Root.left;
Root.left = Root.right;
Root.right = test;
}
}
//中序遍历_不推荐
class Solution {
public TreeNode invertTree(TreeNode root) {
if(root == null) {
return root;
}
invertTree(root.left);
swap(root);
invertTree(root.left);
return root;
}
public void swap(TreeNode Root){
TreeNode test = Root.left;
Root.left = Root.right;
Root.right = test;
}
}
- 思想二: 遍历一层的元素就做翻转
- 迭代法
class Solution {
public TreeNode invertTree(TreeNode root) {
if(root == null){
return null;
}
Deque<TreeNode> que = new ArrayDeque<>();
que.offer(root);
while(!que.isEmpty()){
int end = que.size();
while(end > 0){
TreeNode cur = que.poll();
swap(cur);
if(cur.left != null){
que.offer(cur.left);
}
if(cur.right != null){
que.offer(cur.right);
}
end--;
}
}
return root;
}
public void swap(TreeNode root){
TreeNode temp = root.left;
root.left = root.right;
root.right = temp;
}
}
2、LeetCode#226.对称二叉树
题目简介
给你一个二叉树的根节点 root , 检查它是否轴对称。
示例一
输入:root = [1,2,2,3,4,4,3]
输出:true
1
/ | \
2 | 2
/ \ | / \
3 4 | 4 3
示例二
输入:root = [1,2,2,null,3,null,3]
输出:false
1
/ \
2 2
\ \
3 3
思想逻辑
- 实现: 二叉树(后序遍历,队列)
- 逻辑: 比较左右子树的外侧与内侧是否相同
代码如下
- 思想一: 二叉树是否对称,要比较的是根节点的左子树与右子树是不是相互翻转的,理解这一点我们就知道了要比较的是根节点的左右子树,所以在递归遍历的过程中,也是要同时遍历两棵树。
- 递归法
class Solution {
//确定递归函数的返回值和参数
public boolean isSymmetric(TreeNode root) {
return compare(root.left, root.right);
}
//确定终止条件
private 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{
//确定处理逻辑
boolean outside = compare(left.left, right.right);
boolean inside = compare(left.right, right.left);
return outside && inside;
}
}
}
- 思想二: 用队列来遍历左右子树
- 迭代法
class Solution {
public boolean isSymmetric(TreeNode root) {
Deque<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;
}
// if(leftNode == null && rightNode != null){
// return false;
// }
// if(leftNode != null && rightNode == null){
// return false;
// }
// if(leftNode.val != rightNode.val){
// return false;
// }
if(leftNode == null || rightNode == null || leftNode.val != rightNode.val){
return false;
}
que.offer(leftNode.left);
que.offer(rightNode.right);
que.offer(leftNode.right);
que.offer(rightNode.left);
}
return true;
}
}
3、LeetCode#104.二叉树的最大深度
题目简介
给定一个二叉树,找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例:
给定二叉树 [3,9,20,null,null,15,7],
返回最大深度为 3 。
3
/ \
9 20
/ \
15 7
思想逻辑
- 实现: 二叉树(后序遍历、层序遍历)
- 逻辑: 后序遍历(左右中),从下向上来计数;层序遍历,一层一层来计数
二叉树的高度:二叉树中任意一个结点到叶子结点的距离
二叉树的深度:任意结点到根节点的距离
代码如下
- 思想一: 根节点的高度就是二叉树的最大深度
- 递归法
class Solution {
//递归函数的返回值和参数
public int maxDepth(TreeNode root) {
//终止条件
if(root == null){
return 0;
}
return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
//处理逻辑:如下为展开逻辑,方便审阅
//左
//int leftHeight = maxDepth(root.left);
//右
//int rightHeight = maxDepth(root.right);
//中
//int maxHeight = 1 + Math.max(leftHeight, rightHeight);
//return maxHeight;
}
}
- 思想二: 二叉树的最大的深度就是二叉树的层数
- 迭代法
class Solution {
public int maxDepth(TreeNode root) {
if(root == null) return 0;
Deque<TreeNode> que = new LinkedList<>();
que.offer(root);
//记录二叉树的层数
int MaxHeight = 0;
while(!que.isEmpty()){
//end记录着二叉树的一层同时也记录着二叉树这一层的元素的个数
int end = que.size();
MaxHeight++;
while(end > 0){
TreeNode temp = que.poll();
if(temp.left != null){
que.offer(temp.left);
}
if(temp.right != null){
que.offer(temp.right);
}
end--;
}
}
return MaxHeight;
}
}