牛客 面试必刷TOP101 题解（3、二叉树）

最新推荐文章于 2024-05-26 10:20:15 发布
最新推荐文章于 2024-05-26 10:20:15 发布
阅读量367 收藏
点赞数
分类专栏： 算法 c++ 文章标签： 面试 leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44826485/article/details/128948158
版权

23 二叉树的前序遍历

在这里插入图片描述

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
#include <vector>
class Solution {
public:
    vector<int> ans;
    void show(TreeNode* r){
        if(!r) return;
        ans.push_back(r->val);
        show(r->left);
        show(r->right);
    }
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型vector
     */
    vector<int> preorderTraversal(TreeNode* root) {
        // write code here
        show(root);
        return ans;
    }
};

24 二叉树的中序遍历

在这里插入图片描述

/**
 * struct TreeNode {
 *  int val;
 *  struct TreeNode *left;
 *  struct TreeNode *right;
 *  TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
  public:
    vector<int> ans;
    void show(TreeNode* r) {
        if (!r) return;

        show(r->left);
        ans.push_back(r->val);
        show(r->right);
    }
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param root TreeNode类
     * @return int整型vector
     */
    vector<int> inorderTraversal(TreeNode* root) {
        // write code here
        show(root);
        return ans;
    }
};

25 二叉树的后序遍历

在这里插入图片描述

/**
 * struct TreeNode {
 *  int val;
 *  struct TreeNode *left;
 *  struct TreeNode *right;
 *  TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
  public:
    vector<int> ans;
    void show(TreeNode* r) {
        if (!r) return;

        show(r->left);

        show(r->right);
        ans.push_back(r->val);
    }
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param root TreeNode类
     * @return int整型vector
     */
    vector<int> postorderTraversal(TreeNode* root) {
        // write code here
        show(root);
        return ans;
    }
};

26 求二叉树的层序遍历

在这里插入图片描述

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 * };
 */

#include <cstddef>
#include <queue>
#include <vector>
class Solution {
public:
    /**
     * 
     * @param root TreeNode类 
     * @return int整型vector<vector<>>
     */
    vector<vector<int> > levelOrder(TreeNode* root) {
        // write code here
      
        vector<vector<int> > ans;
        vector<int> Temp;
        queue<TreeNode* > Q;


        if(!root) return ans;
        Q.push(root);
        Temp.push_back(root->val);
        ans.push_back(Temp);

        // cout << Q.size() << endl;
        while (Q.size()) {
            // cout << Q.size() << endl;
            queue<TreeNode* > TQ;
            Temp.clear();
            int m = ans.size(); 
            while (Q.size()) {
                TreeNode* cur = Q.front();Q.pop();
                if(cur->left){
                    Temp.push_back(cur->left->val);
                    TQ.push(cur->left);
                }
                if(cur->right){
                    Temp.push_back(cur->right->val);
                    TQ.push(cur->right);
                }
            }
            if(Temp.size())
                ans.push_back(Temp);
            Q = TQ;
        }
        
        return ans;
        
    }
};

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

在这里插入图片描述


/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    vector<vector<int> > Print(TreeNode* pRoot) {
        vector<vector<int> > ans;
        vector<int> Temp;
        queue<TreeNode* > Q;

        if(!pRoot) return ans;
        Q.push(pRoot);
        Temp.push_back(pRoot->val);
        ans.push_back(Temp);
        
        while (Q.size()) {
            queue<TreeNode* > TQ;
            Temp.clear();
            int m = ans.size(); 
            while (Q.size()) {
                TreeNode* cur = Q.front();Q.pop();
                if(cur->left){
                    Temp.push_back(cur->left->val);
                    TQ.push(cur->left);
                }
                if(cur->right){
                    Temp.push_back(cur->right->val);
                    TQ.push(cur->right);
                }
            }
            if(Temp.size()){
                if(ans.size()%2 == 1){
                    vector<int> e;
                    for(int i=Temp.size()-1;i>=0;i--)
                        e.push_back(Temp[i]);
                    ans.push_back(e);
                }else {
                    ans.push_back(Temp);
                }
            }
                
            Q = TQ;
        }
        return ans;
    }
    
};

28 二叉树的最大深度

在这里插入图片描述

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 * };
 */

class Solution {
public:
    int awm(TreeNode* T){
        if(!T) return 0;
        return max(awm(T->left), awm(T->right)) + 1;
    }
    /**
     * 
     * @param root TreeNode类 
     * @return int整型
     */
    int maxDepth(TreeNode* root) {
        // write code here
        return  awm(root);
    }
};

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

在这里插入图片描述

/**
 * struct TreeNode {
 *  int val;
 *  struct TreeNode *left;
 *  struct TreeNode *right;
 * };
 */

class Solution {
  public:
    bool awm(TreeNode* T, int sum) {
        if (!T)
            return false;
        sum -= T->val;
        if (!T->left && !T->right && sum == 0)
            return true;
        return  awm(T->left, sum) || awm(T->right, sum);
    }
    /**
     *
     * @param root TreeNode类
     * @param sum int整型
     * @return bool布尔型
     */
    bool hasPathSum(TreeNode* root, int sum) {
        // write code here

        return awm(root, sum);
    }
};

30 二叉搜索树与双向链表在这里插入图片描述

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
	TreeNode* head;
	TreeNode* pre;
    TreeNode* Convert(TreeNode* pRootOfTree) {
        if(!pRootOfTree)
			return NULL;
		Convert(pRootOfTree->left);
		if(head == NULL){
			head = pRootOfTree;
			pre = pRootOfTree;
		}else {
			pre->right = pRootOfTree;
			pRootOfTree->left = pre;
			pre = pRootOfTree;
		}
		Convert(pRootOfTree->right);
		return head;
    }
};

31 对称的二叉树

在这里插入图片描述


/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
  public:

    bool awm(TreeNode* T1,TreeNode* T2) {
        if(!T1 && !T2)
            return true;
        if(!T1 || !T2 || T1->val!=T2->val)
            return false;
        return awm(T1->left, T2->right) && awm(T1->right, T2->left);
    }
    bool isSymmetrical(TreeNode* pRoot) {
        if(!pRoot) return true;
        return awm(pRoot->left,pRoot->right);
    }

};

32 合并二叉树

在这里插入图片描述

/**
 * struct TreeNode {
 *  int val;
 *  struct TreeNode *left;
 *  struct TreeNode *right;
 * };
 */

class Solution {
  public:
   
    /**
     *
     * @param t1 TreeNode类
     * @param t2 TreeNode类
     * @return TreeNode类
     */
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        // write code here
        if(!t1)
            return t2;
        if(!t2)
            return t1;
        TreeNode* node = new TreeNode(t1->val+t2->val);
        node->left = mergeTrees(t1->left, t2->left);
        node->right = mergeTrees(t1->right, t2->right);
        return node;
       
    }
};

33 二叉树的镜像

在这里插入图片描述

/**
 * struct TreeNode {
 *  int val;
 *  struct TreeNode *left;
 *  struct TreeNode *right;
 *  TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
  public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param pRoot TreeNode类
     * @return TreeNode类
     */
    TreeNode* Mirror(TreeNode* pRoot) {
        // write code here
        if (!pRoot)
            return NULL;
        TreeNode* temp = pRoot->right;
        pRoot->right = pRoot->left;
        pRoot->left = temp;
        if (pRoot->left)
            Mirror(pRoot->left);
        if (pRoot->right)
            Mirror(pRoot->right);
        return pRoot;
    }
};

34 判断是不是二叉搜索树在这里插入图片描述

/**
 * struct TreeNode {
 *  int val;
 *  struct TreeNode *left;
 *  struct TreeNode *right;
 *  TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
#include <climits>
class Solution {
  public:
    long pre = INT_MIN;
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param root TreeNode类
     * @return bool布尔型
     */
    bool isValidBST(TreeNode* root) {
        // write code here
        if (!root) return true;
        if(!isValidBST(root->left))
            return false;
        if(root->val <= pre)
            return false;
        pre = root->val;
        if(!isValidBST(root->right))
            return false;
        return true;

    }
};

35 判断是不是完全二叉树

在这里插入图片描述

/**
 * struct TreeNode {
 *  int val;
 *  struct TreeNode *left;
 *  struct TreeNode *right;
 *  TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
#include <queue>
class Solution {
  public:

    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param root TreeNode类
     * @return bool布尔型
     */
    bool isCompleteTree(TreeNode* root) {
        // write code here
        if (!root) return true;
        int p = 0;
        queue<TreeNode*> Q;
        Q.push(root);
        while (Q.size()) {
            TreeNode* node = Q.front();
            Q.pop();
            if (p == 1 && node)
                return false;
            if (!node) {
                p = 1;
            } else {
                Q.push(node->left);
                Q.push(node->right);
            }


        }
        return true;
    }
};

36 判断是不是平衡二叉树

在这里插入图片描述

#include <algorithm>
class Solution {
  public:
    int awm(TreeNode* t) {
        if(!t) return 0;
        int a = awm(t->left);
        int b = awm(t->right);
        if(a==-1 || b==-1)
            return -1;
        int c = abs(a-b);
        if(c == 0 || c == 1)
            return max(a, b)+1;
        else
         return -1;
    }
    bool IsBalanced_Solution(TreeNode* pRoot) {
        int ans = awm(pRoot);
        return ans!=-1;
    }
};

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

在这里插入图片描述

/**
 * struct TreeNode {
 *  int val;
 *  struct TreeNode *left;
 *  struct TreeNode *right;
 *  TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
#include <algorithm>
#include <stack>
#include <vector>
class Solution {
  public:
    TreeNode* awm(TreeNode* T, int p, int q) {
        if (!T || T->val == p || T->val == q)
            return T;

        TreeNode* left = NULL;
        TreeNode* right = NULL;
        if (T->val < min(p, q)) {
            left = NULL;
        } else {
            left = awm(T->left, p, q);
        }
        if (T->val > max(p, q)) {
            right = NULL;
        } else {
            right = awm(T->right, p, q);
        }
        if (!left)
            return right;
        if (!right)
            return left;
        return T;
    }

    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param root TreeNode类
     * @param p int整型
     * @param q int整型
     * @return int整型
     */
    int lowestCommonAncestor(TreeNode* root, int p, int q) {
        // write code here
        return awm(root, p, q)->val;
    }
};

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

在这里插入图片描述

/**
 * struct TreeNode {
 *  int val;
 *  struct TreeNode *left;
 *  struct TreeNode *right;
 * };
 */

class Solution {
  public:

    TreeNode* awm(TreeNode* T, int o1, int o2) {
        if (!T || T->val == o1 || T->val == o2)
            return T;
        TreeNode* left = awm(T->left, o1, o2);
        TreeNode* right = awm(T->right, o1, o2);
        if(!left)
            return right;
        if(!right)
            return left;
        return T;

    }
    /**
     *
     * @param root TreeNode类
     * @param o1 int整型
     * @param o2 int整型
     * @return int整型
     */
    int lowestCommonAncestor(TreeNode* root, int o1, int o2) {
        // write code here
        return awm(root, o1, o2)->val;
    }
};

39 序列化二叉树

在这里插入图片描述

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
#include <cstddef>
#include <string>
#include <vector>
class Solution {
  public:
   
    char* Serialize(TreeNode* root) {
       
        if (!root) return "$";
        string ans = "";
        queue<TreeNode*> Q;
        Q.push(root);
        while (Q.size()) {
            TreeNode* node = Q.front();
            Q.pop();
            if (node) {
                ans += to_string(node->val) + "|";
                Q.push(node->left);
                Q.push(node->right);
            } else {
                ans += "#|";
            }
        }
        ans += "$";
        cout << ans << endl;
        char* C = new char[ans.length() + 1];
        strcpy(C, ans.c_str());
        C[ans.length()] = '\0';
        return C;
    }
    TreeNode* awm(int p, vector<int> V) {
        cout << V[p] << endl;
        if (V[p] == -1 || p >= V.size()) return NULL;
        TreeNode* node = new TreeNode(V[p]);
        node->left = awm(p * 2, V);
        node->right = awm(p * 2 + 1, V);
        return node;
    }
    TreeNode* Deserialize(char* str) {

        if (str[0] == '$') return NULL;
        vector<int> V;
        V.push_back(-1);
        int p = 0;

        while (str[p] != '$') {
            if (str[p] == '#') {
                V.push_back(-1);
                p++;
            } else {
                int num = 0;
                while (str[p] != '$' && str[p] != '|') {
                    num *= 10;
                    num += str[p] - '0';
                    p++;
                }
                V.push_back(num);
            }
            p++;
        }
        for (int i = 1; i < V.size(); i++) {
            if (V[i] == -1) {
                if (i * 2 < V.size()) {
                    V.insert(V.begin() + i * 2, -1);
                    V.insert(V.begin() + i * 2 + 1, -1);
                }
            }
        }

        for (int i = 0; i < V.size(); i++)
            cout << V[i] << "  ";
        cout << endl;

        return awm(1, V);
    }
};

40 重建二叉树

在这里插入图片描述

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
#include <vector>
class Solution {
  public:


    TreeNode* reConstructBinaryTree(vector<int> pre, vector<int> vin) {
        int len1 = pre.size();
        int len2 = vin.size();
        if (!len1 || !len2)
            return NULL;
        TreeNode* node = new TreeNode(pre[0]);
        for (int i = 0; i < len2; i++) {
            if (pre[0] == vin[i]) {
                vector<int> lPre (pre.begin() + 1, pre.begin() + i + 1);
                vector<int> lVin (vin.begin(), vin.begin() + i);
                node->left = reConstructBinaryTree(lPre, lVin);
                vector<int> rPre (pre.begin() + 1 + i, pre.end());
                vector<int> rVin (vin.begin() + i + 1, vin.end());
                node->right = reConstructBinaryTree(rPre, rVin);
                break;
            }
        }
        return node;
    }
};

41 输出二叉树的右视图在这里插入图片描述


#include <queue>
#include <vector>
class Solution {
  public:
    TreeNode* reConstructBinaryTree(vector<int> pre, vector<int> vin) {
        int len1 = pre.size();
        int len2 = vin.size();
        if (!len1 || !len2)
            return NULL;
        TreeNode* node = new TreeNode(pre[0]);
        for (int i = 0; i < len2; i++) {
            if (pre[0] == vin[i]) {
                vector<int> lPre (pre.begin() + 1, pre.begin() + i + 1);
                vector<int> lVin (vin.begin(), vin.begin() + i);
                node->left = reConstructBinaryTree(lPre, lVin);
                vector<int> rPre (pre.begin() + 1 + i, pre.end());
                vector<int> rVin (vin.begin() + i + 1, vin.end());
                node->right = reConstructBinaryTree(rPre, rVin);
                break;
            }
        }
        return node;
    }

    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 求二叉树的右视图
     * @param xianxu int整型vector 先序遍历
     * @param zhongxu int整型vector 中序遍历
     * @return int整型vector
     */
    vector<int> solve(vector<int>& xianxu, vector<int>& zhongxu) {
        // write code here
        TreeNode* root = reConstructBinaryTree(xianxu,zhongxu);

        vector<int> ans;
        if(!root) return ans;
        queue<TreeNode*> Q;
        Q.push(root);
        
        while (Q.size()) {

            queue<TreeNode*> temp;
            while(Q.size()){
                TreeNode* node = Q.front();Q.pop();
                
                if(node->left) temp.push(node->left);
                if(node->right) temp.push(node->right);
         
                if(!Q.size()){
                    ans.push_back(node->val);
                    Q = temp;
                    break;
                }
            }

        }
        return ans;

    }
};
nyfz_wyq
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
牛客网《剑指offer》专栏刷题练习之二叉树合集
微凉秋意的博客
09-07 754
本篇文章给大家分享牛客网《剑指offer》专栏中有关二叉树的经典算法题解，我会按照自己的理解与思路帮助大家搞懂算法流程。
牛客面试必刷101代码总结【python】
Anthony_hit的博客
04-15 1803
牛客面试题必刷101代码总结
牛客编程题--必刷101之二叉树篇
qq_36317312的博客
05-11 614
前序遍历 public int[] preorderTraversal (TreeNode root) { // write code here List<Integer> list = new ArrayList<>(); dfs(list,root); int[] res = new int[list.size()]; for(int i =0;i<list.size();i++){
牛客-剑指offer系列题解:重建二叉树
weixin_42042056的博客
04-27 179
记录刷题的过程。牛客和力扣中都有相关题目，这里以牛客的题目描述为主。该系列默认采用python语言。 1、问题描述： 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。 2、数据结构： 二叉树 3、题解： 递归 -...
[刷题记录]牛客面试笔刷TOP101(一)
weixin_67719939的博客
09-07 1083
个人的刷题小总结.自用,会持续更新的,加油.
牛客题霸-二叉树最大深度题解
weixin_47245991的博客
11-06 123
牛客题霸-二叉树最大深度题解 原题链接：https://www.nowcoder.com/practice/8a2b2bf6c19b4f23a9bdb9b233eefa73?tpId=188&rp=1&ru=%2Fta%2Fjob-code-high-week&qru=%2Fta%2Fjob-code-high-week%2Fquestion-ranking bfs求二叉树最大深度 /** * struct TreeNode { * int val; * struct
牛客-剑指offer系列题解:二叉树的镜像
weixin_42042056的博客
04-29 194
记录刷题的过程。牛客和力扣中都有相关题目，这里以牛客的题目描述为主。该系列默认采用python语言。 1、问题描述： 操作给定的二叉树，将其变换为源二叉树的镜像。 2、数据结构： 二叉树 3、题解： 处理根节点，处理左子树，处理右子树。 # -*- coding:utf-8 -*- # class TreeNode: # def __init__(self, x): # s...
牛客每日一题 平衡二叉树 题解（dp）
hunxuewangzi的博客
07-09 184
题目链接 题目思路 感觉这种题目对于我来说完全没思路。。。。哭了 要想让左子树点数-右子树点数的绝对值最大 ，我们可以把左子树尽量塞满，右子树用尽量少的节点。 左子树高度n-1，塞满的节点数为2^(n-1)-1 右子树高度要尽量小，为n-1-d，然后对于右子树的每个子树，把子树的左子树高度拉满点数尽量小树，右子树的高度尽量小，这个过程显然是个递归的过程，即设f[i]为高度为i的“平衡”树的最小的点数，显然f[i] = 1+f[i-1]+f[i-d-1]。 代码 #include<cstdio>
【牛客题解】 ——之字形打印二叉树
Vicky_Cr的博客
04-22 147
之字形打印二叉树 （我以为跟此次遍历二叉树一样那么简单，发现人家这个题貌似比层次遍历高一个level） 思路：利用队列，队列中出一个元素，就把它的左右孩子带进去，不过先开始得设置一个标志位为false，表示他不是从左往右打印的，每一个层次遍历完，都改变falg的值，falg为false，那就翻转 /* struct TreeNode { int val; struct TreeN...
牛客题霸NC12重建二叉树Java题解
云飞扬°的博客
11-27 222
牛客题霸NC12重建二叉树Java题解https://www.nowcoder.com/practice/8a19cbe657394eeaac2f6ea9b0f6fcf6?tpId=117&&tqId=35043&rp=1&ru=/ta/job-code-high&qru=/ta/job-code-high/question-ranking 方法：递归解题思路：在前序遍历中找根节点，可将中序遍历划分为左、根、右。根据中序遍历中的左、右子树的节点数量，可以将前序...
牛客面试算法top101（JAVA和C++）
04-30
牛客面试算法top101（JAVA和C++）
牛客中总结的面试知识概括整理，
04-27
对牛客上面试的总结知识点，和做题目的知识点记录； 牛客中关于spring的题目，所涉及的知识点总结
牛客AI模拟面试1测开岗
01-06
需要的知识 软件测试基础理论知识 黑盒，白盒 编程语言基础 C/C++ java python等 自动化测试工具 Selenium Appium Robotium 计算机基础知识 数据库、Linux、计算机网络 测试框架 ...一般是开发用的比较多，动手能力强的...
牛客面试经验帖子
02-28
该本当为牛客面经经验帖子，里边有很多经验，都是做软件开发的职位的
最新2019的牛客校招面试java.rar
08-18
牛客网整理的最新2019校招java面试题pdf版，共185页，有需要可以下载
Ajax面试题精选及参考答案（3万字长文）
最新发布
linweidong的专栏
05-26 160
Ajax（Asynchronous JavaScript and XML）是一种在不重新加载整个页面的情况下，能够与服务器交换数据并更新部分网页的技术。：这是一个JavaScript对象，用于在客户端与服务器之间进行异步通信。通过它，JavaScript可以发送HTTP请求到服务器，并接收服务器返回的数据。JavaScript：作为Ajax的核心，JavaScript负责创建XMLHttpRequest对象，发送请求，处理服务器响应，以及更新DOM（文档对象模型）以反映数据的变化。DOM操作。
java面试（JVM）
qq_73182976的博客
05-25 904
程序计数器：线程私有的，内部保存字节码的行号。用于记录正在执行的字节码指令的地址。
【面试】PWM（脉冲宽度调制）相关问题 ——长期更新
当实力撑不起野心的时候 学习才是唯一出路
05-23 237
当计数器输出频率一定时，PWM的周期由重加载寄存器（ARR）决定，当周期一定时，占空比由捕获比较寄存器（CCR）决定，调节精度由ARR决定。通过改变信号的高电平和低电平的持续时间比例来控制输出信号的平均功率或电压。答：适用于惯性系统。惯性系统：启动需要时间。3、PWM波形的周期和调节精度由谁决定。答：通过捕获比较寄存器CCR的值调节。4、PWM占空比如何调节。6、PWM适用在哪种系统。
Java高级面试精粹：问题与解答集锦（一）
Layla_c的博客
05-23 1453
答案多态是Java中的一个核心概念，它允许不同类的对象对同一消息做出响应，但具体的行为会根据对象的实际类型而有所不同。重载（Overloading）：当多个方法具有相同的名称，但参数列表不同时，这称为方法重载。编译器根据方法调用时传递的参数类型和数量来确定调用哪个方法。重写（Overriding）：当子类有一个与父类同名、同参数列表的方法时，子类可以提供特定的实现来覆盖父类的方法。运行时，Java虚拟机（JVM）会根据对象的实际类型调用相应的方法，这个过程称为动态绑定或晚期绑定。答案。
python牛客84二叉树和为某一值的路径3
09-17
题目要求：给定一个二叉树和一个整数target，找出所有从根节点到叶子节点路径之和等于target的路径。 解题思路：可以使用深度优先搜索（DFS）的方法来解决该问题。首先定义一个辅助函数来进行递归搜索，该辅助函数...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值