1、NC117 合并二叉树
public TreeNode mergeTrees (TreeNode t1, TreeNode t2)
public class Solution {
/**
*
* @param t1 TreeNode类
* @param t2 TreeNode类
* @return TreeNode类
*/
public TreeNode mergeTrees (TreeNode t1, TreeNode t2) {
if (t1 == null && t2 == null) return null;
if (t1 == null || t2 == null) return t1 == null ? t2 : t1;
// 此时 t1、t2 均不为 null
// 合并节点的值
t1.val = t1.val + t2.val;
// 合并左子树
t1.left = mergeTrees(t1.left, t2.left);
// 合并右子树
t1.right = mergeTrees(t1.right, t2.right);
return t1;
}
}2、NC161 二叉树的中序遍历
public int[] inorderTraversal (TreeNode root)
解法1：递归
public class Solution {
// 中序遍历的递归写法 思路清晰但是不够高效
ArrayList<Integer> list = new ArrayList<>();
public int[] inorderTraversal (TreeNode root) {
recur(root);
return list.stream().mapToInt(Integer::valueOf).toArray();
}
public void recur(TreeNode root) {
if (root == null) return;
recur(root.left);
list.add(root.val);
recur(root.right);
}
}解法2：非递归（往左找，出栈往右找）
public int[] inorderTraversal (TreeNode root) {
ArrayList<Integer> arrList=new ArrayList<>();
Stack<TreeNode> stack=new Stack<>();
while(root!=null || !stack.isEmpty()){
while(root!=null){
stack.push(root);
root=root.left;
}
root=stack.pop();
arrList.add(root.val);
root=root.right;
}
return arrList.stream().mapToInt(Integer::valueOf).toArray();
}3、NC72 二叉树的镜像
public TreeNode Mirror (TreeNode pRoot)
public TreeNode Mirror (TreeNode pRoot) {
if(pRoot == null) {
return null;
}
if(pRoot.left == null && pRoot.right == null) {
return pRoot;
}
TreeNode L = Mirror(pRoot.left);
TreeNode R = Mirror(pRoot.right);
pRoot.left = R;
pRoot.right = L;
return pRoot;
}4、NC13 二叉树的最大深度
public int maxDepth (TreeNode root)
解法1：非递归-层次遍历+队列
public int maxDepth (TreeNode root) {
//通过层次遍历计算二叉树的深度
if(root==null) return 0;
Queue<TreeNode>queue=new LinkedList<>();
queue.offer(root);
int level=0,size;
while(!queue.isEmpty()){
size=queue.size();
for(int i=0;i<size;i++){
TreeNode node=queue.poll();
if(node.left!=null) queue.offer(node.left);
if(node.right!=null) queue.offer(node.right);
}
level++;
}
return level;
}解法2：递归
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* }
*/
public class Solution {
/**
*
* @param root TreeNode类
* @return int整型
*/
public int maxDepth (TreeNode root) {
if(root==null){
return 0;
}
int left = maxDepth(root.left);
int right = maxDepth(root.right);
return 1 + Math.max(left,right);
}
}
5、NC136 输出二叉树的右视图
public int[] solve (int[] xianxu, int[] zhongxu)
构造出二叉树之后再用队列找到每层的最后一个节点
HashMap<Integer,Integer> inOrderHashMap = new HashMap<>();
public int[] solve (int[] xianxu, int[] zhongxu) {
// write code here
if (xianxu==null||zhongxu==null||xianxu.length==0||zhongxu.length==0) return new int[0];
for (int i = 0; i < zhongxu.length; i++) {
inOrderHashMap.put(zhongxu[i],i);
}
TreeNode root = buildTree(xianxu, 0, xianxu.length - 1, inOrderHashMap, 0, zhongxu.length - 1);
Deque<TreeNode> queue = new ArrayDeque<>();
queue.offer(root);
int[] res = new int[xianxu.length];
int count =0;
while (!queue.isEmpty()){
//拿到当前层元素个数
int len = queue.size();
System.out.println(len);
for (int i = 0; i < len; i++) {
TreeNode node = queue.poll();
if (node.left!=null) queue.offer(node.left);
if (node.right!=null) queue.offer(node.right);
//到最后一个元素了
if (i==len-1) res[count++] = node.val;
}
}
//count是有效数组元素 0下标开始 跟左闭右开刚好对冲
return Arrays.copyOfRange(res,0,count);
}
//inOrder: [inLeft,rootIndex-1] rootIndex [rootIndex+1,inRight]
//preOrder: preLeft [preLeft+1,preLeft+rootIndex-inLeft] [preLeft+rootIndex-inLeft+1,preRight]
private TreeNode buildTree(int[] xianxu, int preLeft, int preRight, HashMap<Integer, Integer> inOrderHashMap, int inLeft, int inRight) {
//preLeft == preRight时 也要执行的 --叶子节点罢了
if (preLeft>preRight||inLeft>inRight) return null;
int rootIndex = inOrderHashMap.get(xianxu[preLeft]);
TreeNode root = new TreeNode(xianxu[preLeft]);
root.left = buildTree(xianxu, preLeft + 1, preLeft + rootIndex - inLeft, inOrderHashMap, inLeft, rootIndex - 1);
root.right = buildTree(xianxu,preLeft+rootIndex-inLeft+1,preRight,inOrderHashMap,rootIndex+1,inRight);
return root;
}
6、NC102 在二叉树中找到两个节点的最近公共祖先
public int lowestCommonAncestor (TreeNode root, int o1, int o2)
public int lowestCommonAncestor (TreeNode root, int o1, int o2) {
// write code here
if(root.val == o1 || root.val == o2){
return root.val;
}
TreeNode treeNode = order(root, o1, o2);
return treeNode.val;
}
public TreeNode order(TreeNode root, int o1, int o2){
if(root == null)
return null;
if(root.val == o1 || root.val == o2)
return root;
TreeNode left = order(root.left, o1, o2);
TreeNode right = order(root.right, o1, o2);
if(left != null && right != null)
return root;
if(left == null && right == null)
return null;
return left == null? right: left;
}7、NC15 求二叉树的层序遍历
public ArrayList<ArrayList<Integer>> levelOrder (TreeNode root)
方法：队列
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* }
*/
public class Solution {
/**
*
* @param root TreeNode类
* @return int整型ArrayList<ArrayList<>>
*/
public ArrayList<ArrayList<Integer>> levelOrder (TreeNode root) {
// write code here
if (root == null) {
return new ArrayList<>();
}
ArrayList<ArrayList<Integer>> res = new ArrayList<>();
ArrayList<Integer> temp = new ArrayList<>();
Queue<TreeNode> queue = new LinkedList<>();
queue.add(root);
Queue<TreeNode> mid = new LinkedList<>();
while(!queue.isEmpty()) {
TreeNode node = queue.poll();
temp.add(node.val);
if (node.left != null) {
mid.add(node.left);
}
if (node.right != null) {
mid.add(node.right);
}
if (queue.isEmpty()) {
queue = mid;
mid = new LinkedList<>();
res.add(temp);
temp = new ArrayList<>();
}
}
return res;
}
}
8、NC45 实现二叉树先序、中序、后序遍历
public int[][] threeOrders (TreeNode root)
解法1：递归
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* }
*/
public class Solution {
/**
*
* @param root TreeNode类 the root of binary tree
* @return int整型二维数组
*/
public int[][] threeOrders (TreeNode root) {
if(root==null){
return new int[0][0];
}
int[][] res = new int[3][];
//先序
List<Integer> list1 = new ArrayList<Integer>();
first(root,list1);
res[0] = list1.stream().mapToInt(Integer::intValue).toArray();
//中序
List<Integer> list2 = new ArrayList<Integer>();
second(root,list2);
res[1] = list2.stream().mapToInt(Integer::intValue).toArray();
//后序
List<Integer> list3 = new ArrayList<Integer>();
third(root,list3);
res[2] = list3.stream().mapToInt(Integer::intValue).toArray();
return res;
}
private void first(TreeNode root,List<Integer> list){
if(root==null){
return;
}
list.add(root.val);
first(root.left,list);
first(root.right,list);
}
private void second(TreeNode root,List<Integer> list){
if(root==null){
return;
}
second(root.left,list);
list.add(root.val);
second(root.right,list);
}
private void third(TreeNode root,List<Integer> list){
if(root==null){
return;
}
third(root.left,list);
third(root.right,list);
list.add(root.val);
}
方法2：非递归
/**
* 使用非递归的方法解决
* @param root
* @return
*/
public int[][] threeOrders (TreeNode root) {
if(root==null){
return new int[0][0];
}
List<Integer> list1=new ArrayList<>();
List<Integer> list2=new ArrayList<>();
List<Integer> list3=new ArrayList<>();
preOrder(list1,root);
midOrder(list2,root);
afterOrder(list3,root);
int len = list1.size();
int[][] res=new int[3][len];
for (int i = 0; i < len; i++) {
res[0][i]=list1.get(i);
}
for (int i = 0; i < len; i++) {
res[1][i]=list2.get(i);
}
for (int i = 0; i < len; i++) {
res[2][i]=list3.get(i);
}
return res;
}
/**
* 先序遍历
* @param list1
* @param root
*/
private void preOrder(List<Integer> list1, TreeNode root) {
Stack<TreeNode> stack=new Stack<>();
stack.push(root);
while (!stack.isEmpty()){
TreeNode node = stack.pop();
list1.add(node.val);
if(node.right!=null){
stack.push(node.right);
}
if(node.left!=null){
stack.push(node.left);
}
}
}
/**
* 中序遍历
* @param list2
* @param root
*/
private void midOrder(List<Integer> list2, TreeNode root) {
Stack<TreeNode> stack=new Stack<>();
while (!stack.isEmpty() || root!=null){
while (root!=null){
stack.push(root);
root=root.left;
}
TreeNode node = stack.pop();
list2.add(node.val);
if(node.right!=null){
root=node.right;
}
}
}
/**
* 后序遍历
* @param list3
* @param root
*/
private void afterOrder(List<Integer> list3, TreeNode root) {
Stack<TreeNode> stack=new Stack<>();
stack.push(root);
while (!stack.isEmpty()){
TreeNode node = stack.pop();
list3.add(node.val);
if(node.left!=null){
stack.push(node.left);
}
if(node.right!=null){
stack.push(node.right);
}
}
Collections.reverse(list3);
}
9、判断二叉树是否对称
public boolean isSymmetric (TreeNode root)
方法1：递归
public class Solution {
public boolean isSymmetric (TreeNode root) {
if (root == null) return true;
return recur(root.left, root.right);
}
// 递归辅助函数
public boolean recur(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 return left.val == right.val && recur(left.left, right.right) && recur(left.right, right.left);
}
}方法2：层次遍历-Deque
public boolean isSymmetric (TreeNode root) {
if (root == null) return true;
Deque<TreeNode> queue = new LinkedList<>();
queue.addLast(root.left);
queue.addLast(root.right);
while (!queue.isEmpty()) {
TreeNode left = queue.pollLast();
TreeNode right = queue.pollLast();
if (left == null && right == null) continue;
if (left == null || right == null) return false;
if (left.val != right.val) return false;
//队列需要添加4个元素
queue.addFirst(left.left);
queue.addFirst(right.right);
queue.addFirst(left.right);
queue.addFirst(right.left);
}
return true;
}10、NC62 平衡二叉树
public boolean IsBalanced_Solution(TreeNode root)
public class Solution {
private boolean flag;
public boolean IsBalanced_Solution(TreeNode root) {
if(root == null) {
return true;
}
flag = true;
getDepth(root);
return flag;
}
public int getDepth(TreeNode root) {
if(root == null) {
return 0;
}
int L = getDepth(root.left);
int R = getDepth(root.right);
if(Math.abs(L - R) > 1) {
flag = false;
return -1;
}
return Math.max(L, R) + 1;
}
}或
//平衡二叉树要求：左右子树的深度差不超过1，并且左右子树也是平衡二叉树(空树也可以理解成平衡二叉树)
public class Solution {
public boolean IsBalanced_Solution(TreeNode root) {
if(root==null) return true;
return (Math.abs(depth(root.left)-depth(root.right))<=1)
&& IsBalanced_Solution(root.left) && IsBalanced_Solution(root.right);
}
public int depth(TreeNode root){
if(root==null) return 0;
return Math.max(depth(root.left),depth(root.right))+1;
}
}
或
import java.util.*;
public class Solution {
public boolean IsBalanced_Solution(TreeNode root) {
if(root == null){
return true;
}
//判断两个子树的高度差绝对值是否超过1
if(Math.abs(getTreeDeep(root.left) - getTreeDeep(root.right)) > 1){
return false;
}
return IsBalanced_Solution(root.left) && IsBalanced_Solution(root.right);
}
//计算二叉树的深度
public int getTreeDeep(TreeNode root){
if(root == null){
return 0;
}
int leftNum = 1;
int rightNum = 1;
if(root.left != null){
leftNum += getTreeDeep(root.left);
}
if(root.right != null){
rightNum += getTreeDeep(root.right);
}
return leftNum >= rightNum ? leftNum : rightNum;
}
}
总结：左右子树也要满足&左右子树深度之差不超过1
11、NC9 二叉树中是否存在节点和为指定值的路径---dfs/回溯
public boolean hasPathSum (TreeNode root, int sum)
解法：回溯-结束条件、路径、选择列表
public class Solution {
private ArrayList<ArrayList<Integer>> lists = new ArrayList<>();
public ArrayList<ArrayList<Integer>> pathSum (TreeNode root, int sum) {
ArrayList<Integer> list = new ArrayList<>();
recur(root, sum, list);
return lists;
}
public void recur(TreeNode root, int sum, ArrayList<Integer> list) {
if (root == null) return;
list.add(root.val); // 先加入list中
if (root.left == null && root.right == null) { // 到达叶子结点
if (sum == root.val) lists.add(new ArrayList<Integer>(list));
list.remove(list.size()-1); // 移除当前结点，找到 叶子节点就移除，让list没有叶子节点
} else {
recur(root.left, sum - root.val, list);
recur(root.right, sum - root.val, list);
list.remove(list.size()-1); // 递归返回时移除上一个结点
}
}
}类似方法
public class Solution {
private ArrayList<ArrayList<Integer>> res;
public void getPath(TreeNode root, int sum, ArrayList<Integer> temp){
if(root == null) return ;
if(root.left == null && root.right == null){
if(sum - root.val == 0){
temp.add(new Integer(root.val));
//注意此处，temp为传入的引用，写入总的记录时候要重新建一个对象，因为后面需要对temp修改。
res.add(new ArrayList<Integer>(temp));
//记录之后，需要回溯temp为上一个状态，继续走右分支。
temp.remove(temp.size()-1);
}
return ;
}
temp.add(new Integer(root.val));
getPath(root.left, sum-root.val, temp);
getPath(root.right, sum-root.val, temp);
//左右分支结束之后需要恢复到上一层递归时候的状态，以便上一层递归选择不同的分支。
temp.remove(temp.size()-1);
}
public ArrayList<ArrayList<Integer>> pathSum (TreeNode root, int sum) {
// write code here
res = new ArrayList<ArrayList<Integer>>();
ArrayList<Integer> temp = new ArrayList<Integer>();
getPath(root, sum, temp);
return res;
}
}1
方法1：递归--结束条件，选择列表，路径做选择
public class Solution {
public boolean hasPathSum(TreeNode root, int sum) {
if (root == null)
return false;
sum -= root.val;
if (sum == 0 && root.left == null && root.right == null)
return true;
return hasPathSum(root.left, sum) || hasPathSum(root.right, sum);
}
}方法2：dfs
public boolean hasPathSum (TreeNode root, int sum) {
// write code here
return dfs(root,sum);
}
private boolean dfs(TreeNode root, int sum) {
if(root == null) return false;
sum -= root.val;
if(root.left == null && root.right == null && sum == 0) return true;
return dfs(root.left,sum) || dfs(root.right,sum);
}12、NC5 二叉树根节点到叶子节点的所有路径和---dfs
public int sumNumbers (TreeNode root)
解法1：非递归
private int val = 0;
public int sumNumbers (TreeNode root) {
// write code here
if(root==null)
return 0;
//dfs(root,0);
Stack<TreeNode> st = new Stack<>();//使用栈，将从根节点往下的值依次相加，直到左右子树均为空且栈空，则表示到达最底部。
st.push(root);
while(!st.isEmpty()){
TreeNode p = st.pop();
if(p.left==null && p.right==null){
val = val +p.val; //val计算路径和
}else{
if(p.left!=null){
p.left.val = p.val *10 + p.left.val;
st.push(p.left);
}
if(p.right!=null){
p.right.val = p.val *10 + p.right.val;
st.push(p.right);
}
}
}
return val;
}
方法2：回溯-结束条件 、路径、选择列表
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* }
*/
public class Solution {
private int res = 0;
/**
*
* @param root TreeNode类
* @return int整型
*/
public int sumNumbers (TreeNode root) {
if(root==null){
return 0;
}
process(root,0);
return res;
}
private void process(TreeNode root,int agg){
agg = agg*10 + root.val;
if(root.left==null&&root.right==null){
res = res + agg;
}else{
if(root.left!=null){
process(root.left,agg);
}
if(root.right!=null){
process(root.right,agg);
}
}
}
}
13、NC11 将升序数组转化为平衡二叉搜索树
public TreeNode sortedArrayToBST (int[] num)
解法1：递归&选择中间的作为根节点
public class Solution22 {
public TreeNode sortedArrayToBST(int[] num) {
if(num==null||num.length==0)
return null;
return sorted(num,0,num.length-1);
}
public TreeNode sorted(int[] num,int left,int right) {
if(left>right)
return null;
int mid =(left+right+1)/2;
int num1 =num[mid];
TreeNode node = new TreeNode(num1);
node.left =sorted(num,left,mid-1);
node.right = sorted(num,mid+1,right);
return node;
}
}14、NC8 二叉树根节点到叶子节点和为指定值的路径
public ArrayList<ArrayList<Integer>> pathSum (TreeNode root, int sum)
解法：回溯-结束条件、路径、选择列表
public class Solution {
private ArrayList<ArrayList<Integer>> lists = new ArrayList<>();
public ArrayList<ArrayList<Integer>> pathSum (TreeNode root, int sum) {
ArrayList<Integer> list = new ArrayList<>();
recur(root, sum, list);
return lists;
}
public void recur(TreeNode root, int sum, ArrayList<Integer> list) {
if (root == null) return;
list.add(root.val); // 先加入list中
if (root.left == null && root.right == null) { // 到达叶子结点
if (sum == root.val) lists.add(new ArrayList<Integer>(list));
list.remove(list.size()-1); // 移除当前结点，找到 叶子节点就移除，让list没有叶子节点
} else {
recur(root.left, sum - root.val, list);
recur(root.right, sum - root.val, list);
list.remove(list.size()-1); // 递归返回时移除上一个结点
}
}
}类似方法
public class Solution {
private ArrayList<ArrayList<Integer>> res;
public void getPath(TreeNode root, int sum, ArrayList<Integer> temp){
if(root == null) return ;
if(root.left == null && root.right == null){
if(sum - root.val == 0){
temp.add(new Integer(root.val));
//注意此处，temp为传入的引用，写入总的记录时候要重新建一个对象，因为后面需要对temp修改。
res.add(new ArrayList<Integer>(temp));
//记录之后，需要回溯temp为上一个状态，继续走右分支。
temp.remove(temp.size()-1);
}
return ;
}
temp.add(new Integer(root.val));
getPath(root.left, sum-root.val, temp);
getPath(root.right, sum-root.val, temp);
//左右分支结束之后需要恢复到上一层递归时候的状态，以便上一层递归选择不同的分支。
temp.remove(temp.size()-1);
}
public ArrayList<ArrayList<Integer>> pathSum (TreeNode root, int sum) {
// write code here
res = new ArrayList<ArrayList<Integer>>();
ArrayList<Integer> temp = new ArrayList<Integer>();
getPath(root, sum, temp);
return res;
}
}15、NC6 二叉树的最大路径和
public int maxPathSum (TreeNode root)
解法：回溯-结束条件，记录路径，做选择
public class Solution {
/**
*
* @param root TreeNode类
* @return int整型
*/
public int maxPathSum (TreeNode root) {
// write code here
if(root == null){return 0;}
int[] res = {0x80000000};
subTreeMax(root, res);
return res[0];
}
private int subTreeMax(TreeNode root, int[] res){
// subTreeMax()函数 1.计算包含子树根节点root的最大非折返路径和。
// 所谓非折返，就是路径不能同时包含左右子树。折返路径就是左子树+root+右子树
// 2. 根据最大折返路径与最大非折返路径更新最大路径和。
if(root == null){return 0;}
int leftMax = subTreeMax(root.left, res);
int rightMax = subTreeMax(root.right, res);
int childMax = Math.max(leftMax, rightMax);
int ret = childMax > 0? childMax + root.val: root.val;
int leftRootRight = leftMax + root.val + rightMax;
res[0] = Math.max(res[0], Math.max(leftRootRight, ret));//避免有负的
return ret;
}
}16、NC60 判断一棵二叉树是否为搜索二叉树
public boolean[] judgeIt (TreeNode root)
解法：回溯
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* }
*/
public class Solution {
/**
*
* @param root TreeNode类 the root
* @return bool布尔型一维数组
*/
boolean searchFlag= true;
boolean completeFlag = true;
int num=Integer.MIN_VALUE;
Stack<Integer> stack = new Stack<>();
public boolean[] judgeIt (TreeNode root) {
dfs(root,0);
return new boolean[]{searchFlag, completeFlag};
}
public void dfs(TreeNode root, int len) {
//如果两者为false，则开始剪枝
if(!searchFlag && !completeFlag) return ;
if(root==null){
//判断是否是完全二叉树：
//如果是完全二叉树，那么每个空子叶节点所在路径长度差值不得大于1，并且左子节点路径长度必须大于等于右子节点路径长度
//当节点为空说明是一个空子叶节点，此时将该路径长度与前一个路径（上一个空子节点路径）的长度做比较，如果大于则不是完全二叉树
if(stack.size()>=1 && stack.peek()<len) completeFlag=false;
stack.add(len);
return ;
}
dfs(root.left, len+1);
//判断是否是搜索二叉树：
//如果是搜索二叉树，那么中序遍历的结果应该是递增关系。
//如果此访问节点值小于上一个访问节点值，说明破坏了递增规律，则不是搜索二叉树。
if(root.val>=num){
num = root.val;
}else {
searchFlag=false;
}
dfs(root.right,len+1);
}
}
其他
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* }
*/
public class Solution {
/**
*
* @param root TreeNode类 the root
* @return bool布尔型一维数组
*/
long pre = Long.MIN_VALUE;
public boolean[] judgeIt (TreeNode root) {
// write code here
return new boolean[]{isSBT(root),isCBT(root)};
}
/**
* 判断一棵二叉树是否为搜索二叉树，只要改写一个二叉树中序遍历，在遍历的过程中看节点值是否都是递增的即可。
* @param root
* @return
*/
public boolean isSBT(TreeNode root) {
if (root == null) {
return true;
}
if(!isSBT(root.left)) {
return false;
}
if (root.val <= pre) {
return false;
}
pre = root.val;
return isSBT(root.right);
}
/**
*
* 判断一棵二叉树是否为完全二叉树，依据以下标准会使判断过程变得简单且易实现。
* 1．按层遍历二叉树，从每层的左边向右边依次遍历所有的节点。
* 2．如果当前节点有右孩子节点，但没有左孩子节点，则直接返回 false。
* 3．如果当前节点并不是左右孩子节点全有，那么之后的节点必须都为叶节点，否则返回false。
* 4．遍历过程中如果不返回 false，则遍历结束后返回 true。
* @param root
* @return
*/
public boolean isCBT(TreeNode root) {
if (root == null) {
return true;
}
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
boolean leaf = false;
while (!queue.isEmpty()) {
int size = queue.size();
for (int i = 0; i < size; i++) {
TreeNode node = queue.poll();
//如果当前节点并不是左右孩子节点全有，那么之后的节点必须都为叶节点
if (leaf && (node.left != null || node.right != null)) {
return false;
}
//如果当前节点有右孩子节点，但没有左孩子节点，则直接返回 false
if (node.left == null && node.right != null) {
return false;
}
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
} else {
leaf = true;
}
}
}
return true;
}
}
17、NC12 重建二叉树
public TreeNode reConstructBinaryTree(int [] pre,int [] in)
解法1：
public class Solution {
public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
TreeNode root=reConstructBinaryTree(pre,0,pre.length-1,in,0,in.length-1);
return root;
}
//前序遍历{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}
private TreeNode reConstructBinaryTree(int [] pre,int startPre,int endPre,int [] in,int startIn,int endIn) {
if(startPre>endPre||startIn>endIn)
return null;
TreeNode root=new TreeNode(pre[startPre]);
for(int i=startIn;i<=endIn;i++)
if(in[i]==pre[startPre]){
root.left=reConstructBinaryTree(pre,startPre+1,startPre+i-startIn,in,startIn,i-1);
root.right=reConstructBinaryTree(pre,i-startIn+startPre+1,endPre,in,i+1,endIn);
break;
}
return root;
}
}类似：
public class Solution {
int i = 0;
public TreeNode reConstructBinaryTree(int [] pre,int [] vin) {
if(i == pre.length && vin.length == 0) return null;
TreeNode root = null;
for(int j = 0; j < vin.length; j++) {
if(pre[i] == vin[j]) {
root = new TreeNode(pre[i]);
i++;
root.left = reConstructBinaryTree(pre,Arrays.copyOfRange(vin,0,j));
root.right = reConstructBinaryTree(pre,Arrays.copyOfRange(vin,j+1,vin.length));
break;
}
}
return root;
}
}18、NC14 按之字形顺序打印二叉树
public ArrayList<ArrayList<Integer> > Print(TreeNode pRoot)
import java.util.ArrayList;
import java.util.Queue;
import java.util.LinkedList;
import java.util.Collections;
public class Solution {
public ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
ArrayList<ArrayList<Integer> > res =new ArrayList<>();
if(pRoot == null){
return res;
}
Queue<TreeNode> queue =new LinkedList<TreeNode>();
queue.offer(pRoot);
boolean b = true;
while(!queue.isEmpty()){
int num = queue.size();
ArrayList<Integer> temp = new ArrayList<>();
for(int i = 0;i< num;i++){
TreeNode t = queue.poll();
if(t.left != null){
queue.offer(t.left);
}
if(t.right != null){
queue.offer(t.right);
}
temp.add(t.val);
}
if(!b){
Collections.reverse(temp);
}
b = !b;
res.add(temp);
}
return res;
}
}
19、NC81 二叉搜索树的第k个结点
TreeNode KthNode(TreeNode pRoot, int k)
import java.util.*;
// 中序遍历
public class Solution {
TreeNode KthNode(TreeNode pRoot, int k) {
if(pRoot==null) return null;
int count = 0;
List<TreeNode> stack = new ArrayList<>();
while(!stack.isEmpty() || pRoot!=null) {
if(pRoot!=null) {// 先往左找
stack.add(pRoot);
pRoot = pRoot.left;
}
else {//找到最左，出栈
pRoot = stack.remove(stack.size()-1);
count++;
if(count==k) return pRoot;
pRoot = pRoot.right;
}
}
return null;
}
}
publicclassSolution { privateArrayList<ArrayList<Integer>> lists = newArrayList<>(); publicArrayList<ArrayList<Integer>> pathSum (TreeNode root, intsum) { ArrayList<Integer> list = newArrayList<>(); recur(root, sum, list); returnlists; } publicvoidrecur(TreeNode root, intsum, ArrayList<Integer> list) { if(root == null) return; list.add(root.val); // 先加入list中 if(root.left == null&& root.right == null) { // 到达叶子结点 if(sum == root.val) lists.add(newArrayList<Integer>(list)); list.remove(list.size()-1); // 移除当前结点 } else{ recur(root.left, sum - root.val, list); recur(root.right, sum - root.val, list); list.remove(list.size()-1); // 递归返回时移除上一个结点 } }}
作者：哥们要飞
