NC刷题笔记3-树

已于 2022-04-05 19:59:55 修改
阅读量1.1k 收藏
点赞数
文章标签： 算法 数据结构 linux
于 2022-04-02 14:12:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34329430/article/details/123919026
版权

NC刷题笔记3-树

本博客文章（学习笔记）导航 （点击这里访问）
在这里插入图片描述

NC5 二叉树根节点到叶子节点的所有路径和

描述
给定一个二叉树的根节点root，该树的节点值都在数字0−9 之间，每一条从根节点到叶子节点的路径都可以用一个数字表示。
1.该题路径定义为从树的根结点开始往下一直到叶子结点所经过的结点
2.叶子节点是指没有子节点的节点
3.路径只能从父节点到子节点，不能从子节点到父节点
4.总节点数目为n

例如根节点到叶子节点的一条路径是31→2→3,那么这条路径就用 123 来代替。
找出根节点到叶子节点的所有路径表示的数字之和
例如：

这颗二叉树一共有两条路径，
根节点到叶子节点的路径  21→2 用数字 12 代替
根节点到叶子节点的路径 31→3 用数字 13 代替
所以答案为 12+13=25

数据范围：节点数  1000≤n≤100，保证结果在32位整型范围内
要求：空间复杂度 O(n)，时间复杂度 O(n^2)
进阶：空间复杂度 O(n)，时间复杂度 O(n)

示例1
输入：{1,2,3}
返回值：25

示例2
输入：{1,0}
返回值：10

示例3
输入：{1,2,0,3,4}
返回值：257

思路： 先序遍历（根 左右）

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 sumNumbers(TreeNode root) {
		int sum = 0;
		if (root == null) {
			return sum;
		}
		return preorderSumNumbers(root, sum);
	}
    
	public int preorderSumNumbers(TreeNode root, int sum) {
		if (root == null) return 0;
		sum = sum * 10 + root.val;
		if (root.left == null && root.right == null) {
			return sum;
		}
		return preorderSumNumbers(root.left, sum) + preorderSumNumbers(root.right, sum);
	}
}

NC6 二叉树中的最大路径和

描述
二叉树里面的路径被定义为:从该树的任意节点出发，经过父=>子或者子=>父的连接，达到任意节点的序列。
注意:
1.同一个节点在一条二叉树路径里中最多出现一次
2.一条路径至少包含一个节点，且不一定经过根节点
给定一个二叉树的根节点root，请你计算它的最大路径和

/*
 * 124. Binary Tree Maximum Path Sum
 * 解题思路：
 * 这道题是求树的路径和的题目，不过和平常不同的是这里的路径不仅可以从根到某一个结点，
 * 而且路径可以从左子树某一个结点，然后到达右子树的结点，就像题目中所说的可以起始和终结于任何结点。
 * 在这里树没有被看成有向图，而是被当成无向图来寻找路径。
 * 因为这个路径的灵活性，我们需要对递归返回值进行一些调整，而不是通常的返回要求的结果。
 * 在这里，函数的返回值定义为以自己为根的一条从根到子结点的最长路径（这里路径就不是当成无向图了，
 * 必须往单方向走）。
 * 这个返回值是为了提供给它的父结点计算自身的最长路径用，
 * 而结点自身的最长路径（也就是可以从左到右那种）则只需计算然后更新即可。
 * 这样一来，一个结点自身的最长路径就是它的左子树返回值（如果大于0的话），
 * 加上右子树的返回值（如果大于0的话），再加上自己的值。
 * 而返回值则是自己的值加上左子树返回值，
 * 右子树返回值或者0（注意这里是“或者”，而不是“加上”，因为返回值只取一支的路径和）。
 * 在过程中求得当前最长路径时比较一下是不是目前最长的，如果是则更新。
 * 算法的本质还是一次树的遍历，所以复杂度是O(n)。而空间上仍然是栈大小O(logn)。
 */

import java.util.*;

public class Solution {
    int maxValue = 0;
    public int maxPathSum(TreeNode root) {
        if (root == null) return 0;
        maxValue = Integer.MIN_VALUE;
        getMaxPathSum(root);
        return maxValue;
    }
 
    private int getMaxPathSum(TreeNode root) {
        if (root == null) return 0;
        //因为节点的值可以为负数，所以最大值取0和子树值的较大者
        int leftMax = Math.max(0, getMaxPathSum(root.left));
        int rightMax = Math.max(0, getMaxPathSum(root.right));
        //如果将当前root作为根节点，那么最大值是root.val+左子树最大值+右子树最大值
        maxValue = Math.max(maxValue, root.val + leftMax + rightMax);
        //只能返回左右子树中较大值加上root.val
        return Math.max(0, root.val + Math.max(leftMax, rightMax));
    }
}

NC8 二叉树中和为某一值的路径(二)

描述
输入一颗二叉树的根节点root和一个整数expectNumber，找出二叉树中结点值的和为expectNumber的所有路径。
1.该题路径定义为从树的根结点开始往下一直到叶子结点所经过的结点
2.叶子节点是指没有子节点的节点
3.路径只能从父节点到子节点，不能从子节点到父节点
4.总节点数目为n
如二叉树root为{10,5,12,4,7},expectNumber为22
则合法路径有[[10,5,7],[10,12]]

数据范围:
树中节点总数在范围 [0, 5000] 内
-1000 <= 节点值 <= 1000
-1000 <= expectNumber <= 1000

示例1  输入：{10,5,12,4,7},22  返回值：[[10,5,7],[10,12]]  说明：返回[[10,12],[10,5,7]]也是对的      
示例2  输入：{10,5,12,4,7},15  返回值：[]
示例3  输入：{2,3},0  返回值：[]
示例4  输入：{1,3,4},7  返回值：[]

思路1：
	前序遍历 递归调用

import java.util.ArrayList;
public class Solution {
    ArrayList<ArrayList<Integer>> res=new ArrayList<ArrayList<Integer>>();
    ArrayList<Integer> temp=new ArrayList<Integer>();
    public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) {
        recur(root,target);
        return res;
    }
    public void recur(TreeNode root,int target){
        if(root==null) return;
        temp.add(root.val);
        target=target-root.val;
        if(root.left==null&&root.right==null&&target==0){
            res.add(new ArrayList<Integer>(temp));
            target+=root.val;
            temp.remove(temp.size()-1);
            return;
        }
        recur(root.left,target);
        recur(root.right,target);
        target+=root.val;
        temp.remove(temp.size()-1);
    }
}

NC9 二叉树中和为某一值的路径(一)

描述
给定一个二叉树root和一个值 sum ，判断是否有从根节点到叶子节点的节点值之和等于 sum 的路径。
1.该题路径定义为从树的根结点开始往下一直到叶子结点所经过的结点
2.叶子节点是指没有子节点的节点
3.路径只能从父节点到子节点，不能从子节点到父节点
4.总节点数目为n

例如：
给出如下的二叉树，sum=22，
返回true，因为存在一条路径5→4→11→2的节点值之和为 22

数据范围：
1.树上的节点数满足0≤n≤10000
2.每个节点的值都满足0<∣val∣≤1000
要求：空间复杂度 O(n)，时间复杂度 O(n)
进阶：空间复杂度 O(树的高度)，时间复杂度 O(n)

示例1  输入：{5,4,8,1,11,#,9,#,#,2,7},22  返回值：true
示例2  输入：{1,2},0  返回值：false
示例3  输入：{1,2},3  返回值：true
示例4  输入：{},0  返回值：false

思路：前序遍历

import java.util.*;
public class Solution {
    public boolean hasPathSum (TreeNode root, int sum) {
        // write code here
        if(root==null) return false;
        sum=sum-root.val;
        if(root.left==null&&root.right==null&&sum==0) return true;
        return hasPathSum(root.left,sum)||hasPathSum(root.right,sum);
    }
}

NC11 将升序数组转化为平衡二叉搜索树

描述
给定一个升序排序的数组，将其转化为平衡二叉搜索树（BST）.
平衡二叉搜索树指树上每个节点 node 都满足左子树中所有节点的的值都小于 node 的值，右子树中所有节点的值都大于 node 的值，并且左右子树的节点数量之差不大于1
数据范围：0≤n≤10000，数组中每个值满足∣val∣≤5000
进阶：空间复杂度 O(n)，时间复杂度 O(n)
例如当输入的升序数组为[-1,0,1,2]时，转化后的平衡二叉搜索树（BST）可以为{1,0,2,-1}，如下图所示：

示例1
输入：[-1,0,1,2]
返回值：{1,0,2,-1}

示例2
输入：[]
返回值：{}

思路：
	取数组中间结点为根节点，左侧为左子树，右侧为右子树
	递归构造

import java.util.*;
public class Solution {
    public TreeNode sortedArrayToBST(int[] num) {
        if (num.length == 0)  return null;
        return sortedArrayToBST(num, 0, num.length - 1);
    }
    public TreeNode sortedArrayToBST(int[] num, int start, int end) {
        if (start > end) return null;
        int mid = (start + end+1) >> 1;
        TreeNode root = new TreeNode(num[mid]);
        root.left = sortedArrayToBST(num, start, mid - 1);
        root.right = sortedArrayToBST(num, mid + 1, end);
        return root;
    }
}

NC12 重建二叉树

描述
给定节点数为 n 二叉树的前序遍历和中序遍历结果，请重建出该二叉树并返回它的头结点。
例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建出如下图所示。
提示:
1.vin.length == pre.length
2.pre 和 vin 均无重复元素
3.vin出现的元素均出现在 pre里
4.只需要返回根结点，系统会自动输出整颗树做答案对比
数据范围：0n≤2000，节点的值 0≤val≤10000
要求：空间复杂度 O(n)，时间复杂度 O(n)

思路：
	递归调用

public class Solution {
    int[] pre;
    HashMap<Integer,Integer> inOrder=new HashMap<Integer,Integer>();
    public TreeNode reConstructBinaryTree(int [] pre,int [] vin) {
        this.pre=pre;
        for(int i=0;i<vin.length;i++) inOrder.put(vin[i],i);
        return reBuild(0,0,vin.length-1);
    }
    
    public TreeNode reBuild(int preindex,int left,int right){
        if(left>right) return null;
        TreeNode root=new TreeNode(pre[preindex]);
        root.left=reBuild(preindex+1,left,inOrder.get(pre[preindex])-1);
        root.right=reBuild(preindex+inOrder.get(pre[preindex])-left+1,inOrder.get(pre[preindex])+1,right);
        return root;
    }
}

NC13 二叉树的最大深度

描述
求给定二叉树的最大深度，深度是指树的根节点到任一叶子节点路径上节点的数量。最大深度是所有叶子节点的深度的最大值。（注：叶子节点是指没有子节点的节点。）
数据范围：0≤n≤100000，树上每个节点的val满足∣val∣≤100
要求： 空间复杂度 O(1),时间复杂度 O(n)

示例1  输入：{1,2}  返回值：2
示例2  输入：{1,2,3,4,#,#,5}  返回值：3

思路：
	递归，直接往下面遍历

import java.util.*;
public class Solution {
    public int maxDepth (TreeNode root) {
        if(root==null) return 0;
        if(root.left==null&&root.right==null) return 1;
        return Math.max(maxDepth(root.left),maxDepth(root.right))+1;
    }
}

NC14 按之字形顺序打印二叉树

输入：
二叉树
   1
 2   3
   4   5
输出：
[[1],
[3,2],
[4,5]]

思路1:
	1 双端队列，用于存放二叉树结点信息
	2 用链表存储每层的信息，奇数从左到右，偶数从右向左

import java.util.*;
public class Solution {
    ArrayList<Integer> temp=new ArrayList<Integer>();
    public ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> res=new ArrayList<ArrayList<Integer>>();
        LinkedList<TreeNode> queue=new LinkedList<TreeNode>();
        if(pRoot==null) return res;
        int index=1;
        queue.offer(pRoot);
        while(!queue.isEmpty()){
            int n=queue.size();
            temp=new ArrayList<Integer>();
            for(int i=0;i<n;i++){
                TreeNode node= queue.poll();
                if(index%2==1){
                    temp.add(node.val);
                }else{
                    temp.add(0,node.val);
                }
                if(node.left!=null) queue.offer(node.left);
                if(node.right!=null) queue.offer(node.right);
            }
            res.add(temp);
            index++;
        }
        return res;
    }
}

NC15 求二叉树的层序遍历

思路：栈

import java.util.*;
public class Solution {
    ArrayList<Integer> temp=new ArrayList<Integer>();
    public ArrayList<ArrayList<Integer>> levelOrder (TreeNode root) {
        ArrayList<ArrayList<Integer>> res=new ArrayList<ArrayList<Integer>>();
        LinkedList<TreeNode> queue=new LinkedList<TreeNode>();
        if(root==null) return res;
        queue.offer(root);
        while(!queue.isEmpty()){
            int n=queue.size();
            temp=new ArrayList<Integer>();
            for(int i=0;i<n;i++){
                TreeNode node= queue.poll();
                temp.add(node.val);
                if(node.left!=null) queue.offer(node.left);
                if(node.right!=null) queue.offer(node.right);
            }
            res.add(temp);
        }
        return res;
    }
}

NC16 对称的二叉树

判断二叉树是否是镜像二叉树

思路1：递归
思路2：层序遍历 空值用#代替

思路1：
public class Solution {
    boolean isSymmetrical(TreeNode pRoot) {
        if(pRoot==null||(pRoot.left==null&&pRoot.right==null)) return true;
        return recur(pRoot.left,pRoot.right);
    }
    boolean recur(TreeNode left,TreeNode right){
        if(left==null&&right==null) return true;
        if((left==null&&right!=null)||(left!=null&&right==null)||(left.val!=right.val)) return false;
        return recur(left.left,right.right)&&recur(left.right,right.left);
    }
}

NC 45 二叉树前序、中序和后序遍历

描述
给定一棵二叉树，分别按照二叉树先序，中序和后序打印所有的节点。
数据范围：0≤n≤1000，树上每个节点的val值满足0≤val≤100
要求：空间复杂度 O(n)，时间复杂度 O(n)
示例1  输入：{1,2,3}  返回值：[[1,2,3],[2,1,3],[2,3,1]]
示例2  输入：{}  返回值：[[],[],[]]

思路1：递归
思路2：非递归

import java.util.*;
public class Solution {
    ArrayList<Integer> pre=new ArrayList<>();
    ArrayList<Integer> in=new ArrayList<>();
    ArrayList<Integer> post=new ArrayList<>();
    public int[][] threeOrders (TreeNode root) {
        preOrder(root);
        inOrder(root);
        postOrder(root);
        return getRes();
    }
    public void preOrder(TreeNode root){
        if(root==null) return;
        pre.add(root.val);
        preOrder(root.left);
        preOrder(root.right);
    }
    public void inOrder(TreeNode root){
        if(root==null) return;
        inOrder(root.left);
        in.add(root.val);
        inOrder(root.right);
    }
    public void postOrder(TreeNode root){
        if(root==null) return;
        postOrder(root.left);
        postOrder(root.right);
        post.add(root.val);
    }
    public int[][] getRes(){
        int[][] res =new int[3][pre.size()];
        for(int i=0;i<pre.size();i++){
            res[0][i]=pre.get(i);
            res[1][i]=in.get(i);
            res[2][i]=post.get(i);
        }
        return res;
    }
}

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整型二维数组
     */
    ArrayList<Integer> pre=new ArrayList<>();
    ArrayList<Integer> in=new ArrayList<>();
    ArrayList<Integer> post=new ArrayList<>();
    public int[][] threeOrders (TreeNode root) {
        preOrder(root);
        inOrder(root);
        postOrder(root);
        return getRes();
    }
    
    public void preOrder(TreeNode root){
        if(root==null) return;
        Stack<TreeNode> stack=new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode cur=stack.pop();
            pre.add(cur.val);
            if(cur.right!=null) stack.push(cur.right);
            if(cur.left!=null) stack.push(cur.left);
        }
    }
    
    public void inOrder(TreeNode root){
        if(root==null) return;
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur=root;
        while(!stack.isEmpty()||cur!=null){
            if(cur!=null){
                stack.push(cur);
                cur=cur.left;
            }else{
                cur= stack.pop();
                in.add(cur.val);
                cur=cur.right;
            }
        }
    }
    
    public void postOrder(TreeNode root){
        if(root==null) return;
        Stack<TreeNode> stack=new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode cur=stack.pop();
            post.add(0,cur.val);
            if(cur.left!=null) stack.push(cur.left);
            if(cur.right!=null) stack.push(cur.right);
        }
        
    }
    
    
    public int[][] getRes(){
        int[][] res =new int[3][pre.size()];
        for(int i=0;i<pre.size();i++){
            res[0][i]=pre.get(i);
            res[1][i]=in.get(i);
            res[2][i]=post.get(i);
        }
        return res;
    }
}

NC 58找到两个错误结点

描述
一棵二叉树原本是搜索二叉树，但是其中有两个节点调换了位置，使得这棵二叉树不再是搜索二叉树，请按升序输出这两个错误节点的值。(每个节点的值各不相同)
搜索二叉树：满足每个节点的左子节点小于当前节点，右子节点大于当前节点。
进阶：空间复杂度 O(1)，时间复杂度 O(n)
示例1  输入：{1,2,3}  返回值：[1,2]  
示例2  输入：{4,2,5,3,1}  返回值：[1,3]

思路1：
	数组，中序遍历，从左往右找一个，从右往左找一个
思路2：
	递归

import java.util.*;
public class Solution {
    List<Integer> list=new ArrayList<>();
    public int[] findError (TreeNode root) {
        inOrder(root);
        int left=0,right=list.size()-1;
        int[] res=new int[2];
        while(list.get(left)<list.get(left+1)) left++;
        while(list.get(right)>list.get(right-1)) right--;
        res[0]=list.get(right);
        res[1]=list.get(left);
        return res;
    }
    
    public void inOrder(TreeNode root){
        if(root==null) return;
        Stack<TreeNode> stack=new Stack<>();
        TreeNode cur=root;
        while(!stack.isEmpty()||cur!=null){
            if(cur!=null){
                stack.push(cur);
                cur=cur.left;
            }else{
                cur= stack.pop();
                list.add(cur.val);
                cur=cur.right;
            }
        }
    }
}

import java.util.*;
public class Solution {
    int[] result = new int[2];
    int index = 1;
    TreeNode preNode;
    public int[] findError (TreeNode root) {
        if(root == null) return result;
        findError(root.left);
        if(preNode == null)  preNode = root;
        if(index == 1 && root.val < preNode.val) {
            result[index] = preNode.val;
            index--;
        }
        if(index == 0 && root.val < preNode.val) {
            result[index] = root.val;
        }
        preNode = root;
        findError(root.right);
        return result;
    }
}

NC60 判断一棵二叉树是否为搜索二叉树和完全二叉树

描述
给定一棵二叉树，已知其中的节点没有重复值，请判断该二叉树是否为搜索二叉树和完全二叉树。
输出描述：分别输出是否为搜索二叉树、完全二叉树。


数据范围：二叉树节点数满足 0 \le n \le 5000000≤n≤500000 ，二叉树上的值满足 0 \le val \le 1000000≤val≤100000
要求：空间复杂度 O(n)O(n)，时间复杂度 O(n)O(n)

注意：空子树我们认为同时符合搜索二叉树和完全二叉树。
示例1
输入：
{2,1,3}
复制
返回值：
[true,true]
复制
示例2 输入：{1,#,2} 返回值：[true,false]
说明：由于节点的右儿子大于根节点，无左子树，所以是搜索二叉树但不是完全二叉树    
示例3  输入：{}  返回值：[true,true]

思路：
	1 判断二叉搜索树 当前结点的值比前一个小
	2 判断完全二叉树 
		层序遍历，false的情况：（左节点为空&&右节点不为空）  或  （是叶结点但是左右结点不全为空）

import java.util.*;
public class Solution {
    public boolean[] judgeIt (TreeNode root) {
        boolean[] res = new boolean[2];
        res[0] = isSerachTreeBST(root);
        res[1] = isAllTreeBST(root);
        return res;
    }
    long pre = Long.MIN_VALUE;
    public boolean isSerachTreeBST(TreeNode root){
        if(root == null)return true;
        if (!isSerachTreeBST(root.left)) return false;
        if (root.val <= pre)  return false;
        pre = root.val;
        return isSerachTreeBST(root.right);
    }
    
    public boolean isAllTreeBST(TreeNode root){
        if(root == null) return true;
        Deque<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        TreeNode left = null;
        TreeNode right = null;
        boolean flag = false; //标记是否遇到节点不双全的节点
        while(!queue.isEmpty()){
            root = queue.poll();
            left = root.left;
            right = root.right;
            //遇到左右孩子不双全的节点并且该节点不是叶子节点的时候就不是完全二叉树  //左孩子为空并且右孩子不为空的时候不是完全二叉树
            if((flag && !(left == null && right == null)) || (left == null && right != null)){
                return false;
            }
            if(left != null)    queue.offer(left);
            if(right != null)   queue.offer(right);
            if(left == null || right == null)   flag = true;
        }
        return true;
    }
}

NC62判断是不是平衡二叉树

思路：
	递归判断每个结点高度差是否符合条件

public class Solution {
    public boolean IsBalanced_Solution(TreeNode root) {
        if(root==null) return true;
        int n=Math.abs(height(root.left)-height(root.right));
        return (n<=1)&&IsBalanced_Solution(root.left)&&IsBalanced_Solution(root.right);
    }
    public int height(TreeNode root){
        if(root==null) return 0;
        if(root.left==null && root.right==null) return 1;
        return Math.max( height(root.left),height(root.right) )+1;
    }
}

NC72 二叉树镜像

思路：递归

import java.util.*;

public class Solution {
    public TreeNode Mirror (TreeNode pRoot) {
        if(pRoot==null) return pRoot;
        TreeNode left=pRoot.left;
        TreeNode right=pRoot.right;
        pRoot.left=Mirror(right);
        pRoot.right=Mirror(left);
        return pRoot;
    }
}

NC80 把二叉树打印成多行

思路：层序遍历

import java.util.*;
public class Solution {
    ArrayList<ArrayList<Integer> > res=new ArrayList<ArrayList<Integer> >();
    ArrayList<Integer> temp=new ArrayList<Integer>();
    ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        Queue<TreeNode> stack=new LinkedList<>();
        if(pRoot==null) return res;
        stack.offer(pRoot);
        while(!stack.isEmpty()){
            int n=stack.size();
            temp=new ArrayList<Integer>();
            for(int i=0;i<n;i++){
                TreeNode t=stack.poll();
                temp.add(t.val);
                if(t.left!=null) stack.offer(t.left);
                if(t.right!=null) stack.offer(t.right);
            }
            res.add(temp);
        }
        return res;
    }
}

NC81 二叉搜索树的第k个节点

思路： 中序遍历

import java.util.*;
public class Solution {
    ArrayList<Integer> list=new ArrayList<>();
    public int KthNode (TreeNode proot, int k) {
        inOrder(proot);
        return k==0?-1:k>list.size()?-1:list.get(k-1);
    }
    public void inOrder(TreeNode root){
        if(root==null) return;
        inOrder(root.left);
        list.add(root.val);
        inOrder(root.right);
    }
}

NC84 完全二叉树结点数

思路1：递归树的遍历  时间复杂度O（n） 空间复杂度O（n）
思路2：非递归树的遍历  时间复杂度O（n） 空间复杂度O（n）
思路2：利用完全二叉树的性质  时间复杂度O((logn)^2) 空间复杂度O(logn)
	1 满二叉树结点个数 2^h
	2 完全二叉树 
		① 左右高度相等 左为满 
		② 左右高度不等 右为满

思路1：
public class Solution {
    int index=0;
    public int nodeNum(TreeNode head) {
        preOrder(head);
        return index;
    }
    public void preOrder(TreeNode root){
        if(root==null) return;
        preOrder(root.left);
        index++;
        preOrder(root.right);
    }
}

思路2：
import java.util.*;
public class Solution {
    int index=0;
    public int nodeNum(TreeNode head) {
        preOrder(head);
        return index;
    }
    public void preOrder(TreeNode root){
        if(root==null) return;
        Stack<TreeNode> stack=new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node= stack.pop();
            index++;
            if(node.right!=null) stack.push(node.right);
            if(node.left!=null) stack.push(node.left);
        }
    }
}

思路3：
public class Solution {
    public int nodeNum(TreeNode head) {
        if(head == null) return 0;
        int rightHeight = complateTreeHeight(head.right);
        int leftHeight = complateTreeHeight(head.left);
        if(rightHeight == leftHeight){
            return (int)Math.pow(2, leftHeight)  + nodeNum(head.right);
        }else {
            return (int)Math.pow(2, rightHeight)  + nodeNum(head.left);
        }
    }
    public int complateTreeHeight(TreeNode root){
        int count = 0;
        while (root != null){
            count++;
            root = root.left;
        }
        return count;
    }
}

NC98 判断t1树中是否有与t2树完全相同的子树

描述
给定彼此独立的两棵二叉树，树上的节点值两两不同，判断 t1 树是否有与 t2 树完全相同的子树。子树指一棵树的某个节点的全部后继节点。数据范围：树的节点数满足0<n≤500000，树上每个节点的值一定在32位整型范围内
进阶：空间复杂度: O(1)，时间复杂度 O(n)
示例1  输入：{1,2,3,4,5,6,7,#,8,9},{2,4,5,#,8,9}  返回值：true  备注：1≤n≤500000

思路1：递归
思路2：前序遍历+strings.contains()

import java.util.*;
public class Solution {
    public boolean isContains (TreeNode root1, TreeNode root2) {
        if(root1==null) return false;
        if(root1==null&&root2==null) return true;
        return isContains(root1.left,root2)||isContains(root1.right,root2)||isEqual(root1,root2);
    }
    
    public boolean isEqual(TreeNode root1, TreeNode root2){
        if(root1==null && root2==null) return true;
        if(root1==null||root2==null||root1.val!=root2.val) return false;
        return isEqual(root1.left,root2.left) && isEqual(root1.right,root2.right);
    }
}

public class Solution {
    public boolean isContains(TreeNode root1, TreeNode root2) {
        // 利用先序遍历序列化两颗二叉树
        String str1 = preorder(root1);
        String str2 = preorder(root2);
        // 然后判断str1是否包含str2即可
        return str1.contains(str2);
    }
    // 返回先序遍历后的字符串
    private String preorder(TreeNode root) {
        if (root == null)  return "#";
        return root.val + ","+ preorder(root.left) +"," + preorder(root.right)   ;
    }
}

NC102 在二叉树中找到两个节点的最近公共祖先

思路：
	递归 寻找两个结点的最近祖先

import java.util.*;
public class Solution {
    public int lowestCommonAncestor(TreeNode root, int o1, int o2) {
        return helper(root, o1, o2).val;
    }
    public TreeNode helper(TreeNode root, int o1, int o2) {
        if (root == null || root.val == o1 || root.val == o2)  return root;
        TreeNode left = helper(root.left, o1, o2);
        TreeNode right = helper(root.right, o1, o2);
        //如果left为空，说明这两个节点在root结点的右子树上，我们只需要返回右子树查找的结果即可
        if (left == null)  return right;
        if (right == null)   return left;
        //如果left和right都不为空，说明这两个节点一个在root的左子树上一个在root的右子树上，
        //我们只需要返回cur结点即可。
        return root;
    }
}

NC117 合并二叉树

描述
已知两颗二叉树，将它们合并成一颗二叉树。合并规则是：都存在的结点，就将结点值加起来，否则空的位置就由另一个树的结点来代替。例如：
两颗二叉树是:
		1
	    / \
	   3   2
	  /
	 5
	 
	 	 2
	    / \
	   1   3
	   \	\
	 	4	 7
	 	
		 3
	    / \
	   4   5
	  / \	\
	 5	4	 7

思路：
	递归遍历

import java.util.*;
public class Solution {
    public TreeNode mergeTrees (TreeNode t1, TreeNode t2) {
        if(t1 == null) return t2;
        if(t2 == null) return t1;
        t1.val += t2.val;
        t1.left = mergeTrees(t1.left, t2.left);
        t1.right = mergeTrees(t1.right, t2.right);
        return t1;
    }
}

NC123 序列化二叉树

请实现两个函数，分别用来序列化和反序列化二叉树，不对序列化之后的字符串进行约束，但要求能够根据序列化之后的字符串重新构造出一棵与原二叉树相同的树。
二叉树的序列化(Serialize)是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树等遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过 某种符号表示空节点（#）
二叉树的反序列化(Deserialize)是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。
层序序列化(即用函数Serialize转化)如上的二叉树转为"{1,2,3,#,#,6,7}"，再能够调用反序列化(Deserialize)将"{1,2,3,#,#,6,7}"构造成如上的二叉树。
当然你也可以根据满二叉树结点位置的标号规律来序列化，还可以根据先序遍历和中序遍历的结果来序列化。不对序列化之后的字符串进行约束，所以欢迎各种奇思妙想。
数据范围：节点数n≤100，树上每个节点的值满足0≤val≤150
要求：序列化和反序列化都是空间复杂度 O(n)，时间复杂度 O(n)

示例1
输入：{1,2,3,#,#,6,7}
返回值：{1,2,3,#,#,6,7}

示例2
输入：{8,6,10,5,7,9,11}
返回值：{8,6,10,5,7,9,11}

思路：
	序列化：递归先序遍历
	反序列化：递归先序解码

public class Solution {
    public String Serialize(TreeNode root) {
        StringBuilder sb = new StringBuilder();
        if(root == null){
            sb.append("#,");
            return sb.toString();
        }
        sb.append(root.val + ",");
        sb.append(Serialize(root.left));
        sb.append(Serialize(root.right));
        return sb.toString();
  }
   
   int index = -1;   //计数变量
   public TreeNode Deserialize(String str) {
        index++;
        String[] strr = str.split(",");
        TreeNode node = null;
        if(!strr[index].equals("#")){
            node = new TreeNode(Integer.valueOf(strr[index]));
            node.left = Deserialize(str);
            node.right = Deserialize(str);
        }
        return node;
   }
}

NC136 输出二叉树右视图

描述
请根据二叉树的前序遍历，中序遍历恢复二叉树，并打印出二叉树的右视图
数据范围： 0≤n≤10000
要求： 空间复杂度 O(n)，时间复杂度 O(n)
如输入[1,2,4,5,3],[4,2,5,1,3]时，通过前序遍历的结果[1,2,4,5,3]和中序遍历的结果[4,2,5,1,3]可重建出以下二叉树：
示例1  输入：[1,2,4,5,3],[4,2,5,1,3]  返回值：[1,3,5]  备注：二叉树每个节点的值在区间[1,10000]内，且保证每个节点的值互不相同。

思路：
	1 根据前序和后序还原二叉树
	2 层序遍历二叉树 保存每层最后一个结点

import java.util.*;
public class Solution {
    int[] pre;
    HashMap<Integer,Integer> inOrder=new HashMap<Integer,Integer>();
    public int[] solve (int[] xianxu, int[] zhongxu) {
        TreeNode root=reConstructBinaryTree(xianxu, zhongxu);
        ArrayList<Integer> res=new ArrayList<>();
        Queue<TreeNode> stack=new LinkedList<TreeNode>();
        stack.offer(root);
        while(!stack.isEmpty()){
            int n=stack.size();
            for(int i=0;i<n;i++){
                TreeNode temp=stack.poll();
                if(i==(n-1)) res.add(temp.val);
                if(temp.left!=null) stack.offer(temp.left);
                if(temp.right!=null) stack.offer(temp.right);
            }
        }
        int[] resArray=new int[res.size()];
        for(int i=0;i<res.size();i++){
             resArray[i]=res.get(i);
        }
        return resArray;
    }
    
    public TreeNode reConstructBinaryTree(int [] pre,int [] vin) {
        this.pre=pre;
        for(int i=0;i<vin.length;i++) inOrder.put(vin[i],i);
        return reBuild(0,0,vin.length-1);
    }
    
    public TreeNode reBuild(int preindex,int left,int right){
        if(left>right) return null;
        TreeNode root=new TreeNode(pre[preindex]);
        root.left=reBuild(preindex+1,left,inOrder.get(pre[preindex])-1);
        root.right=reBuild(preindex+inOrder.get(pre[preindex])-left+1,inOrder.get(pre[preindex])+1,right);
        return root;
    }
}
CandyDingDing
关注
专栏目录
NC刷题笔记12-贪心算法
且视他人之疑目如盏盏鬼火,大胆走吾之夜路！
04-03 460
NC刷题笔记12-贪心算法BM95 分糖果问题BM96 主持人调度 BM95 分糖果问题 描述 一群孩子做游戏，现在请你根据游戏得分来发糖果，要求如下： 1. 每个孩子不管得分多少，起码分到一个糖果。 2. 任意两个相邻的孩子之间，得分较多的孩子必须拿多一些糖果。(若相同则无此限制) 给定一个数组 arr 代表得分数组，请返回最少需要多少糖果。 要求: 时间复杂度为 O(n) 空间复杂度为 O(n) 数据范围：1≤n≤100000 ，1≤ai≤1000 示例1 输入：[1,1,2] 返回值：4 说明：最优
leetcode刷题笔记-Dijkstra‘s algorithm
Sengo的博客
08-20 8337
Dijkstra's algorithm具体： https://blog.csdn.net/cjc211322/article/details/24933909 505.The Maze II class Solution(object): def shortestDistance(self, maze, start, destination): des = ...
NC刷题笔记4-栈
且视他人之疑目如盏盏鬼火,大胆走吾之夜路！
04-02 496
NC刷题笔记4-栈NC14 按之字形顺序打印二叉树NC45 实现二叉树先序，中序和后序遍历NC52 有效括号序列NC76 用两个栈实现队列LC84 直方图最大矩阵NC90 包含min函数的栈NC115 栈和排序NC117 直方图最大矩阵NC137 表达式求值NC 157单调栈NC175 合法括号字符串NC199 字符串解码NC208 每日温度NC 216 逆波兰表达式NC219 移掉 K 位数字NC237 最大矩形NC240 计算器（一）NC241 计算器（二） NC14 按之字
【菜鸡刷题-NC119】找出其中最小的K个数 || 迭代堆排序|| 小顶堆 || python
Aka_Happy的博客
01-21 169
@author = YHR | 代码原创 | 转载请标明来源 文章目录题目描述方法代码 题目描述 输入n个整数，找出其中最小的K个数。 例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。 方法代码 简单的排序 – 快排/ 冒泡/ 啥都可以 但本宝宝就想用【小顶堆】的【迭代】排序… 反复熟悉一下他，毕竟他可是最好最坏的时间复杂度都为 O(nlogN)的好算法~ ，此外 空间为O(1)哦~ 虽然他不稳定啦。 异常情况处理 # 边界情况处理 .
动态规划刷题NC19
Annie_0321的博客
08-27 200
描述 给定一个数组arr，返回子数组的最大累加和 例如，arr = [1, -2, 3, 5, -2, 6, -1]，所有子数组中，[3, 5, -2, 6]可以累加出最大的和12，所以返回12. 题目保证没有全为负数的数据 [要求] 时间复杂度为O(n)O(n)，空间复杂度为O(1)O(1) 示例1 输入：[1, -2, 3, 5, -2, 6, -1] 返回值：12 解答： import java.util.*; public class Solution { /** * max s
Leetcode No.15 三数之和
10-11 492
一、题目描述 给你一个包含 n 个整数的数组nums，判断nums中是否存在三个元素 a，b，c ，使得a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。 注意：答案中不可以包含重复的三元组。 示例： 给定数组 nums = [-1, 0, 1, 2, -1, -4]， 满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ] 二、解题思路 暴力法的时间复杂度是O(n^3)。可以先固定一个值，然后寻找后两个值时可采取双指针的方法，将总...
NC刷题笔记5-队列
且视他人之疑目如盏盏鬼火,大胆走吾之夜路！
04-02 842
NC刷题笔记5-队列NC82 滑动窗口最大值NC123 序列化二叉树NC267 从上往下打印二叉树 NC82 滑动窗口最大值 描述 给定一个长度为 n 的数组 num 和滑动窗口的大小 size ，找出所有滑动窗口里数值的最大值。 例如，如果输入数组 {2,3,4,2,6,2,5,1} 及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为 {4,4,6,6,6,5}； 针对数组 {2,3,4,2,6,2,5,1} 的滑动窗口有以下6个： {[2,3,4],2,6,2,5,1}， {2,[3,4,
牛客网刷题笔记（一）
weixin_43964189的博客
03-20 314
牛客网刷题笔记
【Leetcode刷题笔记之链表篇】142. 环形链表 II
大家好我叫张同学
01-20 1175
给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 如果链表中有某个节点，可以通过连续跟踪 `next `指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数` pos` 来表示链表尾连接到链表中的位置（索引从` 0` 开始）。如果 pos 是` -1`，则在该链表中没有环。 注意：`pos `不作为参数进行传递，仅仅是为了标识链表的实际情况。`不允许修改` 链表。
编程题刷题笔记（包括leetcode和各种公司笔试题）
weixin_38104825的博客
07-06 4666
7/6：     做的查找中的word_ladder，没做出来。         学到了的知识点：             unordered_set：                 定义为unordered_set&lt;string&gt;dict                 在集合中查找为dict.find(cur_front)，找没找到用if (dict.find(cur_...
关于以前学的都忘了于是决定写几道题练练手这件事
jzc020121的博客
03-15 2208
文章目录关于以前学的都忘了于是决定写几道题练练手这件事pwn复习wp1. 基础nc题例1 get shell例二 bugku -- pwn1 ~~话说bugku更新到只剩三道pwn了？？~~2.简单栈溢出例1 level0例2 born例三 hello_pwn例四 bugku --pwn13.开始分手并逝去的system（/bin/sh）例1 level2例二 --老的bugku--pwn44.格式化字符串例1 cgfsb例二 队长的pwnme2.elf5.我就是要栈溢出例1 int_overflow例
NC6 二叉树中的最大路径和
香蕉的博客
03-27 218
描述 二叉树里面的路径被定义为:从该树的任意节点出发，经过父=>子或者子=>父的连接，达到任意节点的序列。 注意: 1.同一个节点在一条二叉树路径里中最多出现一次 2.一条路径至少包含一个节点，且不一定经过根节点 给定一个二叉树的根节点root，请你计算它的最大路径和 思路：DFS 时间复杂度 :O(N)，N每个节点都要遍历. 空间复杂度是:O(N), N递归树的深度。 struct TreeNode { int val; struct TreeNode *left;
NC5 二叉树根节点到叶子节点的所有路径和
weixin_57769964的博客
01-29 439
描述 给定一个二叉树的根节点root，该树的节点值都在数字\ 0-9 0−9 之间，每一条从根节点到叶子节点的路径都可以用一个数字表示。 1.该题路径定义为从树的根结点开始往下一直到叶子结点所经过的结点 2.叶子节点是指没有子节点的节点 3.路径只能从父节点到子节点，不能从子节点到父节点 4.总节点数目为n 例如根节点到叶子节点的一条路径是1→2→3,那么这条路径就用123来代替。 找出根节点到叶子节点的所有路径表示的数字之和 例如： 这颗二叉树一共有两条路径， 根节点到叶子节点的路径 1→2..
CC27 二叉树中的最大路径和
m0_62396648的博客
05-02 475
描述 二叉树里面的路径被定义为:从该树的任意节点出发，经过父=>子或者子=>父的连接，达到任意节点的序列。 注意: 1.同一个节点在一条二叉树路径里中最多出现一次 2.一条路径至少包含一个节点，且不一定经过根节点 给定一个二叉树的根节点root，请你计算它的最大路径和 例如： 给出以下的二叉树， 最优路径是:2=>1=>3，或者3=>1=>2，最大路径和=2+1+3=6 数据范围：节点数满足 0≤n≤1050 \le n \le 10^50≤n
dfs算法面试题总结
最新发布
syath1314的博客
09-07 151
二叉树里面的路径被定义为:从该树的任意节点出发，经过父=>子或者子=>父的连接，达到任意节点的序列。注意:1.同一个节点在一条二叉树路径里中最多出现一次2.一条路径至少包含一个节点，且不一定经过根节点给定一个二叉树的根节点root，请你计算它的最大路径和例如：给出以下的二叉树，最优路径是:2=>1=>3，或者3=>1=>2，最大路径和=2+1+3=6数据范围：节点数满足 1≤1051≤n≤105要求：空间复杂度O(1)，时间复杂度O(n)
使用dfs求解：NC9二叉树中和为某一值的路径
weixin_56068397的博客
03-03 180
题目描述： 描述 给定一个二叉树root和一个值 sum ，判断是否有从根节点到叶子节点的节点值之和等于 sum 的路径。 1.该题路径定义为从树的根结点开始往下一直到叶子结点所经过的结点 2.叶子节点是指没有子节点的节点 3.路径只能从父节点到子节点，不能从子节点到父节点 4.总节点数目为n 算法思路： 本题使用dfs进行求解，同时采用递归，对于dfs如果遍历到的节点为空则返回false，如果遍历到叶子节点并且从根节点到叶子节点的路径之和刚好等于sum，那么返回true，否则向左右子树进行遍历。 算法实现
【牛客剑指offer刷题】：Python：63. 买卖股票的最好时机(一)
Jack_Kuo的博客
11-30 572
描述 假设你有一个数组prices，长度为n，其中prices[i]是股票在第i天的价格，请根据这个价格数组，返回买卖股票能获得的最大收益 1.你可以买入一次股票和卖出一次股票，并非每天都可以买入或卖出一次，总共只能买入和卖出一次，且买入必须在卖出的前面的某一天 2.如果不能获取到任何利润，请返回0 3.假设买入卖出均无手续费 数据范围： 0≤n≤10000,0≤val≤10000 要求：空间复杂度 O(1)，时间复杂度 O(n) 示例1 输入： [8,9,2,5,4,7,1] 返回值： 5 说明： 在第3
【LeetCode】124. 二叉树中的最大路径和
记录、总结
02-17 349
题目描述： 路径 被定义为一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点，且不一定经过根节点。 路径和 是路径中各节点值的总和。 给你一个二叉树的根节点 root ，返回其 最大路径和 。 示例 1： 输入：root = [1,2,3] 输出：6 解释：最优路径是 2 -> 1 -> 3 ，路径和为 2 + 1 + 3 = 6 示例 2： 输入：root = [-10,9,20,null,null,15
剑指Offer：重建二叉树
weixin_45263663的博客
03-15 739
描述 给定节点数为 n 的二叉树的前序遍历和中序遍历结果，请重建出该二叉树并返回它的头结点。 例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建出如下图所示。 提示: 1.vin.length == pre.length 2.pre 和 vin 均无重复元素 3.vin出现的元素均出现在 pre里 4.只需要返回根结点，系统会自动输出整颗树做答案对比 数据范围：n \le 2000n≤2000，节点的值 -10000 \le val \le 10
NC6.5数据字典-帐户与银行对账信息
"NC 6.5数据字典是NC系统的一个关键组成部分，由Joyce@翰智软件创建，主要用于提供系统内部数据结构的详细信息。这个数据字典包含多个表和字段，例如gl_accountstart和gl_bankreceipt，用于管理财务会计中的帐户启用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

CandyDingDing

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值