二叉树——面试必刷TOP101

最新推荐文章于 2024-06-12 23:40:32 发布
最新推荐文章于 2024-06-12 23:40:32 发布
阅读量307 收藏
点赞数
分类专栏： 题目记录 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xmm18323188267Ella/article/details/124607216
版权

二叉树

BM23 二叉树的前序遍历

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {

    ArrayList<Integer> list=new ArrayList<>();
    public int[] preorderTraversal (TreeNode root) {
        pre(root);
        int[] res=new int[list.size()];
        for(int i=0;i<list.size();i++){
            res[i]=list.get(i);
        }
        return res;
    }
    private void pre(TreeNode root){
        if(root==null) return;
        list.add(root.val);
        pre(root.left);
        pre(root.right);
    }
}
// 先把当前节点的值保存到list中，然后再把它的右孩子节点、左孩子节点分别压入stack中
private void pre(TreeNode root){
    Stack<TreeNode> stack = new Stack<>();
    if(root == null)return;
    stack.push(root);
    while (!stack.isEmpty()) {
        TreeNode node = stack.pop();
        list.add(node.val);
        if (node.right != null) stack.push(node.right);
        if (node.left != null) stack.push(node.left);
    }
}

BM24 二叉树的中序遍历

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {

    ArrayList<Integer> list=new ArrayList<>();
    public int[] inorderTraversal (TreeNode root) {
        in(root);
        int[] res=new int[list.size()];
        for(int i=0;i<list.size();i++){
            res[i]=list.get(i);
        }
        return res;
    }
    private void in(TreeNode root){
        if(root==null) return;
        in(root.left);
        list.add(root.val);
        in(root.right);
    }
}
// 
private void in(TreeNode root){
    Stack<TreeNode> stack = new Stack<>();
    if(root == null)return;
    while (root != null || !stack.isEmpty()) {
        while (root != null) {
            stack.add(root);
            root = root.left;
        }
        TreeNode node = stack.pop();
        list.add(node.val);
        root = node.right;
    }
}

BM25 二叉树的后序遍历

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {

    ArrayList<Integer> list =new ArrayList<>();
    public int[] postorderTraversal (TreeNode root) {
        post(root);
        int[] res=new int[list.size()];
        for(int i=0;i<list.size();i++){
            res[i]=list.get(i);
        }
        return res;
    }
    private void post(TreeNode root){
        if(root==null) return;
        post(root.left);
        post(root.right);
        list.add(root.val);
    }
}
// 
private void post(TreeNode root){
    Stack<TreeNode> stack = new Stack<>();
    if(root == null) return;
    stack.push(root);
    while (!stack.isEmpty()) {
        TreeNode node = stack.pop();
        list.add(node.val);
        if (node.left != null) stack.push(node.left);
        if (node.right != null) stack.push(node.right);
    }
    Collections.reverse(list);
}

BM26 求二叉树的层序遍历

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {

    ArrayList<ArrayList<Integer>> res=new ArrayList<>();
    ArrayList<TreeNode> queue=new ArrayList<>();
    public ArrayList<ArrayList<Integer>> levelOrder (TreeNode root) {
        if(root!=null) queue.add(root);
        while(queue.size()!=0){
            ArrayList<Integer> path=new ArrayList<>();
            for(int i=queue.size()-1;i>=0;i--){
                TreeNode node=queue.remove(0);
                path.add(node.val);
                if(node.left!=null) queue.add(node.left);
                if(node.right!=null) queue.add(node.right);
            }
            res.add(path);
        }
        return res;
    }
}

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

import java.util.ArrayList;

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    ArrayList<ArrayList<Integer>> res=new ArrayList<>();
    ArrayList<TreeNode> queue=new ArrayList<>();
    public ArrayList<ArrayList<Integer> > Print(TreeNode root) {
        if(root!=null) queue.add(root);
        while(queue.size()!=0){
            ArrayList<Integer> path=new ArrayList<>();
            for(int i=queue.size()-1;i>=0;i--){
                TreeNode node=queue.remove(0);
                if(res.size()%2==1) path.add(0,node.val);
                else path.add(node.val);
                if(node.left!=null) queue.add(node.left);
                if(node.right!=null) queue.add(node.right);
            }
            res.add(path);
        }
        return res;
    }

}

BM28 二叉树的最大深度

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {

    public int maxDepth (TreeNode root) {
        if(root==null) return 0;
        return Math.max(maxDepth(root.left),maxDepth(root.right))+1;
    }
}

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

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {

    public boolean hasPathSum (TreeNode root, int sum) {
        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);
    }
}

BM30 二叉搜索树与双向链表

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    TreeNode pre,head;
    public TreeNode Convert(TreeNode root) {
        if(root==null) return null;
        in(root);
        return head;
    }
    private void in(TreeNode cur){
        if(cur==null) return;
        in(cur.left);
        if(pre==null) head=cur;
        else pre.right=cur;
        cur.left=pre;
        pre=cur;
        in(cur.right);
    }
}

BM31 对称的二叉树

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    boolean isSymmetrical(TreeNode root) {
        if(root==null) return true;
        return dfs(root.left,root.right);
    }
    private boolean dfs(TreeNode l,TreeNode r){
        if(l==null && r==null) return true;
        if(l==null || r==null || l.val!=r.val) return false;
        return dfs(l.left,r.right) && dfs(l.right,r.left);
    }
}

BM32 合并二叉树

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        if(root1==null||root2==null) return root1==null?root2:root1;
        return dfs(root1,root2);
    }
    public TreeNode dfs(TreeNode r1,TreeNode r2){
        if(r1==null||r2==null) return r1==null?r2:r1;
        r1.val+=r2.val;
        r1.left=dfs(r1.left,r2.left);
        r1.right=dfs(r1.right,r2.right);
        return r1;
    }
}

BM33 二叉树的镜像

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {

    public TreeNode Mirror (TreeNode root) {
        if(root==null) return null;
        TreeNode tmp=root.left;
        root.left=Mirror(root.right);
        root.right=Mirror(tmp);
        return root;
    }
}

BM34 判断是不是二叉搜索树

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {

    long pre=Long.MIN_VALUE;
    public boolean isValidBST (TreeNode root) {
        if(root==null) return true;
        if(!isValidBST(root.left)) return false;
        if(root.val<=pre) return false;
        pre=root.val;
        return isValidBST(root.right);
    }
}

BM35 判断是不是完全二叉树

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {

    int n=0,p=0;;
    public boolean isCompleteTree (TreeNode root) {
        if(root==null) return true;
        dfs(root,1);
        return n==p;
    }
    private void dfs(TreeNode root,int i){
        if(root==null) return;
        n++;
        p=Math.max(p,i);
        dfs(root.left,2*i);
        dfs(root.right,2*i+1);
    }
}

BM36 判断是不是平衡二叉树

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

BM37 二叉搜索树的最近公共祖先

import java.util.*;

public class Solution {

    public int lowestCommonAncestor (TreeNode root, int p, int q) {
        if(root.val>p && root.val>q) return lowestCommonAncestor(root.left,p,q);
        if(root.val<p && root.val<q) return lowestCommonAncestor(root.right,p,q);
        return root.val;
    }
}

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

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {

    public int lowestCommonAncestor (TreeNode root, int p, int q) {
        if(root==null) return -1;
        if(root.val==p||root.val==q) return root.val;
        int left=lowestCommonAncestor(root.left,p,q);
        int right=lowestCommonAncestor(root.right,p,q);
        if(left==-1) return right;
        if(right==-1) return left;
        return root.val;
    }
}

BM39 序列化二叉树

import java.util.*;
/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    String Serialize(TreeNode root) {
        if(root==null)return "[]";
        StringBuilder res =new StringBuilder("[");
        ArrayList<TreeNode> queue =new ArrayList<>();
        if(root!=null)queue.add(root);
        while(queue.size()!=0){
            TreeNode node= queue.remove(0);
            if(node!=null){
                res.append(node.val+",");
                queue.add(node.left);
                queue.add(node.right);
            }
            else res.append("null,");
        }
        res.deleteCharAt(res.length()-1);
        res.append("]");
        return res.toString();   
    }
    TreeNode Deserialize(String data) {
        if(data.equals("[]"))return null;
        String[] vals=data.substring(1,data.length()-1).split(",");
        TreeNode root =new TreeNode(Integer.parseInt(vals[0]));
        ArrayList<TreeNode> queue=new ArrayList<>();
        if(root!=null)queue.add(root);
        int i=1;
        while(queue.size()!=0){
            TreeNode node=queue.remove(0);
            if(!vals[i].equals("null")){
                node.left=new TreeNode(Integer.parseInt(vals[i]));
                queue.add(node.left);
            }
            i++;
            if(!vals[i].equals("null")){
                node.right=new TreeNode(Integer.parseInt(vals[i]));
                queue.add(node.right);
            }
            i++;
        }
        return root; 
    }
}

BM40 重建二叉树

import java.util.*;

public class Solution {
    int[] pre;
    HashMap<Integer,Integer> map=new HashMap<>();
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        this.pre=pre;
        for(int i=0;i<in.length;i++){
            map.put(in[i],i);
        }
         return dfs(0,0,in.length-1);
    }
    private TreeNode dfs(int root,int l,int r){
        if(l>r) return null;
        TreeNode node=new TreeNode (pre[root]);
        int i=map.get(pre[root]);
        node.left=dfs(root+1,l,i-1);
        node.right=dfs(root+i-l+1,i+1,r);
        return node;
    }
}

BM41 输出二叉树的右视图

/**
 * 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 {
    List<Integer> res=new ArrayList<>();
    List<TreeNode> queue=new ArrayList<>();
    public List<Integer> rightSideView(TreeNode root) {
        if(root!=null) queue.add(root);
        while(queue.size()!=0){
            for(int i=queue.size()-1;i>=0;i--){
                TreeNode node=queue.remove(0);
                if(node.left!=null) queue.add(node.left);
                if(node.right!=null) queue.add(node.right);
                if(i==0) res.add(node.val);
            }
        }
        return res;
    }
}
124. 二叉树中的最大路径和
/**
 * 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 {
    int sum=Integer.MIN_VALUE;
    public int maxPathSum(TreeNode root) {
        dfs(root);
        return sum;
    }
    private int dfs(TreeNode root){
        if(root==null) return 0;
        int left=Math.max(dfs(root.left),0);// 左子树提供的最大路径和
        int right=Math.max(dfs(root.right),0);//右子树提供的最大路径和
        sum=Math.max(sum,root.val+left+right);
        return root.val+Math.max(left,right);
    }
}
543. 二叉树的直径
/**
 * 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 {
    int max=0;
    public int diameterOfBinaryTree(TreeNode root) {
        if(root==null) return 0;
        dfs(root);
        return max;
    }
    private int dfs(TreeNode root){
        if(root==null) return 0;
        int left=dfs(root.left);
        int right=dfs(root.right);
        max=Math.max(left+right,max);
        return Math.max(left,right)+1;
    }
}
662. 二叉树最大宽度
/**
 * 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 {
    //假设满二叉树表示成数组序列，记录节点层数和每一层最左节点的索引
    int max = 0;
    HashMap<Integer, Integer> map = new HashMap<>();
    public int widthOfBinaryTree(TreeNode root) {
        dfs(root, 1, 1);
        return max;
    }
    private void dfs(TreeNode root, int level, int i) {
        if (root == null) return;
        if (!map.containsKey(level)) map.put(level,i);//每一层最左节点的索引
        max = Math.max(max, i-map.get(level)+1);
        dfs(root.left,level+1,i*2);
        dfs(root.right,level+1,i*2+1);
    }
}
剑指 Offer 54. 二叉搜索树的第k大节点
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    int res,k;
    public int kthLargest(TreeNode root, int k) {
        this.k=k;
        dfs(root);
        return res;
    }
    public void dfs(TreeNode root){
        if(root==null)return;
        dfs(root.right);
        if(k==0) return;
        if(--k==0)res=root.val;
        dfs(root.left);
    }
}
230. 二叉搜索树中第K小的元素
/**
 * 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 {
    int res,k;
    public int kthSmallest(TreeNode root, int k) {
        this.k=k;
        dfs(root);
        return res;
    }
    public void dfs(TreeNode root){
        if(root==null) return;
        dfs(root.left);
        if(k==0)return;
        if(--k==0)  res=root.val;
        dfs(root.right);
    }
}
450. 删除二叉搜索树中的节点
/**
 * 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 deleteNode(TreeNode root, int key) {
        if (root == null)    return null;
        if (key > root.val)    root.right = deleteNode(root.right, key);     
        else if (key < root.val)    root.left = deleteNode(root.left, key);  
        else {  
            if (root.left==null)   return root.right; 
            if (root.right==null)  return root.left;  
            TreeNode node = root.right;           
            while (node.left!=null)   node = node.left;
            node.left = root.left;    
            root = root.right;        
        }
        return root;    
    }
}
572. 另一棵树的子树
class Solution {
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        if(root==null) return false;
        return recur(root,subRoot)||isSubtree(root.left,subRoot)
                ||isSubtree(root.right,subRoot);
    }
    public boolean recur (TreeNode root,TreeNode subRoot){
        if(subRoot==null&&root==null) return true;
        if(subRoot==null||root==null||(root.val!=subRoot.val)) return false;
        return recur(root.left,subRoot.left)&&recur(root.right,subRoot.right);
    }
}
208. 实现 Trie (前缀树)
class Trie {
    class TireNode {
        private boolean isEnd;
        TireNode[] next;
        public TireNode() {
            isEnd = false;
            next = new TireNode[26];
        }
    }
    private TireNode root;
    public Trie() {
        root = new TireNode();
    }
    public void insert(String word) {
        TireNode node = root;
        for (char c : word.toCharArray()) {
            if (node.next[c - 'a'] == null) node.next[c - 'a'] = new TireNode();
            node = node.next[c - 'a'];
        }
        node.isEnd = true;
    }
    public boolean search(String word) {
        TireNode node = root;
        for (char c : word.toCharArray()) {
            node = node.next[c - 'a'];
            if (node == null) return false;
        }
        return node.isEnd;
    }
    public boolean startsWith(String prefix) {
        TireNode node = root;
        for (char c : prefix.toCharArray()) {
            node = node.next[c - 'a'];
            if (node == null) return false;
        }
        return true;
    }
}
剑指 Offer 34. 二叉树中和为某一值的路径
class Solution {
    List<List<Integer>> res =new ArrayList<>();
    List<Integer> path=new ArrayList<>();
    public List<List<Integer>> pathSum(TreeNode root, int target) {
        recur(root,target);
        return res;
    }
    public void recur(TreeNode root,int target){
        if(root==null) return;
        path.add(root.val);
        target-=root.val;
        if(target==0&&root.left==null&&root.right==null) res.add(new ArrayList(path));
        recur(root.left,target);
        recur(root.right,target);
        path.remove(path.size()-1);
    }
}

JZ33判断一个数组是不是某二叉搜索树的后序遍历

public class Solution {
    public boolean VerifySquenceOfBST(int [] post) {
        if(post.length==0) return false;
        return recur(post,0,post.length-1);
    }
    public boolean recur(int[] post,int i,int j){
        if(i>=j)return true;
        int k=i;
        while(post[k]<post[j]) k++;
        int m=k;
        while(post[k]>post[j]) k++;
        return k==j&&recur(post,i,m-1)&&recur(post,m,j-1);
    }
}
yy的旅行日志
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最优二叉树——哈夫曼树.doc
07-11
树结构的特点是：它的每一个结点都可以有不止一个直接后继，除根结点外的所有结点都有且只有一个直接前趋。
《剑指Offer》刷题笔记——面试题55-II. 平衡二叉树
12-22
难度：简单 一、题目描述： 二、解题分析： 1、剑指解析 I、自顶向下 II、自底向上 2、代码实现 I、自顶向下 # Definition for a binary tree node. # class TreeNode: # def __init__(self, x): ... def height
算法——（树）BM41:输出二叉树的右视图
weixin_44758107的博客
11-03 315
题目描述： 根据二叉树的前序、中序遍历，输出二叉树的右视图 例如： 前序：[1,2,4,5,3] 中序：[4,2,5,1,3]
牛客BM41. 输出二叉树的右视图
TSWorld
04-22 1070
Description: 题目大意：给出二叉树的前序遍历和中序遍历，输出右视图。 解题思路: 算法标签：BFS 通过前序遍历和中序遍历构造二叉树。 利用层序遍历找到右视图。 代码: class Solution { public: vector<int> rightSideView(TreeNode* root) { unordered_map<int ,int>rightview; int maxdepth = -1;
BM41 输出二叉树的右视图
liulong999的博客
04-04 749
牛客、算法
回溯——面试必刷TOP101
yy的旅行日志的博客
05-06 184
回溯——面试必刷TOP101
【牛客网面试必刷TOP101】二叉树篇（二）
qq_66314292的博客
08-28 1579
二叉树是数据结构中重要的一个章节，他的重要性也不言而喻，在未来不管是笔试还是面试都会遇到这类的题目，所以接下来我就会把一些常考的题目全部整理出来供大家学习指正。
【牛客网面试必刷TOP101】二叉树篇（三）
qq_66314292的博客
09-01 1957
二叉树是数据结构中重要的一个章节，他的重要性也不言而喻，在未来不管是笔试还是面试都会遇到这类的题目，所以接下来我就会把一些常考的题目全部整理出来供大家学习指正。
最全【牛客网面试必刷TOP101】二叉树篇（三）
2401_84164617的博客
05-04 644
二叉树是数据结构中重要的一个章节，他的重要性也不言而喻，在未来不管是笔试还是面试都会遇到这类的题目，所以接下来我就会把一些常考的题目全部整理出来供大家学习指正。
【牛客网面试必刷TOP101】二叉树篇（一）
qq_66314292的博客
08-26 1229
二叉树是数据结构中重要的一个章节，他的重要性也不言而喻，在未来不管是笔试还是面试都会遇到这类的题目，所以接下来我就会把一些常考的题目全部整理出来供大家学习指正。
《剑指Offer》刷题笔记——面试题07. 重建二叉树打印链表
01-20
难度：中等 一、题目描述： 二、解题分析： 1、剑指解析： 2、代码实现： from typing import List ###### 代码主体 ###### ... def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode: ...
二叉树——替罪羊树.ppt
11-07
1 引入替罪羊树的目的 2 替罪羊树的定义 3 替罪羊树的基本操作: 插入 删除 查询
《剑指Offer》刷题笔记——面试题32-II. 从上到下打印二叉树II
12-22
难度：简单 一、题目描述： 二、解题分析： # Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = None class Solution: ...
简单的项目部署脚本（转载）
u010230019的博客
06-09 603
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
m0_74100417的博客
06-09 1230
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
修改菜品——后端Java
weixin_53717695的博客
06-09 406
修改菜品——后端Java
java.lang.reflect.Type是什么
最新发布
yuchangyuan5237的博客
06-12 387
通过 java.lang.reflect.Type 接口及其实现，Java 提供了一个强大的机制，用于在运行时检查和操作类型信息。这在编写通用库、框架和工具时特别有用，因为它允许你处理泛型类型和其他复杂类型结构。
二叉树——课上练（链式存储结构）
10-06
二叉树的链式存储结构是通过定义一个含有数据和指向左右子节点的指针的结构体来实现的。每个结点都包含一个数据项和两个指针，分别指向其左子节点和右子节点。采用链式存储结构的优点是可以灵活地插入、删除和修改节点，但相应的缺点是需要更多的存储空间和额外的指针操作。 在建立二叉树时，可以按照先序遍历的顺序输入节点序列，并采用递归方式进行建立。例如，按照先序输入的节点序列为：a b c # # # d e # f # # g # #。其中，#表示空节点。通过递归方式建立二叉树可以保证节点的插入顺序与先序输入的顺序一致。 关于二叉树的一些特性和存储方式，还有以下几点： 1. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有2^(i-1)个节点。 2. 若规定只有根节点的二叉树的深度为1，则深度为K的二叉树的最大节点数是2^k-1。 3. 对任何一棵二叉树，如果其叶节点个数为n0，度为2的非叶节点个数为n2，则有n0 = n2 + 1。 4. 具有n个节点的完全二叉树的深度k为log2(n+1)向上取整。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值