_13LeetCode代码随想录算法训练营第十三天-C++二叉树

news2024/11/18 21:43:24

_13LeetCode代码随想录算法训练营第十三天-C++二叉树

题目列表

  • 102.二叉树的层序遍历
  • 107.二叉树的层次遍历II
  • 199.二叉树的右视图
  • 637.二叉树的层平均值
  • 429.N叉树的层序遍历
  • 515.在每个树行中找最大值
  • 116.填充每个节点的下一个右侧节点指针
  • 117.填充每个节点的下一个右侧节点指针II
  • 104.二叉树的最大深度
  • 111.二叉树的最小深度
  • 226.翻转二叉树
    1. 对称二叉树

102.二叉树的层序遍历

题目

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

代码

/*
 * @lc app=leetcode.cn id=102 lang=cpp
 *
 * [102] 二叉树的层序遍历
 */

// @lc code=start
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode* > que;
        vector<vector<int>> res;
        //队列为空时肯定是先入队列
        if(root != nullptr)
            que.push(root);
        while(!que.empty())
        {
            //一层一层处理数据
            vector<int> tempRes;
            for(int size = que.size(); size > 0; size--)
            {
                //先出队列并存储元素
                TreeNode* data = que.front();
                tempRes.push_back(data->val);
                que.pop();
                //如果当前元素左右孩子不为空，则将当前元素的左孩子和右孩子入队列
                //这里第一次写的时候忘记判断了，要注意
                if(data->left != nullptr) que.push(data->left);
                if(data->right != nullptr) que.push(data->right);
            }
            res.push_back(tempRes);
        }
        return res;
    }
};
// @lc code=end

107.二叉树的层次遍历II

题目

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

代码

/*
 * @lc app=leetcode.cn id=107 lang=cpp
 *
 * [107] 二叉树的层序遍历 II
 */

// @lc code=start
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> res;
        queue<TreeNode* > que;
        if(root != nullptr)
            que.push(root);
        while(!que.empty())
        {
            vector<int> data;
            for(int size = que.size(); size > 0; size--)
            {
                TreeNode* node = que.front();
                data.push_back(node->val);
                que.pop();
                if(node->left != nullptr) que.push(node->left);
                if(node->right != nullptr) que.push(node->right);
            }
            res.push_back(data);
        }
        //再此处翻转一下即可
        reverse(res.begin(), res.end());
        return res;
    }
};
// @lc code=end

199.二叉树的右视图

题目

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

代码

/*
 * @lc app=leetcode.cn id=199 lang=cpp
 *
 * [199] 二叉树的右视图
 */

// @lc code=start
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> res;
        queue<TreeNode *> que;
        if(root != nullptr)
            que.push(root);
        while(!que.empty())
        {
            vector<int> data;
            for(int size = que.size(); size > 0; size--)
            {
                TreeNode* node = que.front();
                data.push_back(node->val);
                que.pop();
                if(node->left != nullptr) que.push(node->left);
                if(node->right != nullptr) que.push(node->right);
            }
            res.push_back(*(data.end() - 1));
        }
        return res;
    }
};
// @lc code=end

637.二叉树的层平均值

题目

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 1 0 − 5 10^{-5} 10−5以内的答案可以被接受。

代码

/*
 * @lc app=leetcode.cn id=637 lang=cpp
 *
 * [637] 二叉树的层平均值
 */

// @lc code=start
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> res;
        queue<TreeNode* > que;
        if(root != nullptr)
            que.push(root);
        while(!que.empty())
        {
            double sum = 0;
            int size = que.size();
            for(int i = size; i > 0; i--)
            {
                TreeNode* node = que.front();
                sum += node->val;
                que.pop();
                if(node->left != nullptr) que.push(node->left);
                if(node->right != nullptr) que.push(node->right);
            }
            res.push_back(sum / size);
        }
        return res;
    }
};
// @lc code=end

429.N叉树的层序遍历

题目

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。

树的序列化输入是用层序遍历，每组子节点都由 null 值分隔。

代码

/*
 * @lc app=leetcode.cn id=429 lang=cpp
 *
 * [429] N 叉树的层序遍历
 */

// @lc code=start
/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        queue<Node* > que;
        vector<vector<int>> res;
        if(root != nullptr)
            que.push(root);
        while(!que.empty())
        {
            vector<int> data;
            for(int size = que.size(); size > 0; size--)
            {
                Node* node = que.front();
                que.pop();
                data.push_back(node->val);
                for(int i = 0; i < (node->children).size(); i++)
                {
                    if((node->children)[i] != nullptr)
                        que.push((node->children)[i]);
                }
            }
            res.push_back(data);
        }
        return res;
    }
};
// @lc code=end

515.在每个树行中找最大值

题目

给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

代码

/*
 * @lc app=leetcode.cn id=515 lang=cpp
 *
 * [515] 在每个树行中找最大值
 */

// @lc code=start
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        vector<int> res;
        queue<TreeNode* > que;
        if(root != nullptr)
            que.push(root);
        while(!que.empty())
        {
            int max = INT_MIN;
            for(int size = que.size(); size > 0; size--)
            {
                TreeNode* node = que.front();
                que.pop();
                if(node->val > max)
                    max = node->val;
                if(node->left != nullptr) que.push(node->left);
                if(node->right != nullptr) que.push(node->right);
            }
            res.push_back(max);
        }
        return res;
    }
};
// @lc code=end

116.填充每个节点的下一个右侧节点指针

题目

给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

代码

不是和熟练，应该复习。

/*
 * @lc app=leetcode.cn id=116 lang=cpp
 *
 * [116] 填充每个节点的下一个右侧节点指针
 */

// @lc code=start
/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if(root != nullptr)
            que.push(root);
        while(!que.empty())
        {
            Node* pre;
            Node* cur;  
            int size = que.size();             
            for(int i = 0; i < size; i++)
            {
                if(i == 0)
                {
                    pre = que.front();
                    que.pop();
                    cur = pre;
                }
                else
                {
                    cur = que.front();
                    que.pop();
                    pre->next = cur;
                    pre = pre->next;
                }
                if(cur->left != nullptr) que.push(cur->left);
                if(cur->right != nullptr) que.push(cur->right);
            }
            pre->next = nullptr;
        }
        return root;
    }
};
// @lc code=end

117.填充每个节点的下一个右侧节点指针II

题目

给定一个二叉树

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

代码

/*
 * @lc app=leetcode.cn id=117 lang=cpp
 *
 * [117] 填充每个节点的下一个右侧节点指针 II
 */

// @lc code=start
/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node* > que;
        if(root != nullptr)
            que.push(root);
        while(!que.empty())
        {
            Node* pre;
            Node* cur;
            int size = que.size();
            for(int i = 0; i < size; i++)
            {
                if(i == 0)
                {
                    pre = que.front();
                    que.pop();
                    cur = pre;
                }
                else
                {
                    cur = que.front();
                    que.pop();
                    pre->next = cur;
                    pre = pre->next;
                }
                if(cur->left != nullptr) que.push(cur->left);
                if(cur->right != nullptr) que.push(cur->right);
            }
            pre->next = nullptr;
        }
        return root;
    }
};
// @lc code=end

104.二叉树的最大深度

题目

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

代码

/*
 * @lc app=leetcode.cn id=104 lang=cpp
 *
 * [104] 二叉树的最大深度
 */

// @lc code=start
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode* root) {
        queue<TreeNode*> que;
        int depth = 0;
        if(root != nullptr)
            que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            for(int i = 0; i < size; i++)
            {
                TreeNode* node = que.front();
                que.pop();
                if(node->left != nullptr) que.push(node->left);
                if(node->right != nullptr) que.push(node->right);
            }
            depth++;
        }
        return depth;
    }
};
// @lc code=end

111.二叉树的最小深度

题目

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

**说明：**叶子节点是指没有子节点的节点。

代码

/*
 * @lc app=leetcode.cn id=111 lang=cpp
 *
 * [111] 二叉树的最小深度
 */

// @lc code=start
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int minDepth(TreeNode* root) {
        queue<TreeNode* > que;
        int minDepth = 0;
        if(root != nullptr)
            que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            for(int i = 0; i < size; i++)
            {
                TreeNode* node = que.front();
                que.pop();
                if(node->left != nullptr) que.push(node->left);
                if(node->right != nullptr) que.push(node->right);
                if(node->left == nullptr && node->right == nullptr)
                    return ++minDepth;
            }
            minDepth++;
        }
        return minDepth;
    }
};
// @lc code=end

226.翻转二叉树

题目

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

前序递归遍历

/*
 * @lc app=leetcode.cn id=226 lang=cpp
 *
 * [226] 翻转二叉树
 */

// @lc code=start
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(root == nullptr)
            return root;
        //前序遍历方法实现
        swap<TreeNode*>(root->left, root->right);
        invertTree(root->left);
        invertTree(root->right);
        return root;
    }
};
// @lc code=end

后序递归遍历

/*
 * @lc app=leetcode.cn id=226 lang=cpp
 *
 * [226] 翻转二叉树
 */

// @lc code=start
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(root == nullptr)
            return root;
        //后序遍历方法实现        
        invertTree(root->left);
        invertTree(root->right);
        swap<TreeNode*>(root->left, root->right);
        return root;
    }
};
// @lc code=end

中序递归遍历-比较奇怪

/*
 * @lc app=leetcode.cn id=226 lang=cpp
 *
 * [226] 翻转二叉树
 */

// @lc code=start
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(root == nullptr)
            return root;
        //后序遍历方法实现        
        invertTree(root->left);        
        swap<TreeNode*>(root->left, root->right);
        invertTree(root->left);
        return root;
    }
};
// @lc code=end

前序遍历非递归统一写法

/*
 * @lc app=leetcode.cn id=226 lang=cpp
 *
 * [226] 翻转二叉树
 */

// @lc code=start
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        stack<TreeNode*> st;
        if(root != nullptr)
            st.push(root);
        while(!st.empty())
        {
            TreeNode* node = st.top();
            st.pop();
            if(node == nullptr)
            {
                node = st.top();
                st.pop();
                swap<TreeNode*>(node->left, node->right);
            }
            else
            {
                st.push(node);
                st.push(nullptr);
                if(node->right != nullptr) st.push(node->right);
                if(node->left != nullptr) st.push(node->left);
            }
        }
        return root;
    }
};
// @lc code=end

层次遍历

/*
 * @lc app=leetcode.cn id=226 lang=cpp
 *
 * [226] 翻转二叉树
 */

// @lc code=start
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        queue<TreeNode*> que;
        if(root != nullptr)
            que.push(root);
        while(!que.empty())
        {
            TreeNode* node = que.front();
            que.pop();
            swap<TreeNode*>(node->left, node->right);
            if(node->left != nullptr) que.push(node->left);
            if(node->right != nullptr) que.push(node->right);
        }
        return root;
    }
};
// @lc code=end

101.对称二叉树

题目

给你一个二叉树的根节点 root ， 检查它是否轴对称。

整体思路

遍历顺序：

后序遍历：因为我们要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等。

正是因为要遍历两棵树而且要比较内侧和外侧节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中。
在这里插入图片描述

代码

递归代码

/*
 * @lc app=leetcode.cn id=101 lang=cpp
 *
 * [101] 对称二叉树
 */

// @lc code=start
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool compare(TreeNode* left, TreeNode* right)
    {
        //如果左子树为空右子树不为空，返回false
        if(left == nullptr && right != nullptr)
            return false;
        else if(left != nullptr && right == nullptr)//如果右子树为空左子树不为空，返回false
            return false;
        else if(left == nullptr && right == nullptr)//如果左子树和右子树都为空，则返回true
            return true;
        else if(left->val != right->val)//如果左子树和右子树所指元素不相等，则返回false
            return false;
        else//如果左子树和右子树所指向的值相等，则继续遍历
        {
            bool lcom = compare(left->left, right->right);
            bool rcom = compare(left->right, right->left);
            return lcom && rcom;
        }
    }
    bool isSymmetric(TreeNode* root) {
        //注意这个条件一定要判断，不然会访问空指针
        if(root == nullptr)
            return true;
        return compare(root->left, root->right);
    }
};
// @lc code=end

非递归代码

/*
 * @lc app=leetcode.cn id=101 lang=cpp
 *
 * [101] 对称二叉树
 */

// @lc code=start
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        //如果root是空节点，则是对称的
        if(root == nullptr)
            return true;
        //定义一个队列，将左子树和右子树入队列
        queue<TreeNode*> que;
        que.push(root->left);
        que.push(root->right);
        while(!que.empty())
        {
            TreeNode* rightNode = que.front();
            que.pop();
            TreeNode* leftNode = que.front();
            que.pop();
            //如果左右子树都为空，则返回true
            if(leftNode == nullptr && rightNode == nullptr)
                continue;//这里最开始写成了返回true，此时并不能说明整个树都是对称的
            //如果左子树为空或右子树为空或左子树的元素与右子树的元素不等，则返回false
            if(leftNode == nullptr || rightNode == nullptr ||(leftNode->val != rightNode->val))
                return false;
            //现在就只剩下左右子树元素相等的情况了。
            //此时就要继续往下遍历了
            que.push(leftNode->left);
            que.push(rightNode->right);
            que.push(leftNode->right);
            que.push(rightNode->left);            
        }
        return true;
    }
};
// @lc code=end

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/112758.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

说话人识别中的数据预处理和数据增强

说话人识别中的数据预处理和数据增强

数据预处理 假设已经采集到一些数据&#xff0c;在进行训练之前&#xff0c;需要先对数据做以下预处理&#xff1a; 数据清洗语音检测&#xff08;Voice Activity Detection&#xff0c;VAD&#xff0c;也叫Speech Detection&#xff0c;或Silence Suppression&#xff0c;静音…
阅读更多...
ICMP V6（计算机网络-网络层）

ICMP V6（计算机网络-网络层）

IPv6 使用的 ICMP IETF 制定的与IPv6配套使用的ICMP新版本&#xff0c;即ICMPv6 ICMPv6报文作为IPv6分组有效载荷进行传输&#xff0c;对应的IPv6“下一个首部字段”的值为58 ICMPv6 的报文格式和 IPv4 使用的 ICMP 的相似&#xff0c;即前 4 个字节的字段名称都是一样的&…
阅读更多...
Linux下进程及其相关概念理解

Linux下进程及其相关概念理解

目录 何为进程&#xff1f; task_struct 中存储了什么进程信息&#xff1f; 如何查看进程&#xff1f; 如何获取进程pid&#xff1f; 如何创建子进程&#xff1f; 为什么返回值如此呢&#xff1f; 为什么有两个返回值&#xff1f; 进程状态 进程的一般状态 运行态 终…
阅读更多...
18-JavaSE基础巩固练习：正则表达式练习

18-JavaSE基础巩固练习：正则表达式练习

正则表达式基本练习 一、练习1 1、需求 请编写正则表达式验证用户输入的手机号码是否满足要求。请编写正则表达式验证用户输入的邮箱号是否满足要求。请编写正则表达式验证用户输入的电话号码是否满足要求。 2、思路&#xff1a; 心得&#xff1a; 拿着一个正确的数据&…
阅读更多...
SAP UI5 Smart Chart 功能介绍

SAP UI5 Smart Chart 功能介绍

笔者已经写过一篇详细的文章介绍 SAP UI5 Smart Chart 的使用方法&#xff1a; SAP UI5 应用开发教程之一百五十三 - 使用 SAP UI5 Smart Chart 控件轻松绘制十数种不同类型的专业图表 本文泛泛地介绍 Smart Chart 提供的一些其他功能。 工具栏右侧的按钮可用于选择图表类型…
阅读更多...
Zookeeper 1 初识 Zookeeper 1.1 Zookeeper 概念

Zookeeper 1 初识 Zookeeper 1.1 Zookeeper 概念

Zookeeper 【黑马程序员Zookeeper视频教程&#xff0c;快速入门zookeeper技术】 文章目录Zookeeper1 初识 Zookeeper1.1 Zookeeper 概念1.1.1 Zookeeper 概念1 初识 Zookeeper 1.1 Zookeeper 概念 1.1.1 Zookeeper 概念 Zookeeper 是 Apache Hadoop 项目下的一个子项目&…
阅读更多...
3、前端笔记-JS-变量

3、前端笔记-JS-变量

1、什么是变量 变量是用于存放数据的容器&#xff0c;可以通过变量名获取数据 本质&#xff1a;变量是程序在内存中申请的一块用来存放数据的空间 2、变量的使用 2.1 声明变量和赋值 1、声明变量 2、给变量赋值 var:JS关键字&#xff0c;用来声明变量。使用这个关键字后&a…
阅读更多...
（二）计算机组成原理——计算机的基本组成

（二）计算机组成原理——计算机的基本组成

目录 冯诺依曼计算机的特点 计算机硬件框图 系统复杂性管理的方法&#xff08;3’Y&#xff09; 计算机的工作步骤 上机前的准备 计算机的工作过程 存储器的基本组成 运算器的基本组成及操作过程 控制器 计算机组成原理课程笔记。 冯诺依曼计算机的特点 冯诺依曼计算…
阅读更多...
sandbox启动未加载repeater的问题

sandbox启动未加载repeater的问题

背景 通过官方提供的 repeater 的下载链接&#xff0c;并不能够在sandbox启动时&#xff0c;加载进行&#xff0c;我们可以看下sandbox的日志截图 但是如果通过源码的repeater进行安装后&#xff0c;就能够成功加载到repeater。 分析 这是个很奇怪的问题&#xff0c;想要分析…
阅读更多...
Sentinel的规则

Sentinel的规则

四.Sentinel的规则 1.流控规则 1.1流控规则有哪些? 流量控制有以下几个角度: 资源的调用关系&#xff0c;例如资源的调用链路&#xff0c;资源和资源之间的关系&#xff1b;运行指标&#xff0c;例如 QPS&#xff08;每秒查询率&#xff09;、线程池、系统负载等&#xff…
阅读更多...
深度学习时数据量过大的一个解决思路：将零散的数据集中化

深度学习时数据量过大的一个解决思路：将零散的数据集中化

问题描述 最近笔者在做一个kaggle上的树叶分类的题目&#xff08;https://www.kaggle.com/competitions/classify-leaves&#xff09;&#xff0c;这个题目要求根据一张树叶的图片给出这片树叶的类别&#xff0c;这个题目也是沐神的《动手深度学习》课程里的一个课程竞赛题目。…
阅读更多...
编译原理笔记03

编译原理笔记03

第四章 语义分析 语义分析也称为类型检查&#xff0c;上下文相关分析&#xff0c;主要负责检查程序的上下文相关的属性&#xff0c;例如变量使用前要声明&#xff0c;函数调用要与声明一致等。 1.语义规则 通常来说&#xff0c;程序设计语言都采用自然语言来表达程序语言的语义…
阅读更多...
JMeter分布式压测

JMeter分布式压测

一、Jmeter4.0分布式压测准备工作 压测注意事项 the firewalls on the systems are turned off or correct ports are opened. 系统上的防火墙被关闭或正确的端口被打开。 all the clients are on the same subnet. 所有的客户端都在同一…
阅读更多...
数据科学与工程理论基础复习提纲

数据科学与工程理论基础复习提纲

一、Sketch 1.1 简单抽样算法 1.1.1 核心思想 对于到达的元素aia_iai​&#xff0c;以概率pM/mpM/mpM/m对该元素的频数加1。 MMM&#xff1a;抽样后的数据流大小mmm&#xff1a;原始数据流大小 1.1.2 操作 更新&#xff1a;当元素aia_iai​到达时&#xff0c;以ppp的概率更…
阅读更多...
分库分表：垂直分库、垂直分表、水平分库、水平分表四个概念

分库分表：垂直分库、垂直分表、水平分库、水平分表四个概念

文章目录一、分库分表的意义二、垂直分表的思路三、垂直分库的思路四、水平分库的思路五、水平分表的思路一、分库分表的意义 随着公司业务快速发展&#xff0c;数据库中的数据量猛增&#xff0c;访问性能也变慢了&#xff0c;优化迫在眉睫。分析一下问题出现在哪儿呢&#xf…
阅读更多...
太强了，阿里内部JDK源码剖析知识手册，由浅入深堪称完美

太强了，阿里内部JDK源码剖析知识手册，由浅入深堪称完美

前言 作为Java程序员&#xff0c;在这里想问问大家在空余时间有没有去读过 JDK 源码&#xff0c;虽然读源码有点自不量力的感觉&#xff0c;&#xff08;大佬可以忽略这句&#xff09;但是如若能够经常在空余时间看一下 jdk 源码不仅可以让自己对日常的开发环境了解得更加深刻…
阅读更多...
【nowcoder】笔试强训Day3

【nowcoder】笔试强训Day3

目录 一、选择题 二、编程题 2.1在字符串中找出连续最长的数字串 2.2 数组中出现次数超过一半的数字 一、选择题 1.以下代码运行输出的是 public class Person{private String name "Person";int age0;} public class Child extends Person{public String gra…
阅读更多...
Python json常见用法

Python json常见用法

目录 导包 api介绍 常见用法 json转python内置对象 字典对象 数组对象 文件读取 python内置对象转json 字典转json 字典转json&#xff08;压缩存储&#xff09; 字典转json&#xff08;美化输出&#xff09; 文件读取 自定义对象 普通对象 嵌套对象 补充支持 …
阅读更多...
设计一个亿级高并发系统架构 - 12306火车票核心场景DDD领域建模

设计一个亿级高并发系统架构 - 12306火车票核心场景DDD领域建模

“ 架设一个亿级高并发系统&#xff0c;是多数程序员、架构师的工作目标。 许多的技术从业人员甚至有时会降薪去寻找这样的机会。但并不是所有人都有机会主导&#xff0c;甚至参与这样一个系统。今天我们用12306火车票购票这样一个业务场景来做DDD领域建模。” 开篇 要实现软件…
阅读更多...
数据库系统概论第七章（数据库设计）知识点总结（1）—— 概述

数据库系统概论第七章（数据库设计）知识点总结（1）—— 概述

本专栏收录了数据库的知识点&#xff0c;而从本文起&#xff0c;将讲述有关于数据库设计有关知识点&#xff0c;提供给有需要的小伙伴进行学习&#xff0c;本专栏地址可以戳下面链接查看 &#x1f388; 数据库知识点总结&#xff08;持续更新中&#xff09;&#xff1a;【数据库…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023