面试准备算法

用最少数量的箭引爆气球

class Solution {
public:
    class MyCompare{
    public:
        bool operator()(vector<int>& a, vector<int>& b){
            return a[0] < b[0];
        }
    };
    int findMinArrowShots(vector<vector<int>>& points) {
        int count = 1;
        MyCompare cmp;
        sort(points.begin(), points.end(), cmp);
        for(int i=1; i<points.size(); i++){
            if(points[i][0] > points[i-1][1]){ //当前左边界大于前一个右边界
                count++;
            }else{
                points[i][1] = min(points[i][1], points[i-1][1]); //更新右边界
            }
        }
        return count;
    }
};

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

给一个二叉树：

填充它的每个next指针，让指针指向其下一个右侧节点。

/*
// 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) {
        if(root == nullptr){
            return nullptr;
        }

        queue<Node*> que;
        que.push(root);
        while(!que.empty()){
            int n = que.size();
            Node* prev = nullptr;
            for(int i=1; i<=n; i++){
                Node* curr = que.front();
                que.pop();
                if(curr->left){
                    que.push(curr->left);
                }
                if(curr->right){
                    que.push(curr->right);
                }
                if(i != 1){
                    prev->next = curr;
                }
                prev = curr;
            }
        }
        return root;
    }
};

二叉搜索树迭代器

实现一个二叉搜索树迭代器BSTIterator，表示一个按中序遍历的迭代器。

/**
 * 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 BSTIterator {
private:
    void inorder(TreeNode* root, vector<int>& res){
        if(!root){
            return;
        }
        inorder(root->left, res);
        res.push_back(root->val);
        inorder(root->right, res);
    }

    vector<int> inorderTraversal(TreeNode* root){
        vector<int> res;
        inorder(root, res);
        return res;
    }

    vector<int> arr;
    int idx;
public:
    BSTIterator(TreeNode* root) {
        this->idx = 0;
        arr = inorderTraversal(root);
    }
    
    int next() {
        return arr[idx++];
    }
    
    bool hasNext() {    
        return idx < arr.size();
    }
};

/**
 * Your BSTIterator object will be instantiated and called as such:
 * BSTIterator* obj = new BSTIterator(root);
 * int param_1 = obj->next();
 * bool param_2 = obj->hasNext();
 */

克隆图

给一个无向连通图中一个节点的引用，请返回该图的深拷贝。
深度优先搜索

图的深拷贝是构建一张与原图结构，值均一样的图，但是其中的节点不再是原来图节点的引用。
因此，为了深拷贝出整张图，我们需要知道整张图的结构以及对应节点的值。

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> neighbors;
    Node() {
        val = 0;
        neighbors = vector<Node*>();
    }
    Node(int _val) {
        val = _val;
        neighbors = vector<Node*>();
    }
    Node(int _val, vector<Node*> _neighbors) {
        val = _val;
        neighbors = _neighbors;
    }
};
*/

class Solution {
public:
    unordered_map<Node*, Node*> visited;
    Node* cloneGraph(Node* node) {
        if(node == nullptr){
            return node;
        }

        //如果该节点已经被访问过，直接从哈希表中取出对应的克隆节点返回
        if(visited.find(node) != visited.end()){
            return visited[node];
        }

        //克隆节点
        Node* cloneNode = new Node(node->val);
        visited[node] = cloneNode;

        for(auto& neighbor : node->neighbors){
            cloneNode->neighbors.emplace_back(cloneGraph(neighbor));
        }

        return cloneNode;
    }
};

除法求值

广度优先搜索
将整个问题建模成一张图：给定图中的一些点（变量），以及某些边的权值（两个变量的比值），试求出任意两点（两个变量）求出其路径长（两个变量的比值）。

因此，我们首先要遍历equations数组，找出其中所有不同的字符串，并通过哈希表将每个不同的字符串映射成整数。

在构建完图之后，对于任何一个查询，就可以从起点出发，通过广度优先搜索的方式，不断更新起点与当前点之间的路径，直到搜索到终点为止。

寻找重复值

快慢指针
对nums数组建图，每个位置i连一条i->nums[i]的边，由于存在重复的数字target，因此，target这个位置至少有两条指向它的边，因此一定存在环。

那么问题等价于找环的入口。

我们将设置慢指针slow和快指针fast，慢指针每次走一步，快指针走两步，在有环的情况下一定相遇，此时再将慢指针放到slow，两个指针同时移动一步，相遇的点就是答案。

课程表二

现在共有numCourses门课程需要选，记为0到numCourses-1。

给定一个数组，它的每一个元素表示先后之间要修的课程顺序，[ai,bi]表示要学习ai，先要学习bi。

给出先修顺序。

class Solution {
public:
    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
        //求拓扑顺序，每次找到入度为0的点，就是第一步要走的，随后减掉入度为0的相邻点的入度。
        vector<int> inDegree(numCourses, 0); //求每个点的入度
        vector<vector<int>> nextNode(numCourses); //求每个点相邻的点
        vector<int> res;

        for(auto &p : prerequisites){
            inDegree[p[0]]++;
            nextNode[p[1]].push_back(p[0]);
        }

        queue<int> que;
        for(int i=0; i<numCourses; i++){
            if(inDegree[i] == 0){
                que.push(i);
            }
        }

        while(!que.empty()){
            int course = que.front();
            que.pop();
            res.push_back(course);

            for(auto &p : nextNode[course]){
                inDegree[p]--;

                if(inDegree[p] == 0){
                    que.push(p);
                }
            }
        }


        if(res.size() != numCourses){
            return {};
        }
        return res;
    }
};

单词搜索

给定一个mxn二维字符网格board和一个字符串单词word，如果word存在于网格中返回true，否则返回false。

在一个信噪比为63:1，带宽为8KHz的信道上传输某个二进制信号，其最大数据速率可以达到？

• 根据香农定理，最大速率=Wlog2(1+S/N) = 48kHz
• 根据奈奎斯定义2W*log 2V = 16000b/s

线程的实现可分为三类，用户级线程，内核级线程以及混合线程。

TCP首部的固定长度为20Byte。

ORDER BY排序，默认是升序。

ORDER BY排序可以对多列或单列进行排序。

多列排序是前一列存在相同值才会根据后一列进行排序。

SELECT prod_price FROM Products ORDER BY prod_price DESC;表示查询结果根据prod_price倒序排。

临界资源是互斥共享资源，非共享数据不属于临界资源。
磁带机、打印机一次只能允许一个进程使用，CPU也是临界资源。

HTTP常用的首部字段Connection表示客户端要求服务器使用持久连接，以便其它请求复用。

HOST：客户端发送请求时，用来指定服务器的域名。
Content-Length：服务器返回数据时，表明本次回应的数据长度。
Connection字段最常用于客户端要求服务器使用持久连接，以便其它请求复用。
Content-Type字段用于服务器回应时，告诉客户端，本次数据是什么格式。
Content-Encoding字段说明数据的压缩方式。表示服务器返回的数据用了什么压缩格式。
Refer告知服务器请求的原始资源的URI。

统计每日新增用户数：
第一步查出用户第一次登录的日期，同时去重user_id，第二步group by date即可。

创建软链接：
ln -s file1 link1

SELinux是一种安全增强型Linux，默认的工作模式是强制模式，系统严格按照SELinux策略进行访问控制，任何违反策略的访问都会被拒绝。这种模式提供了最高的安全性。

查看防火墙状态的命令是：

• iptables -L
• systemctl status firewalld

TCP协议使用的传输协议是IP。