递归注意点
1. 确定递归函数的参数和返回值
2. 确定终止条件
3. 确定单层递归的逻辑
二叉树的前序遍历
/**
* 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> preorderTraversal(TreeNode root) {
List<Integer> result =new ArrayList<Integer>();
preorder(root,result);
return result;
}
public void preorder(TreeNode root,List<Integer> result){
if(root == null) return ;
result.add(root.val );
preorder(root.left,result);
preorder(root.right,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;
* }
* }
*/
class Solution {
public List<List<Integer>> resultList = new ArrayList<List<Integer>>();
public List<List<Integer>> levelOrder(TreeNode root) {
checkfun(root);
return resultList;
}
public void checkfun(TreeNode node){
if(node == null) return;
Queue<TreeNode> que =new LinkedList<TreeNode>();
que.offer(node);
while(!que.isEmpty()){
List<Integer> item =new ArrayList<Integer>();
int len = que.size();
while(len>0){
TreeNode tempNode = que.poll();
item.add(tempNode.val);
if(tempNode.left != null) que.offer(tempNode.left);//注意是tempNode不是node,一不注意写错了,绝了。
if(tempNode.right != null) que.offer(tempNode.right);
len--;
//
}
resultList.add(item);
//System.out.println(item);
}
}
}
翻转二叉树
遍历,然后左右翻转。
/**
* 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;
invertTree(root.left);
invertTree(root.right);
swapChildren(root);
return root;
}
private void swapChildren(TreeNode root){
TreeNode tmp =root.left;
root.left= root.right;
root.right= tmp;
}
}
对称二叉树
分为外侧和内侧两个部分来进行比较。
/**
* 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 compare(root.left, root.right);
}
private boolean compare(TreeNode left, TreeNode right){
if(left ==null && right != null) return false;
if(left !=null && right == null) return false;
if(left ==null && right==null) return true;
if(left.val != right.val) return false;
boolean compareOutside =compare(left.left,right.right);
boolean compareInside = compare(left.right,right.left);
return compareOutside && compareInside;
}
}
二叉树的最大深度
前序遍历求得是深度,后序求的是高度。
/**
* 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) {
if(root == null) return 0;
int leftDepth=maxDepth(root.left);
int rightDepth=maxDepth(root.right);
return Math.max(leftDepth,rightDepth)+1;
}
}
二叉树的最小深度
/**
* 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) {
if(root ==null) return 0;
int leftDepth =minDepth(root.left);
int rightDepth = minDepth(root.right);
if(root.left==null) return rightDepth+1;
if(root.right == null) return leftDepth+1;
return Math.min(leftDepth,rightDepth)+1;
}
}