面试复盘 on Wxn的博客

给个offer

Wed, 24 Apr 2024 00:00:00 +0000

This article offers a sample of basic Markdown.

正文开始

如果考到数论的题,会做你就做,不会做你就说你对数论这块不太熟悉,数论这个面算法工程师考的比较多,做开发的话链表比较多

1.41. 包含min函数的栈

//https://leetcode.cn/problems/bao-han-minhan-shu-de-zhan-lcof/description/
class MinStack {
public:
    /** initialize your data structure here. */
    //1.单调栈
    //2.主栈与辅助栈
    //3.1)push都要插入（如果辅助栈为空，或者辅助栈顶>=x，则辅助栈插入）
    //2)pop() 如果辅助栈顶 == 主栈顶，则辅助栈顶弹出，否者就只有主栈弹出
    //3)4)直接返回相应的栈
    MinStack() {
        
    }
    
    void push(int x) {
        
    }
    
    void pop() {
        
    }
    
    int top() {
        
    }
    
    int getMin() {
        
    }
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(x);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.getMin();
 */

2.35. 反转链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
 //https://leetcode.cn/problems/reverse-linked-list/
//难点：单链表要建立一个前驱节点
//关键点：画图
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        
    }
};

3.19. 二叉树的下一个节点

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode *father;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL), father(NULL) {}
 * };
 */
 //这个是vip题目
//285. 二叉搜索树中的中序后继
//分类讨论:有右子树和没有右子树
//中序遍历
//情况1:这个点有右子树,那后继就是"右子树"最左边的那个
//情况2:这个点的右子树为空(且有父节点),当p有父节点且p等于p父节点的右儿子,那么p就赋值为p的父节点,最后返回p的父节点
class Solution {
public:
    TreeNode* inorderSuccessor(TreeNode* p) {
        
    }
};

4.34. 链表中环的入口结点

142. 环形链表 II

LCR 022. 环形链表 II

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *entryNodeOfLoop(ListNode *head) {
        
    }
};

画图:数学证明:(b+c)表示n圈

备份
class Solution {
public:
    ListNode *entryNodeOfLoop(ListNode *head) {
        auto first = head,slow = head;
        while(first && first->next && first->next->next)
        {
            first = first->next->next;
            slow = slow->next;
            if(first == slow)
            {
                first = head;
                while(first != slow)
                {
                    first = first->next;
                    slow = slow->next;
                }
                return first;
            }
        }
        return nullptr;
    }
};

5.77.翻转单词顺序

151. 反转字符串中的单词

1
2
3

//先翻转整个句子
//再翻转单独的一个单词
//难点:在找到一段时,不要忘记边界

void Reverse(int l ,int r,string& s)
{
    for(int i = l , j = r ;i < j ;i++,j--)swap(s[i],s[j]);
}
Reverse(0,s.size()-1,s);
等价于
reverse(s.begin()+0,s.begin()+s.size());//范围:[)

反转不是空格的那一段

6.18.重建二叉树

https://leetcode.cn/problems/zhong-jian-er-cha-shu-lcof/description/

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
  //前:根左右
 //中:左根右
 //1.使用哈希表,快速的找到"一个元素在中序遍历的位置"
 //2.递归dfs(主函数直接返回)
 //1)递归参数:左右子树节点个数
 //2)递归内部:
 /*
 - 前序遍历:左>右 -> null
 - 根节点的值为前序遍历的第1个点 preorder[a]
 - 找到根节点在哈希表中的位置
 - 左右子树递归创建 范围画图
 */
class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        
    }
};

7.21. 斐波那契数列

//f[i] = f[i-1]+f[i-2]
class Solution {
public:
    int Fibonacci(int n) {
        
    }
};

8.78. 左旋转字符串

//先把整个进行翻转
//再把前(总-个数),后两部分进行翻转
class Solution {
public:
    string leftRotateString(string str, int n) {
        
    }
};

9.87. 把字符串转换成整数

//分步
//过滤掉行首空格
//long long
//判断这个数是不是负数
//如果在累加的过程中(还没加完),就已经越界了,那就直接跳出来
class Solution {
public:
    int strToInt(string str) {
        
    }
};

10.28. 在O(1)时间删除链表结点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
  //1.用下一个节点覆盖掉当前节点
 //2.删除掉当前节点
class Solution {
public:
    void deleteNode(ListNode* node) {
        
    }
};

11.66. 两个链表的第一个公共结点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
  //双指针,
 //指针1走完a再走b,指针2走完b再走a,返回最后相遇的位置,如果最后都指向空也算相遇了
 //这个也是有难点的: 注意:对于指针1与指针2,要么是"回头",要么是"下一个"
class Solution {
public:
    ListNode *findFirstCommonNode(ListNode *headA, ListNode *headB) {
        
    }
};

12.84. 求1+2+…+n

//语法题:(false && 条件); = false 可以起到if的效果
class Solution {
public:
    int getSum(int n) {
        
    }
};

13.36. 合并两个排序的链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
  //归并排序(一个函数足够)
  //虚拟节点(比如说初始化为-1)+当前节点
 //1)两个指针
 //2)比较两个指针的值哪个小,哪个小就给哪个(如果l1)
 //3)链到虚拟链表,当前节点后移,l1也后移
 //4)处理残局:l1与l2哪个不同,就一直链到空为止
class Solution {
public:
    ListNode* merge(ListNode* l1, ListNode* l2) {
        
    }
};

14.14. 不修改数组找出重复的数字

//简单方法:哈希表
//方二:抽屉原理
//二分法:
//一个萝卜一个坑,假如说数的个数>坑的个数,那么这个区间一定存在重复的数
//注意:给定一个长度为 n+1的数组nums，数组中所有的数均在 1∼n的范围内，其中 n≥1,表示下标有效的范围是[1,nums.size()-1]
class Solution {
public:
    int duplicateInArray(vector<int>& nums) {
        // l 和 r 分别代表的是 数字 1  和 数字n 这里并不是下标.
        int l = 1, r = nums.size() - 1;
        while (l < r){
            // 二分 找到中间的那个数
            int mid = l + r >> 1;
            int s = 0;
            // 下面这句话的意思 从 nums里面 循环去先去 判断 这个数 x 的值看他是否在 [l, mid]中间, 在的话 判断条件执行完为true
            //  true 的话代表 数字 1 flase 代表 数字 0. 然后再进行累加 s += x 统计符合条件的个数.
            // 最终的效果就是 统计了 整个数组中 数的值 在 [l,mid] 之间的个数.
            for (auto x : nums) s += x >= l && x <= mid; // left : [l, mid] , right : [mid + 1, r]
            // 理解: 一个坑存一个数, 正常情况下 一定是坑的个数 和 数的个数相等. 如果一坑里面有两个数. 那么就会出现
            // 数的个数 大于 坑的个数 说明 这个区间段一定存在重复的个数.
            if (s > mid - l + 1) r = mid;
            else l = mid + 1;
        }

        return r;//l和r都可以
    }
};

15.68. 0到n-1中缺失的数字

//二分
//通过下标直接查找,
//因为是连续的,如果不少的话,则有nums[mid] == mid,如果是左边少了,就是不等
//最后还要判断nums[r] == r,要是等于的话,那就是少最后一个
class Solution {
public:
    int getMissingNumber(vector<int>& nums) {
        
    }
};


eg:
//[0,1,2,4] n=4
//[0,1,2,3] n=4   
class Solution {
public:
    int getMissingNumber(vector<int>& nums) {
        if(nums.empty())return 0;
        int n = nums.size();
        if(nums.back() == n-1)return n;//缺少最后面一个数
        
        int l = 0 ,r = n-1;
        while(l < r)
        {
            int mid = l + r >> 1;
            if(nums[mid] == mid)l = mid +1;//这部分不缺
            else r = mid;
        }
        return r;
    }
};

补充：13. 找出数组中重复的数字

//哈希表秒了
//方二：不要了
class Solution {
public:
    int duplicateInArray(vector<int>& nums) {
        
    }
};

16.75. 和为S的两个数字

//时间复杂度最重要
//用法哈希表,count看是否存在
class Solution {
public:
    vector<int> findNumbersWithSum(vector<int>& nums, int target) {
        
    }
};

17.23. 矩阵中的路径

//dfs
//枚举起点，枚举方向
//起点怎么枚举:两个for循环
//方向怎么枚举?上右下左:画图

//dfs中:
//1)刚好遍历到的字符个数u == 字符串的长度,就OK
//2)如果u下标字符 != 遍历到的字符,就不ok
//3)遍历四个方向,为了避免回头遍历,比如你刚遍历完一个字符'a',下一个字符还是'a',就会回头遍历,
//我们要避免这个,就需要先修改为一个其他的,等遍历完再返还
class Solution {
public:
    bool dfs(vector<vector<char>>& matrix, string &str,int u ,int x,int y)
    {
        if(str[u] != matrix[x][y])return false;//当前字符与之不符
        if(u == str.size()-1)return true;//刚好是最后一个,而且能来到这,说明相符
        int dx[4]={-1,0,1,0},dy[4]={0,1,0,-1};
        char t = matrix[x][y];
        matrix[x][y] = '*';
        for(int i = 0 ; i < 4 ;i++)
        {
            int a= x+dx[i],b = y +dy[i];
            if(a>=0 && a<matrix.size() &&b>=0 && b<matrix[a].size())
                if(dfs(matrix,str,u+1,a,b))return true;
        }
        matrix[x][y] = t;
        return false;
    }
    bool hasPath(vector<vector<char>>& matrix, string &str) {
        for(int i = 0 ;  i < matrix.size() ; i++)
        {
            for(int j = 0 ; j < matrix[i].size() ; j++)
            {
                if(dfs(matrix,str,0,i,j))
                {
                    return true;
                }
            }
        }
        return false;
    }
};

18.55. 连续子数组的最大和

1
2

s表示收益
res表示最终结果

19.42. 栈的压入、弹出序列

关键:不是所有的数都入栈,他才开始进行弹出操作.
    完全可以实现这么一种情况:你还进去,人家就已经出来了

//1.长度不同,肯定不行
//2.用一个栈来模拟整个过程
//3.一直将pushV的元素入栈,直到栈顶元素 == 要弹出的第i元素(i从0开始)
//(while循环 --->尽可能的把能弹出的元素弹出来[前提:栈中有元素且栈顶元素刚好是我们要弹出的元素])
//4.最后如果栈为空,即为ok
class Solution {
public:
    bool isPopOrder(vector<int> pushV,vector<int> popV) {
        
    }
};

20.70. 二叉搜索树的第k个结点

230. 二叉搜索树中第K小的元素

//例子中:第1小的数是1;第二小数是2;第三小的数是3;
//所有:就是求中序遍历的第k个
//中序遍历:我们都知道是左根右,左和右就是一个dfs,那么中是难点
//中序遍历的中:k--,如果k==0,就是我们的答案
//最后dfs加一个阀门:如果节点指针为空,则直接return
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* kthNode(TreeNode* root, int k) {
        
    }
};

21.48. 复杂链表的复刻

//1.给旧链表每2个节点之间加1个节点(新节点的值是前节点的值)
//2.重新遍历链表中的每个节点 (p->next)->random=(p->random)->next;
//3.将新链表拎出来:
//1)搞个虚拟头结点,最后返回dummy->next
//2)一有虚拟节点,那必须有一个cur节点
//3)画图:
//              1.cur->next = p->next;
//              2.cur = cur->next;
//              3.难点:需要把新旧链表彻底分开p->next = p->next->next;
//              p = p->next;
/**
 * Definition for singly-linked list with a random pointer.
 * struct ListNode {
 *     int val;
 *     ListNode *next, *random;
 *     ListNode(int x) : val(x), next(NULL), random(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *copyRandomList(ListNode *head) {
        
    }
};

22.53. 最小的k个数

//使用大根堆priority_queue
//只放k个,多了就踢了
//最后记翻转
class Solution {
public:
    vector<int> getLeastNumbers_Solution(vector<int> input, int k) {
        priority_queue<int>heap;
        for(auto x : input)
        {
            heap.push(x);
            if(heap.size() > k)heap.pop();//把堆顶删了
        }
        vector<int>res;
        while(heap.size())
        {
            res.push_back(heap.top());
            heap.pop();
        }
        reverse(res.begin(),res.end());
        return res;
    }
};

23.33. 链表中倒数第k个节点

//先求链表长度n
//链表中倒数第k个节点 == 链表从前往后挪n-k次
//简单画个图
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* findKthToTail(ListNode* pListHead, int k) {
        
    }
};

24.71. 二叉树的深度

//max(左子树,右子树)+1
//dfs
//一共两行代码
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int treeDepth(TreeNode* root) {
        if(!root)return 0;
        return max(treeDepth(root->left),treeDepth(root->right))+1;
    }
};

25.72. 平衡二叉树

//这个题和求树的最大深度一样
/*
if(!root)return 0;
*/
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isBalanced(TreeNode* root) {
        
    }
};

 //错误的做法:只能保证根节点的左右子树,相差不超过1,不能拿保证"任意结点的左右子树的深度相差不超过 1"
//  //树的深度
// class Solution {
// public:
//     int dfs(TreeNode* root)
//     {
//         if(!root)return 0;
//         return max(dfs(root->left),dfs(root->right))+1;
//     }
//     bool isBalanced(TreeNode* root) {
//         if(!root)return true;
//         int l = dfs(root->left);
//         int r = dfs(root->right);
//         //cout<< l<<' '<<r<<' ';
//         if(abs(l-r)>1)return false;
//         return true;
//     }
// };



//正确的:他计算了任意一个节点的左右子树的高度不超过1
class Solution {
public:
    bool res = true;
    int dfs(TreeNode* root)
    {
        if(!root)return 0;
        int left = dfs(root->left) ,right = dfs(root->right);
        if(abs(left-right)>1)res = false; 
        return max(left,right)+1;
    }
    bool isBalanced(TreeNode* root) {
        dfs(root);
        return res;
    }
};

26.15. 二维数组中的查找

//每列是递增的
//难点:右上角
//(i,j)=>(0,array[0].size()-1)
//在范围内:(i<array.size() && j>=0)
//x = array[i][j],直接返回true
//x > target j--;
//else i++;
class Solution {
public:
    bool searchArray(vector<vector<int>> array, int target) {
        
    }
};

27.59. 把数字翻译成字符串

//dp的问题:直接记下来就行了
class Solution {
public:
    int getTranslationCount(string s) {
        int n = s.size();
        vector<int> f(n + 1);//因为dp从1开始
        f[0] = 1;
        for (int i = 1; i <= n; i ++ ) {
            f[i] = f[i - 1];//f[i]包含了f[i - 1]的所有情况
            if (i > 1) {
                int t = s[i - 1] - '0' + (s[i - 2] - '0') * 10;//状态转移的条件:只有[10,25]才可以状态转移
                if (t >= 10 && t <= 25) f[i] += f[i - 2];//条件all满足:f[i] = f[i - 1]+f[i - 2];
            }
        }
        return f[n];
    }
};

29.37. 树的子结构

以根为开始,开始进行p1与p2的匹配:
需要另写一个函数进行匹配,函数的参数是以p1,p2为根节点的一段小树
函数内部实现:
1.p2为空.说明之前的匹配好了,直接return true;
2.p1为空 或者 p1和p2的值不匹配,直接return false;
3.没有被条件1和2直接return,说明当前的节点是匹配的,我们接着
匹配左左和右右,是且的关系
class Solution {
public:
    bool dfs(TreeNode* p1, TreeNode* p2)
    {
        if(!p2)return true;
        if(!p1 || p1->val != p2->val)return false;
        //此时,当前节点是匹配的
        return dfs(p1->left,p2->left) && dfs(p1->right,p2->right);//左边匹配且右边匹配
    }
    bool hasSubtree(TreeNode* pRoot1, TreeNode* pRoot2) {
        if(!pRoot1 || !pRoot2)return false;
        if(dfs(pRoot1,pRoot2))return true;//遍历当前节点
        return hasSubtree(pRoot1->left,pRoot2) || hasSubtree(pRoot1->right,pRoot2);//下一个节点
    }
};

30.46. 二叉搜索树的后序遍历序列

//和那个重建二叉树思路有一点点类似
//画图确定范围
class Solution {
public:
//1.搞一个全局变量
    vector<int> seq;

    bool verifySequenceOfBST(vector<int> sequence) {
        seq = sequence;
        return dfs(0, seq.size() - 1);//dfs的是范围
    }
    
    //dfs的是范围
    bool dfs(int l, int r) {
        if (l >= r) return true; // 1.如果子序列为空或只有一个节点，它必然是BST的后序遍历结果
        int root = seq[r]; // 2.根节点 子序列的最后一个节点是当前子树的根节点
        int k = l;//左右子树的分界线(找到右子树的第一个元素)
        while (k < r && seq[k] < root) k++; // 找到左子树和右子树的分界点
        for (int i = k; i < r; i++)//遍历右子树,如果右子树中,有元素小于根节点就不满足二叉搜索树
            if (seq[i] < root)
                return false; // 如果在右子树中找到比根节点小的值，则不是合法的BST后序遍历
        return dfs(l, k - 1) && dfs(k, r - 1); // 递归检查左子树和右子树
    }
};

31.26. 二进制中1的个数

//记住就好, x与-x的与
int lowbit(int x){
    return x&(-x);
}//可以得到最后一个1

32. 49. 二叉搜索树与双向链表

//最后要改成中序遍历的结果

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode *pre = nullptr , * head = nullptr;
    TreeNode* convert(TreeNode* root) {
        if(!root)return nullptr;
        dfs(root);
        //力扣专著
        // leetcode 是 循环链表,  要加上 这里
        // 循环链表 首尾相连, pre 最后在 链表尾结点
        //head->left = pre, pre->right = head;
        return head;
    }
    void dfs(TreeNode * cur)
    {
        if(!cur)return ;
        dfs(cur->left);
        if(!pre)head = cur;//这个头结点是我们要的答案
        else
        {
            //画图
            pre->right = cur;
            cur->left = pre;
        }
        //更新前驱节点
        pre = cur;
        dfs(cur->right);
    }
};

34.32. 调整数组顺序使奇数位于偶数前面

维护两个指针,一个从头一个从尾
使得:前指针前面都是奇数,后指针都是偶数

前指针遇到偶数就停下来,遇到奇数就前进
后指针遇到奇数就停下来,遇到偶数就前进

如何前指针的下标和后指针的下标不同,就交换两个数
while(i < j)
{
    while()
    while()
}
class Solution {
public:
    void reOrderArray(vector<int> &array) {
         int i = 0 ,j =array.size()-1;
         while(i < j)
         {
             while(i<j && array[i] % 2 == 1)i++;
             while(i<j && array[j] % 2 == 0)j--;
             if(i<j)swap(array[i],array[j]);
         }
    }
};

35.60. 礼物的最大价值

`1`	`非常经典的dp问题,太难了,直接pass`

36.63. 字符串中第一个只出现一次的字符

class Solution {
public:
    char firstNotRepeatingChar(string s) {
        unordered_map<char , int>hash;
        for(auto ch : s)hash[ch]++;
        
        
        //要求返回第一个只出现一次的字符,我们只能再变量一次字符串,而不是哈希表
        for(auto ch : s)
        {
            if(hash[ch] == 1)return ch;
        }
        return '#';
    }
};

37.85. 不用加减乘除做加法

class Solution {
public:
    int add(int num1, int num2){
        while(num2)
        {
            int sum = num1 ^ num2;//不进位
            int carray = (num1 & num2)<<1;//进位
            num1  =  sum , num2 = carray;//把进位拿去加,直到加为0
        }
        return num1;//num1是答案
    }
};

38.47. 二叉树中和为某一值的路径

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
//dfs中的条件是难点:没有左右子树,且遍历到这里刚好sum减到了0,才可以把这条路径放进去
class Solution {
public:
    //res是最中的答案,path是其中的一条路
    vector<vector<int>>res;
    vector<int> path;
    vector<vector<int>> findPath(TreeNode* root, int sum) {
        if(!root)return {};//标准
        dfs(root,sum);
        return res;
    }
    void dfs(TreeNode * node , int sum)
    {
        if(!node)return;//标准
        path.push_back(node->val);
        if(!node->left && !node->right && sum - node->val == 0)res.push_back(path);//这个是难点
        dfs(node->left,sum-node->val);
        dfs(node->right,sum-node->val);
        path.pop_back();
    }
};

39.82. 圆圈中最后剩下的数字

编号: 旧 = (新+m)%n
f(n,m) = (f(n-1,m)+m)%n;
class Solution {
public:
    int lastRemaining(int n, int m){
        if(n == 1)return 0;
        return (lastRemaining(n-1,m)+m)%n;
    }
};

40.39. 对称的二叉树

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool res = true;
    bool isSymmetric(TreeNode* root) {
        if(!root)return true;
        
        return dfs(root->left,root->right);//难点是看出来要把左右节点作为参数传给dfs
    }
    bool dfs(TreeNode * p, TreeNode* q)
    {
        if(!p || !q)return !p && !q;//这句话也是难点
        //上一步p为空或者q为空,都直接返回了,到了这里,p和q肯定都不为空
        if(p->val != q->val)return false;
        return dfs(p->left,q->right) && dfs(p->right,q->left);
    }
};

42.38. 二叉树的镜像

class Solution {
public:

    void mirror(TreeNode* root) {
        if(!root)return ;
        swap(root->left,root->right);//swap能直接换节点!,这个有点吊
        mirror(root->left);
        mirror(root->right);
        
    }
};

44.43. 不分行从上往下打印二叉树

//层序遍历
class Solution {
public:
    vector<int> printFromTopToBottom(TreeNode* root) {
        if(!root)return {};
        queue<TreeNode*> q;
        vector<int> res;
        q.push(root);
        while(!q.empty())
        {
            //res.push_back(q.);//这里我当时卡住了,不知道怎么把队列的值放进去
            auto t = q.front();//1.先拿队列头
            q.pop();//2.弹出队头
            res.push_back(t->val);
            
            //注意:这里不用for循环,直接就把t的左右子树加进去就行了
                if(t->left)q.push(t->left);
                if(t->right)q.push(t->right);
        }
        return res;
    }
};

45.44. 分行从上往下打印二叉树

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
 //相比较43题,你需要在while循环中嵌套一个while循环
class Solution {
public:
    vector<vector<int>>res;
    
    vector<vector<int>> printFromTopToBottom(TreeNode* root) {
        if(!root)return {};
        queue<TreeNode*>q;
        q.push(root);
        while(!q.empty())
        {
            //分层
            int len = q.size();
            vector<int> path;//每一层
            while(len--)
            {
                auto t = q.front();
                q.pop();
                path.push_back(t->val);
                if(t->left)q.push(t->left);
                if(t->right)q.push(t->right);
            }
            res.push_back(path);
        }
        return res;
    }
};

补充45. 之字形打印二叉树

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
 //相比较43题,你需要在while循环中嵌套一个while循环
class Solution {
public:
    vector<vector<int>>res;
    
    vector<vector<int>> printFromTopToBottom(TreeNode* root) {
        if(!root)return {};
        queue<TreeNode*>q;
        q.push(root);
        
        bool flag = false;//表示不用翻转
        while(!q.empty())
        {
            //分层
            int len = q.size();
            vector<int> path;//每一层
            
            while(len--)
            {
                auto t = q.front();
                q.pop();
                path.push_back(t->val);
                if(t->left)q.push(t->left);
                if(t->right)q.push(t->right);
            }
            
            if(flag) reverse(path.begin(),path.end());
            flag = !flag;
            
            res.push_back(path);
        }
        return res;
    }
};

48.25. 剪绳子

//直接上结论:
//0.如果小于3,就直接返回1*(n-1)
//1.如果这个数%3余1,就先拆分出一个4
//2.如果这个数%3余2,就先拆分出一个2
//3.将这个数拆分成尽可能多的3,最后还剩下多少就再乘多少
class Solution {
public:
    int maxProductAfterCutting(int length) {
        if(length<=3)return 1*(length-1);//n>=2,m>=2表示绳长大于等于2,且分的段数大于等于2
        int n = length;
        int sum =  1;
        if(n%3 == 1) sum *= 4,n -= 4;
        if(n%3 == 2) sum *= 2,n-= 2;
        while(n) sum*=3 , n -= 3;
        return sum;
    }
};

49.88. 树中两个结点的最低公共祖先

//代码很简单,只有一函数即可
//以下情况是一句代码:
//1.如果p和q都属于这颗树,就返回这颗树
//2.如果q属于这颗树,p不属于,就返回q
//3.如果p属于这颗树,q不属于,就返回p
//不管怎么说,都是一句话,if(q==root || q==root)return root;

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(!root)return nullptr;
        if(p==root || q == root)return root;
        
        TreeNode* left = lowestCommonAncestor(root->left,p,q);
        TreeNode* right = lowestCommonAncestor(root->right,p,q);
        if(left && right)return root;//一个在左,一个在右,就返回根节点
        if(left)return left;//只有左面,就返回左面
        else return right;//只有右面,就返回右面
    }
};

50.17. 从尾到头打印链表

//小小翻转列表,直接拿些
class Solution {
public:
    vector<int> printListReversingly(ListNode* head) {
        if(!head)return {};
        if(!head->next)return{head->val};
        ListNode* pre = nullptr;
        ListNode* cur = head;
        while(cur)
        {
            auto next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }
        vector<int> res;
        //头节点是pre
        while(pre)
        {
            res.push_back(pre->val);
            pre = pre->next;
        }
        return res;
    }
};

51.61. 最长不含重复字符的子字符串

//双指针
//哈希表
//维护一个i，j区间：
//当我们把一个新的字符加到哈希表中，大于了1时，
//我们就要删掉i，j区间内所有出现1的字符，直到遍历到那个大于1的字符为止，
//此时，我们再计算当前的答案
class Solution {
public:
    int longestSubstringWithoutDuplication(string s) {
        if(s.empty())return 0;
        int res = 0;
        unordered_map<char ,int> hash;
        for(int i = 0 , j = 0 ; j < s.size() ; j ++)// i,j 区间
        {
            if((++hash[s[j]]) > 1)//开始维护
            {
                while(hash[s[i]] == 1)
                {
                    hash[s[i]]--;
                    i++;//过
                }
                //此时，我们就遍历到那个重复字符
                hash[s[i]]--,i++;
            }
             res = max(res , j-i+1);
        }
        return res;
    }
};

53.20. 用两个栈实现队列

//思路要搞定:
//其中一个栈,有元素进就先进,
//当要弹出元素时,先从一个栈中将元素放到另一个栈中,再弹出
//考查队头,原理同上
//判空:两个队列同时为空才是空
class MyQueue {
public:
    stack<int> stk1 ,stk2;
    /** Initialize your data structure here. */
    MyQueue() {
        
    }
    
    /** Push element x to the back of queue. */
    void push(int x) {
        stk1.push(x);
    }
    
    /** Removes the element from in front of queue and returns that element. */
    int pop() {
        if(!stk2.empty()){
            int t = stk2.top();
            stk2.pop();
            return t;
        }
        else
        {
            while(!stk1.empty()){
                stk2.push(stk1.top());
                stk1.pop();
            }
            int t = stk2.top();
            stk2.pop();
            return t;
        }
    }
    
    /** Get the front element. */
    int peek() {
        if(!stk2.empty())return stk2.top();
        else
        {
            while(!stk1.empty()){
                stk2.push(stk1.top());
                stk1.pop();
            }
            return stk2.top();
        }
    }
    
    /** Returns whether the queue is empty. */
    bool empty() {
        if(stk1.empty() && stk2.empty())return true;
        else return false; 
    }
};

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue obj = MyQueue();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.peek();
 * bool param_4 = obj.empty();
 */

54.83. 股票的最大利润

//贪心
//先买再卖
//如何枚举
//枚举在某天卖

//开一变量,计算前i天的最小值minV
//如果前天的股票价格>minV,比较一下max(res,当天股票价格-minV)
class Solution {
public:
    int maxDiff(vector<int>& nums) {
        if(nums.empty())return 0;
        int minV = nums[0];
        int res = 0;
        for(int i = 1 ; i < nums.size() ;i++)
        {

            minV = min(minV,nums[i]);//得到前几天股票的最低价
            res = max(res , nums[i]-minV);//res与（当前股票价格-前几天股票的最低价）进行比较
        }
        return res;
    }
};

40. 顺时针打印矩阵

//蛇形数组
//走到不能走为止:
//1.越界了不能走
//2.已经走过了不能走(加一个数组标记是否走过)

//每都先计算一下:下一步能不能走,不能走,就换下一个方向
class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix) {
        if(matrix.empty())return {};
        int n = matrix.size() , m = matrix[0].size();
        
        vector<int> res;
        vector<vector<bool>>st(n,vector<bool>(m,false));
        
        int dx[4] = {0,1,0,-1} , dy[4] = {1,0,-1,0};//四个方向的向量:右下左上
        int x = 0,y = 0 ,step = 0;//起始点,方向
        for(int i= 0 ; i < n*m ;i++)
        {
            res.push_back(matrix[x][y]);
            st[x][y] =  true;
            int a = x + dx[step] , b = y +dy[step];//先计算一下,下一个位置能不能走,不能走就换下一个方向
            if(a < 0 || a > n-1 || b <0 || b > m-1 || st[a][b])
            {
                step = (step + 1)%4;
                a = x + dx[step] , b = y +dy[step];
            }
            x = a ,y =b;
        }
        
        return res;
    }
};

补充:判断一颗树是不是完全二叉树:

LeetCode 958. 二叉树的完全性检验

可以根据编号找规律:

如果是完全二叉树的话:

(节点的总个数) 一定是等于 (最大的节点编号 )

class Solution{
  public:
    int n = 0 , p = 0;
    bool dfs(TreeNode * root, int k)
    {
        if(!root)return true;
        if(k>100)return false;//溢出
        n++ , p = max(p,k);
        return dfs(root->left,2*k) && dfs(root->right,2*k+1);
    }
    bool isCompleteTree(TreeNode * root)
    {
        if(!dfs(root,1))return false;//1表示传进去的是根节点,return false表示节点个数溢出
        return n == p;
    }
};

2024-04-22简历怎么说

Mon, 22 Apr 2024 00:00:00 +0000

This article offers a sample of basic Markdown.

正文开始

自我介绍

面试官你好,我叫wxn,来自河北,是24应届毕业生,我的技术栈是c++,熟悉window和Linux的c++开发,熟悉qt界面开发,以及一些网络编程的开发,有比较丰富的项目经验,参加过蓝桥杯并获得省二等奖,所以我想找一份c++开发的工作,非常开心认识您,在这里也提前感谢接下来的面试,谢谢

项目介绍

毕业设计主要是模仿小米的小爱音箱做的。项目采用 C/S 架构，分成了三个部分，arm音箱部分、后台c++服务器以及qt客户端。音箱部分基于 mini2440 开发板，移植了 Linux 操作系统,应用层采用开源库 madplay 作为音频的编解码工具，采用父、子、孙三个进程来控制音乐的播放。通过按键实现切歌、调节音量、暂停等功能。后台阿里云服务器是一个公网服务器，使用C++语言，可以实现 APP 数据的转发,充当一个中转站的角色。

服务器选择使用开源高并发框架libevent 来实现。服务器还加入了链表的功能，记录 APP 和音箱的绑定关系。 APP客户端用 Qt 实现，主要负责往服务器发送控制指令，包括切歌、调节音量、播放模式、语音控制等等,然后服务器再转发给音箱

共享单车这个项目主要是仿照哈啰单车为灵感，项目采用cs架构，由我和学校老师一起完成，我主要负责的部分是Linux服务端的开发，服务器采用libevent+线程池的组合，用到了单例，订阅者发布者模式，并使用封装包头的方式来解决分包粘包的问题，使用protobuf来实现应用层协议，对数据进行序列化与反序列化，并使用cmake来对项目进行管理，客户端的部分由同学负责，使用qt for Android架构，我也有少量涉及…

上位机这个项目我主要实现对下位机相关数据的实时监控，使用的com2与com3进行连串口通信，对关键数据进行监测，如果超过门限值就做出警告，并写入文件作为异常的日志。其中调试用到了串口调试工具，并在真机上进行测试，然后数据传输协议是通过老师提供的协议文档，对数据进行封装，比如包头，命令，参数，奇偶校验位等…

QQ这个项目我主要负责是客户端的界面美化，采用无边框模式，对标题栏重写，以及对按键样式的设计等来达到与QQ相近的效果，同时使用MySQL来完成一些增删改查的业务，比如注册登录群组等

补充:文件操作

#include <iostream>
#include <fstream>

#include "string.h"

using namespace std;


int main()
{
    char filename[60]={0};
    strcpy(filename,"C:\\Users\\wxn\\Desktop\\1.txt");
    char ch;
    ifstream inFile;

    inFile.open(filename);
    if(!inFile.is_open())
    {
        cout<<"can not open file:["<<filename<<"]"<<endl;
        exit(1);
    }
    int count = 0;
    inFile >>ch;//读取一个字符
    while(inFile.good())//查看是否读取成功
    {
        count++;
        inFile>>ch;
    }

    cout<< count <<" characters in "<<filename<<endl;
    inFile.close();

    return 0;
}

2024-04-21毕业设计提问

Sun, 21 Apr 2024 00:00:00 +0000

This article offers a sample of basic Markdown.

正文开始

1.简要的描述一下你的项目？

智能音箱主要是模仿小米的小爱音箱做的。项目采用 C/S 架构，分成了三个部分，arm音箱部分、后台c++服务器以及qt客户端。音箱部分基于 mini2440 开发板，移植了 Linux 操作系统，包括 u-boot、操作系统内核以及根文件系统。应用层使用开源库 madplay 作为音频的编解码工具，采用父、子、孙三个进程来控制音乐的播放。通过按键实现切歌、调节音量、暂停等功能。后台阿里云服务器是一个公网服务器，使用C++语言，可以实现 APP 数据的转发,充当一个中转站的角色。

2、为什么会做这么一个项目？

这个项目是从小米的小爱音箱找到的灵感，我们的毕业设计要求使用开发板,当时有两种选择:一种是stm32开发板,一种是Linux开发板,我更喜欢Linux，然后就研究了一下这个项目的架构,就觉得mini2440开发板比较合适，而且我觉得用这个项目把我基本上所有学到得的东西都结合起来了,有c和c++编程,还有Linux操作系统以及qt开发等，所以就实现了arm音箱、c++服务器和qtAPP客户端。

3、服务器端为什么选择 C++，和使用 C 语言有什么区别？

这个就涉及到了 C 和 C++的区别。C 语言更多的用于底层或者操作系统的开发，服务器端开发更适合选择 C++。因为服务器端的代码逻辑一般比较复杂，代码量比较大，C++提供了很多开源的库，比如 STL。选择 C++开发服务器，就不用去关心链表的插入、删除等等操作，只需要调用一个成员函数就能解决。所以用 C++开发效率更高、运行也会更加稳定。而且C++因为有继承和多态的存在，代码的重用性更好，一份代码可以用在不同的项目中，后期维护更低。

4、mini2440 是一块什么样的开发板，用的是什么芯片？

mini2440 还是一块比较老的开发板，用的三星的 S3C 2440 单核处理器，ARM9 内核，64M SDRAM 和 256M NandFlash，性能不算强大，比较适合用于学习。

补充：请简要介绍一下Linux开发板中的Bootloader是什么，以及它的作用和优势。

在Linux开发板中，Bootloader是一个特别设计的小型程序，它存储在开发板的非易失性存储器中，是系统上电或重启后首先被执行的代码。Bootloader的核心作用是为系统的启动准备环境，将操作系统内核加载到内存中并执行。

5、u-boot 源码看过吗？他的启动流程是什么样的？（完成了哪些功能）

u-boot源码没有看过 , 但是我自己动手编译过，直接用的 mini2440 开发板定制的配置文件。启动流程了解一些，分为两个阶段:

第一个阶段设置 CPU 工作模式为 SVC，关闭中断、看门狗、MMU、cache(高速缓冲存储器)、初始化内存、串口、设置栈，为运行 C 语言做准备，然后跳到 C 语言开始执行。
第二个阶段主要是初始化外设、进入循环处理用户的指令。

6、移植内核的时候你做了哪些事情？

移植内核的时候用了 mini2440 开发板定制的配置文件，所以配置内核没有花什么时间，就是添加了对 cram 文件系统格式的支持。然后开始arm-linux-32交叉编译，最后烧写到开发板的 NandFlash 中。（最好了解下 NorFlash 和 NandFlash 的区别）

开发板上有一个上下推拉按钮,一开始烧录uboot.bin文件时,先推到上面的norflash,等烧录完成后,我再关闭开发板的电源,将按钮推到nandflah,再开启电源,使用xshell通过串口进行连接就可以了,连接的端口不固定,有时是com5,有时是com6,连接之前最好在电脑上的设备管理器中段端口进行查看一下啊,连接成功后,就可以在xshell中操作开发板的Linux系统了.因为开发板的内存有限,所以我并没有选择在开发版的操作系统中进行Linux编程,我是先在vm上安装一个红帽系统,在上面进行编程,然后把交叉编译后的二进制文件通过tftp工具传输到开发板上.

7、项目中使用了哪些开源库？

用于音频解码的 madplay，网络数据传输使用的 json 格式，音箱上面移植了 json-c，服务器用的 jsoncpp 和 libevent，Qt上用了 QJson,以及网络和数据库等模块。

8、工程文件的编译方式你知道哪些？

编译 json 的时候遇到过两种方式，一个是用 configure，一个是用 cmake，

两种都是为了产生 Makefile 文件来完成工程的编译。configure 是一个sh脚本，

属于 autotools 工具集，autotools 有很多工具，autoscan、autoconf、autoheadler，通过这些工具可以自动生成 Makefile 文件。configure 文件就是这些工具的一个中间产物，运行 configure 脚本，可以自动检查和配置编译环境，生成 Makefile 文件。

但是 autotools 工具步骤太多，所以现在就有了 CMake，通过CMakeList.txt来指定编译规则，运行 cmake 命令也可以产生 Makefile。项目中因为使用了交叉编译，配置交叉编译用 configure 更方便，所以我选择了通过 configure 来产生 Makefile 文件。

9、移植开源库是什么样的步骤？

1.先是通过 configure 脚本配置编译环境，设置目标架构、交叉编译工具以及安装目录，这一步同时会生成 makefile 文件，

2.然后通过 make 命令对 makefile进行编译，

3.编译完成后执行 make install 把目标文件安装到指定的目录，我就是把目标文件安装到交叉工具链的目录里面。

10、播放音乐为什么选择多进程？使用多线程能完成吗？

播放音乐使用了三个进程，

1.父进程负责监听服务器和按键信息，收到开始播放消息的时候创建子进程，

2.子进程创建孙进程，孙进程负责音乐的播放，子进程通过 wait 函数阻塞，等待孙进程播放结束来回收孙进程的资源。

(如果只创建两个进程,那就没有经常可以回收播放音乐的进程,父进程忙着监听服务器和按键事件,肯定不能用wait阻塞)

{如果非要使用两个进程,可以让音乐进程结束时,让音乐进程向父进程发送一个信号,父进程可以再处理函数中执行资源回收的工作.}

多线程也可以完成，主要是考虑到进程比较健壮，如果主进程死了不会影响播放音乐的进程，这样用户体验会更好一些。

在多线程应用中,所有线程共享一个进程的资源和地址空间,如果主线程发送了崩溃或非正常终止,整个进程以及器内部的所有线程通常都会受到影响,从而导致整个应用程序终止.

11、父子孙三个进程需要通信吗？使用的是哪种通信方式？

需要通信，用了shm共享内存和信号。

父进程需要把播放模式传递给孙进程，

子进程和孙进需要把当前正在播放的音乐以及进程号传递给父进程。

数据的传递使用的是 shm共享内存。父进程控制子进程和孙进程的暂停继续 , 使用的是信号。

12、Linux 有哪些 IPC 方式？各自的优缺点是什么？

无名管道、有名管道、信号、消息队列、共享内存、信号量以及套接字。

无名管道只能用于父子进程，

有名管道可以用于任意两个进程，管道比较简单，但是只能传输没有格式的字节流。信号传递的数据量有限，一般只是用于进程的控制。

消息队列可以传输有格式的数据。

共享内存传输效率最高，因为可以直接读写内存。信号量主要用于进程的同步。

套接字属于网络传输，也算是一种进程间通信。

13、进程和线程的区别有哪些？各有什么优势？

进程和线程的根本区别是:

进程是操作系统资源分配的基本单位，

而线程是处理器任务调度和执行的基本单位。资源开销：每个进程都有独立的代码和数据空间（程序上下文），程序之间的切换会有较大的开销；线程共享代码和数据空间，线程之间切换的开销小。包含关系：一个进程可以包含多个线程。内存分配：同一进程内的线程,共享本进程的地址空间和资源，而进程之间的地址空间和资源,是相互独立的。影响关系：一个进程崩溃后，在保护模式下不会对其他进程产生影响，但是一个线程崩溃整个进程都死掉。所以多进程要比多线程健壮。执行过程：进程有独立的入口，就是 main 函数，线程不能单独运行，只能由进程创建然后开始运行。进程的优点就是健壮，不容易死掉；线程开销小、切换快，而且没有复杂的通信机制，定义一个全局变量就都可以访问。

14、音箱是如何实现同时接收阿里云服务器的消息和按键消息的？

用了 select 机制，把按键的设备文件对应的文件描述符和 socket 对应的文件描述符放在一个集合里面同时监听，监听到数据后再去判断到底是网络消息还是按键消息，然后再去调用不同的处理函数。

15、后台服务器为什么选择阿里云服务器？

服务器只要是公网服务器都行，阿里云、华为云、腾讯云都可以，当时看阿里云便宜就选择了阿里云。

16、服务器是怎么解决高并发问题的？能同时处理多少个音箱？

服务器用的一个高并发网络框架libevent，libevent在Linux上是通过epoll来实现的，(epoll)是一种效率比较高的多路复用技术，一个集合，里面有很多事件，一个事件对应一个客户端，不断的循环遍历集合，判断有没有客户端发送数据过来。它不会像多线程一样消耗过多的硬件资源。我写了一个sh脚本，用虚拟机模拟启动了 100 个音箱和 100 个客户端，运行比较慢，但是收发消息都正常。最多能处理多少个没试过，这个得取决于服务器软硬件性能吧。

17、你知道哪些并发服务器模型，有什么优缺点吗？

我知道有多进程、多线程、UDP、select、epoll。多进程的并发服务器开销比较大，因为每个进程都要独立的地址空间，所以效率并不高。多线程服务器资源开销确实比较小，但是线程同步又会比较麻烦，要加上一些同步机制。

UDP 其实算是循环服务器，谈不上并发。Select 能监听的文件描述符个数有上限，而且每次都得遍历集合，找到活跃的文件描述符，这个影响效率。Epoll 比 select 效率高，他是通过事件的方式通知应用层，省去了遍历集合这个环节。

补充：UDP 其实算是循环服务器，谈不上并发。为什么这么说？

UDP（User Datagram Protocol，用户数据报协议）通常被描述为一种无连接的、不可靠的协议。与TCP（Transmission Control Protocol，传输控制协议）不同，UDP不建立连接，不保证数据包的顺序、可靠传输或数据完整性。

在UDP服务器中，通常只有一个主循环，这个循环监听从客户端到来的数据报文（datagrams）。当数据报文到达时，服务器处理这个数据报文，然后继续等待下一个数据报文的到来。这个处理过程是顺序的，每次只处理一个数据报文，因此在基本的UDP服务器设计中，并没有并发处理数据报文的机制。

18、你刚才提到了线程同步，线程同步你用过哪些方法？

线程同步用过互斥锁、信号量和条件变量。

19、互斥锁和信号量有什么区别？

互斥锁只有两种状态，要么上锁，要么没上锁，同一时刻只允许一个线程访问共享资源。

信号量分为二值信号量和计数信号量，如果是二值信号量也只有两种状态，如果是计数信号量可以有多种状态，同一时刻可以允许多个进程访问共享资源。

20、如果有多个APP 和多个音箱，你这服务器能处理吗？

可以处理的，我在服务器端创建了一个链表，保存了 APP 和音箱的绑定的关系。第一次使用 APP 的时候，必须要输入app id号和音箱的设备ID 号，在服务器端记录两者的绑定关系，所以一个 APP 最终只能控制一个音箱。

21、服务器端是如何保存APP 和音箱数据的？

服务器端有一个链表，链表里面除了加入了 APP 和音箱的绑定关系，还记录了他们的在线状态，这样 APP 发送指令的时候，服务器就可以先判断对方是否在线，再选择发送。

22、服务器除了选择libevent实现，还有其他方式吗？

TCP+多线程、UDP、select或者直接使用libevent的底层实现 epoll 都可以实现。协议的话 TCP 比较合适，因为 TCP 安全可靠，而且我发送的指令数据量并不大。select 的话能处理的文件描述符数量有限，所以用作高并发不太合适，多线程太占用系统资源，epoll 效果应该是最好的。

23、你对多路IO 复用技术了解多少？

Linux 里面主要有 select、poll 和 epoll 三个，select 效率比较低，因为它只是知道了有 IO 事件发生，至于是哪个，还要循环查找所有的文件描述符，然后进行读写操作。而且 select 能监听的文件描述符个数有数量限制。

poll 和 select 本质没有区别，效率也不高。但是它没有文件描述符个数的限制，因为它是基于链表实现的。 epoll 不同于 select 和 poll，它是通过事件完成的，一旦有 IO 事件发生，会自动通知应用层，省去了循环遍历的麻烦。所以 epoll 的效率不会随着文件描述符数量的增加而降低。

（他们的缺点是什么？都是同步 IO。什么是同步 IO？异步 IO？）

24、客户端和服务器的通信选择了哪种协议？为什么选择了这种协

协议选择了 TCP 协议，TCP 安全、可靠、基于流（tcp是流式传输协议，udp是报式传输协议），

项目中客户端和服务器主要是传输一些指令，数据量不大，但是对安全性以及完整性要求比较高，所以就选择了 TCP。

我也比较过 TCP 和 UDP，UDP 简单但是不安全，不可靠，容易丢包，比较适合传输大量的数据，比如图片数据、音视频数据。

25、描述一下TCP 的三次握手和四次挥手。

三次握手是指客户端和服务器建立连接的过程。

1）第一次握手，Client 将标志位 SYN 置为 1，随机产生一个值 seq=J，并将该数据包发送给 Server，

Client 进入 SYN_SENT 状态，等待 Server 确认。

2）第二次握手，Server 收到数据包后由标志位 SYN=1 知道 Client 请求建立连接，

Server 将标志位 SYN 和 ACK 都置为 1， ack=J+1，随机产生一个值 seq=K，

并将该数据包发送给 Client 以确认连接请求， Server 进入 SYN_RCVD 状态。

3）第三次握手，Client 收到确认后，检查 ack 是否为 J+1，ACK 是否为 1，如果正确则将标志位 ACK 置为 1，ack=K+1，并将该数据包发送给 Server，Server 检查 ack 是否为 K+1，ACK 是否为 1，

如果正确则连接建立成功，Client 和 Server 进入 ESTABLISHED（一丝淡薄里斯，确定的）状态，完成三次握手，随后 Client 与 Server 之间可以开始传输数据了。

四次挥手是指服务器和客户端断开连接的过程，既可以是服务器发起，也可以是客户端发起。

第一次挥手，Client 发送一个 FIN，用来关闭 Client 到Server 的数据传送，Client 进入 FIN_WAIT_1 状态。

第二次挥手，Server 收到 FIN 后，发送一个 ACK 给 Client，确认序号为收到序号+1（与 SYN 相同，一个 FIN 占用一个序号），Server 进入 CLOSE_WAIT 状态。

第三次挥手，Server 发送一个 FIN，用来关闭 Server 到 Client 的数据传送，Server 进入 LAST_ACK 状态。

第四次挥手， Client 收到 FIN 后，Client 进入 TIME_WAIT 状态，接着发送一个 ACK 给Server，确认序号为收到序号+1，Server 进入 CLOSED 状态，完成四次挥手。

26、如何保证qtAPP 端的数据一定能被音箱收到？

我模拟了 TCP 协议的超时重传机制，APP 发送指令给服务器，服务器转发给音箱，音箱收到数据后还要回复服务器，服务器再回复 APP，所以 APP 只有收到了服务器的回复才认为消息发送成功，如果超过规定的时间还没有收到，会再次发送数据。超时时间是通过 setsockopt 函数来设置的。

27、如果在使用的过程中由于网络问题音箱掉线了怎么处理的？

为了保证音箱时刻在线，我在项目中添加了一种保活机制，就是音箱每隔 1 秒钟向服务器发送一帧数据，表示音箱还在线。所以如果当前的时间节点-上一次保活的时间节点，超过 1S 服务器都没有收到数据，就可以判定音箱掉线了，这个时候服务器会通知 APP。

28、网络传输数据为什么选择了 json 传输？尝试过其他格式吗？

json 用起来更加灵活，不像结构体那样庞大，需要发送什么就添加什么键值对。其他格式听说过 XML 和 YAML，但是没有使用过。

29、Qt 端的语音识别是怎么实现的？

语音识别用的是百度 AI 平台提供的接口，先把语音录制成音频文件，然后通过 HTTP 方式向百度服务器发起请求，最终返回识别的结果。

30、APP 为什么选择 Qt，没有做 Android 或者 IOS 吗？

Qt 是 C++的一个应用，用的就是 C++语言，而且他的跨平台性比较好，Linux 和 Windows 都可以使用。Android 和 IOS 没有研究过。

31、说一说 Qt 的信号与槽机制。

信号与槽是 Qt 里面的一个重要机制，主要是方便各个组件之间的交互。信号就是在特定情况下发生的事件，比如 button 被点击是一个事件、输入框按下回车是一个事件。槽就是收到特定信号后的处理函数，比如点击按键后，向服务器发起连接，发起连接这个动作可以放在槽函数中。

32、Qt 下如何自定义信号？

使用 signals 关键字来声明信号，emit 发送信号，在需要接受信号的对象中连接槽函数。信号可以有参数，但是不能有返回值。

33、做项目的过程中你遇到了哪些问题？是怎么解决的？

印象比较深的是音箱连不上服务器，后来我自己在本地写了一个服务器程序，可以连上，大概确认了音箱程序没有问题。

然后在Google 或者是 Stack Overflow上查了一下连不上的原因，发现是阿里云你需要自己在安全组添加对应的协议和端口号…

34、你觉得这个项目还有哪些地方需要改进？

我觉得目前音箱还不够智能，不能够通过语音直接控制开发板。后面我打算升级一下硬件系统，因为 mini2440 不管是内存还是 CPU 都只适合学习，然后增加一些模块,比如语言识别模块，实现本地的语音控制。目前国内的智能音箱基本能够实现人机对话，我觉得这一块我要研究的内容还有很多。

2024-04-20七大排序算法+层序遍历

Sat, 20 Apr 2024 00:00:00 +0000

This article offers a sample of basic Markdown.

正文开始

https://www.nowcoder.com/login?callBack=%2Fprofile%2F319706329%2FcodeBookDetail%3FsubmissionId%3D416948138

1.冒泡排序(从小到大)

#include <iostream>
#include <vector>

using namespace std;

//冒泡排序
vector<int> MySort(vector<int>& arr) {
    int n = arr.size();
    for(int i = 0; i< n-1;i++)//冒泡排序和选择排序都是0~n-1轮
    {
        for(int j = 0 ; j <n -i-1 ;j++)
        {
            if(arr[j] <= arr[j+1])continue;
            int t = arr[j];
            arr[j] = arr[j+1];
            arr[j+1] = t;
        }
    }
    return arr;
}

int main()
{
    vector<int> arr{5,2,3,1,4};
    for(auto it : arr)
    {
        cout<<it<<" ";
    }
    cout<<" "<<endl;
    MySort(arr);
    for(auto it : arr)
    {
        cout<<it<<" ";
    }
    return 0;
}

2.选择排序(从小到大)

#include <iostream>
#include <vector>

using namespace std;

//选择排序
vector<int> MySort(vector<int>& arr) {
    int n = arr.size();
    for(int i = 0; i< n-1;i++)
    {
        //只有这个是需要改变的
        int min_idx = i;
        for(int j = i+1 ; j < n; j++)//找到[i,n-1]范围内,最小数的下标
        {
            if(arr[j] <arr[min_idx])min_idx = j;
        }
        int t = arr[i];
        arr[i] = arr[min_idx];
        arr[min_idx] = t;
    }
    return arr;
}

int main()
{
    vector<int> arr{5,2,3,1,4};
    for(auto it : arr)
    {
        cout<<it<<" ";
    }
    cout<<" "<<endl;
    MySort(arr);
    for(auto it : arr)
    {
        cout<<it<<" ";
    }
    return 0;
}

3.插入排序

#include <iostream>
#include <vector>

using namespace std;

//插入排序
/**
* 将数组分为已排序和未排序的两部分,每次从未排序中选取一个元素,将他插入到已排序的的部分的正确位置
*/
vector<int> MySort(vector<int>& arr) {
    int n = arr.size();
    //arr[0]是已排好序的
    for(int i = 1; i < n; i++)
    {
        int key = arr[i];//我们要排序的元素
        int j = i-1;//已排好序的部分是[0,j]
        while(j >= 0 &&arr[j]>key)
        {
            arr[j+1] = arr[j];
            j--;
        }
        arr[j+1] = key;//j有可能<0,这么看来+1也就记住了吧
    }
    return arr;
}

int main()
{
    vector<int> arr{5,2,3,1,4};
    for(auto it : arr)
    {
        cout<<it<<" ";
    }
    cout<<" "<<endl;
    MySort(arr);
    for(auto it : arr)
    {
        cout<<it<<" ";
    }
    return 0;
}

4.归并排序

#include <iostream>
#include <vector>

using namespace std;

//归并排序
vector<int> tmp;
void merge_sort(vector<int>&q ,int l,int r)
{
    if(l >= r) return;

    int mid = (l + r) >>1;
    merge_sort(q, l, mid);
    merge_sort(q, mid+1, r);

    int k = 0;//临时数组的下标
    int i = l , j = mid + 1;//i<=mid < mid+1<=r/////////////
    while(i <= mid && j <= r)//////////////
    {
        if(q[i] <= q[j])tmp[k++] = q[i++];
        else tmp[k++] = q[j++];
    }

    while(i<=mid){tmp[k++] = q[i++];}
    while(j<=r){tmp[k++] = q[j++];}
    for( i = l ,j = 0 ; i <= r ; i++,j++)q[i] = tmp[j];
}
vector<int> MySort(vector<int>& arr) {
    int n = arr.size();
    tmp.resize(n,0);//初始化为n个元素且都为0
    merge_sort(arr, 0, n-1);//0,n-1是下标
    return arr;
}
int main()
{
    vector<int> arr{5,2,3,1,4};
    for(auto it : arr)
    {
        cout<<it<<" ";
    }
    cout<<" "<<endl;
    MySort(arr);
    for(auto it : arr)
    {
        cout<<it<<" ";
    }
    return 0;
}

5.快速排序

//快速排序
void quick_sort(vector<int>&q,int l ,int r)
{
    if(l >= r)return;
    int x = q[(l+r)>>1], i=l-1 , j=r+1;//x是最中间的那个数,i要多往前走一步,j要多往后走1步
    while (i < j) {
        do i++ ; while(q[i] < x);
        do j-- ; while(q[j] > x);
        if(i<j) swap(q[i],q[j]);//快速排序比的是下标
    }
    quick_sort(q, l, j);
    quick_sort(q, j+1, r);
}
vector<int> MySort(vector<int>& arr) {
    int n = arr.size();
    quick_sort(arr,0,n-1);
    return arr;
}

6.希尔排序(了解)

希尔排序是插入排序的一种优化,

他的核心思想是假定原数组中间间隔着特定的增量,然后通过对组内的元素进行插入排序,

不断缩小增量序列,从而达到有序的状态.

我只了解过基本的原理,并没有实际使用过.

7.堆排序(了解)

堆排序是基于二叉堆数据结构的一种比较排序算法。二叉堆是一种完全二叉树，其中每个父节点的值都大于或等于（小于或等于）其子节点的值，称为最大堆（最小堆）。

堆排序算法的基本思想是将待排序的数组构造成一个最大堆，然后不断调整堆,进行下沉操作，直到数组有序。

堆排序的优势在于其时间复杂度稳定为O(nlogn)，不受输入数据的影响。而且不需要额外的存储空间。

这个我也只是了解过基本的原理,并没有实际使用过.

反转链表

206. 反转链表

class Solution {
public:
    // ListNode* reverseList(ListNode* head) {
    //     if(!head)return NULL;
    //     auto a = head,b = head->next;
    //     while(b)
    //     {
    //         auto c = b->next;
    //         b->next= a;
    //         a = b;
    //         b = c;
    //     }
    //     head->next = NULL;
    //     return a;
    // }
    ListNode * reverseList(ListNode * head)
    {
        if(!head || !head->next)return head;
        auto tail = reverseList(head->next);
        head->next->next = head;
        head->next = NULL;
        return tail;
    }
};

层序遍历

102. 二叉树的层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>>res;
        if(!root)return res;
        queue<TreeNode*>q;//中间变量
        q.push(root);
        while(!q.empty())
        {
            vector<int> level;//每一层的结点(要放到答案res里面的)
            int len = q.size();//这一层的节点个数
            while(len --)
            {
                auto t = q.front();
                q.pop();
                level.push_back(t->val);

                //未下一层做准备
                if(t->left)q.push(t->left);
                if(t->right)q.push(t->right);
            }
            res.push_back(level);
        }
        return res;
    }
};

#include <iostream>
#include <vector>

using namespace std;

// 提问1:指针怎么调用函数?
// 你可以使用using根据函数签名来创建一个函数指针类型
void func(int t)
{
    cout << t << endl;
}

using FuncPtr = void (*)(int);

using SortPtr = void (*)(vector<int> &);
// 提问2:冒泡排序的原理是什么? 他的时间复杂度是多少?O(n^2)
void sort_1(vector<int> &arr)
{
    int n = arr.size();
    for (int i = 0; i < n - 1; i++)
    {
        for (int j = 0; j < n - i - 1; j++)
            if (arr[j] > arr[j + 1])
                swap(arr[j], arr[j + 1]);
    }
}
// 提问3:选择排序的原理是什么? 他的时间复杂度是多少?O(n^2)
// 也是遍历n-1轮,他是从i为0的元素开始,直到我们将他放到合适的位置
// 选择排序的难点:最小元素的下标
// 选第1小的元素的下标,选第2小的元素的下标,选第3小的元素的下标...
void sort_2(vector<int> &arr)
{
    int n = arr.size();
    for (int i = 0; i < n - 1; i++)
    {
        int min_idx = i;
        int j = min_idx + 1;
        while (j < n)
        {
            if (arr[j] < arr[min_idx])
                min_idx = j;
            j++;
        }
        swap(arr[i], arr[min_idx]);
    }
}
// 提问4:插入排序的原理是什么? 他的时间复杂度是多少?O(n^2)
// 两部分:一部分已经排好了,另一部分没排列好,我们就不断把没排好的元素插入到排好的一部分中
// 我们先把要插入元素提起来,也就是说这个元素的位置就空了,然后不断的将前面的元素往后移
void sort_3(vector<int> &arr)
{
    int n = arr.size();
    // 这是没排好的部分
    for (int i = 1; i < n; i++)
    {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) // 前一数比这个数大了,我们就要把他后移
        {
            arr[j + 1] = arr[j]; // j+1这个位置被空出来了
            j--;
        }
        swap(key, arr[j + 1]);//或者这arr[j+1]=key;也行
    }
}

// 提问5:归并排序的原理是什么? 他的时间复杂度是多少?O(n log n)
// 合并两个子数组的复杂度为 O(n)），而分割的层数是对数级别的（每分割一次，数组的大小减半，
// 所以需要 log n 层分割才能到达单个元素）。
// 线性的合并复杂度乘以对数级别的层数，最终时间复杂度就是 O(n log n)
vector<int> tmp;
void merge_sort(vector<int> &q, int l, int r)
{
    if (l >= r)
        return;
    int mid = l + r >> 1;
    merge_sort(q, l, mid);
    merge_sort(q, mid + 1, r);

    int k = 0;
    int i = l, j = mid + 1;
    while (i <= mid && j <= r) // 想一下:i有没有可能等于mid,j有没有可能等于r
    {
        if (q[i] <= q[j])
            tmp[k++] = q[i++];
        else
            tmp[k++] = q[j++];
    }
    while (i <= mid)
        tmp[k++] = q[i++];
    while (j <= r)
        tmp[k++] = q[j++];
    for (i = l, j = 0; i <= r; i++, j++) //
        q[i] = tmp[j];
}
void sort_4(vector<int> &arr)
{
    int n = arr.size();
    tmp.resize(n, 0);
    merge_sort(arr, 0, n - 1);
}

// 提问6:快速排序的原理是什么? 他的时间复杂度是多少?平均情况下为O(n log n)，最坏情况下为O(n^2)
void sort_5(vector<int> &q, int l, int r)
{
    if (l >= r)
        return; // 左和右是一个数,就没必要继续了(这里加等号,表示两个数相等了,那就是没必要继续了)
    int x = q[l + r >> 1], i = l - 1, j = r + 1;
    while (i < j) // 这里不加等号是因为:这个是只要在i不等j的情况下,就继续遍历
    {
        do
            i++;
        while (q[i] < x); // 我们要的是一个从小到到的排列顺序,所以,正常情况下是q[i]<x<q[j],直到不满足的时候,我们就把两个数进行交换
        do
            j--;
        while (q[j] > x);
        if (i < j) // 这个表示,如果i不等于j
            swap(q[i], q[j]);
    }
    // 此刻,q[l,j]都是<=x,q[j,r]都是>=x
    sort_5(q, l, j);
    sort_5(q, j + 1, r);
}
// 提问7:希尔排序   插入排序Ultra

// 提问8:堆排序  O(nlogn)

int main()
{
    FuncPtr ptr = func;
    ptr(2);
    func(1);

    printf("你好\n");
    vector<int> array{11, 412, 41, 454, 1, 2, 4545, 24, 4574};
    cout << "排序前:";
    for (auto x : array)
    {
        cout << x << ' ';
    };
    // SortPtr ptr1 = sort_3;
    // ptr1(array);

    // using SortPtrUltr = void (*)(vector<int> &, int, int);
    // SortPtrUltr ptr2 = sort_5;
    // ptr2(array, 0, array.size() - 1);
    using Sort_merge = void (*)(vector<int> &);
    Sort_merge ptr3 = sort_4;
    ptr3(array);

    cout << endl
         << "排序后:";
    for (auto x : array)
    {
        cout << x << ' ';
    };
    return 0;
}

总结一下:

O(n^2)就是两层循环:for+for,或者for+while

冒泡排序:O(n^2),第一次将第一大的浮出水面,第二次将第二大的浮出水面,…
选择排序:O(n^2),第一次拿到第一小元素的下标,第二次拿到第二小元素下标…
插入排序:O(n^2),将未排好顺序的部分,一个元素一个元素的插入到排好顺序的部分,

比如举个例子:将x插入到[0,j]的部分,每次在遇到x<q[j]时,q就往后移动一位,直到x不再小于为止,那个位置就是x应该插入的位置

快速排序:平均情况下为O(n log n)，最坏情况下为O(n^2),==先治后分==,取一个标准,比如说中间值,我设置为x,不断将数组分为<=x的部分,和>=x的部分,双指针从两边走,走不动时(不满足q[i]<x<q[j]),就交换
归并排序:O(n log n),分治思想,==先分后治==,分成[l,mid]和[mid+1,r],

,看成两个数组,每次取每个数组的最小值,加入到临时数组中,

最后在把临时数组放到最终的数组中(临时数组每次递归都是从下标0开始的)

2024-04-19面试复盘

Fri, 19 Apr 2024 00:00:00 +0000

This article offers a sample of basic Markdown.

正文开始

在线编程工具:

https://www.bejson.com/runcode/c740/

sizeof(空类) = 1;

静态成员变量和成员函数都不占类的大小(sizeof),也就是说静态成员变量和成员函数都不属于类

继承下面说了

封装:将变量设置为protected或者provate,限制这些变量在类外的直接访问,我们可以使用get常量函数来完成对这个变量的封装

protected:当一个成员被定义为protected类型时，仅能在类内、友元和派类访问。

private:当一个成员被定义为private类型时，仅能在类内、友元访问。

多态下面说了

1.struct和class的区别

首先,class是cpp独有的,c语言里面没有,

然后就是在cpp中,class的默认访问权限是private,而struct是public;

还有就是class默认都是私有继承,而sruct默认是公有继承.

最后一点是,在语法上的区别,你使用cpp中 ,

不管是struct还是class,都可以直接使用类名.

在c语言中,要么写 struct A a;(带上struct),要么你用typedef struct A A;一下

涉及知识:https://blog.csdn.net/weixin_52668597/article/details/136666085?spm=1001.2014.3001.5501

补充:公有继承,保护继承与私有继承下,类内的元素的权限变化:

公有继承:原来啥权限就还是啥权限,一点不变
保护继承:原来公有变保护,其他两个->原来啥权限就还是啥权限
私有继承:原来公有变私有,原来保护变私有,原来私有还是私有

2.值传递，地址传递，引用传递（拷贝）的区别

值传递你无法在函数中改变这个变量的值

地址传递和引用你可以在函数中改变这个变量的值

值传递相当于是你建立了一个副本,你是你,他是他,你的改变无法影响到他,他的改变无法影响到你.

地址传递的话,传进去的就是本人了,此时修改地址上的数据会影响到原始数据.

而引用传递相当于是给该变量取的别名,相当于是一个大名一个小名比如鲁迅和周树人,本质上还是一个人,所以改变引用传递的变量也可以改变变量的原始数据

4.指针是几个字节？

64位系统是8字节

32位系统是4字节

5.static关键字

static的用法分为静态变量与静态函数

静态变量将变量限定在当前文件下,且生命周期和该文件运行的周期一样长.

然后再细分就是局部静态变量与全局静态变量:局部静态变量被限定在一个代码块内(一般是一个函数),而全局静态变量只要是在这个文件内,都可以访问.

再者就是静态函数了,静态成员函数只能访问静态成员变量

然后就是,类中的静态成员变量并不属于这个类,你用sizeof去算,他不算这个类的大小

涉及知识:cpp编译单元 https://blog.csdn.net/weixin_52668597/article/details/137575061?spm=1001.2014.3001.5501

6.虚函数指针，虚函数表

涉及知识:https://blog.csdn.net/weixin_52668597/article/details/137447982?spm=1001.2014.3001.5501

只要你在类中写了一个虚函数,那么就会产生一个虚函数表.

而且不管你写多少个虚函数,这些虚函数在类中所占的内存就只有8个字节,而占的这八个字节就是虚函数指针,也就是说,这些虚函数都放在一个数组中,这个数组就是虚函数表

7.多态

涉及知识:https://blog.csdn.net/weixin_52668597/article/details/137447982?spm=1001.2014.3001.5501

多态其实就是父类指针指向子类对象,如果子类重写了父类的方法,那么这个父类指针就会呈现出不同的现象

8.编译器如何知道你是进行的函数重载

答：函数重载，它允许在同一个作用域中定义多个同名函数，但这些函数的参数列表或类型必须不同。在调用这些函数时，编译器会根据传递给函数的参数的数量、类型或顺序来确定要调用的具体函数版本。

简单来讲，就是函数重载可以是参数类型不同，参数顺序不同，也可以是参数个数不同

编译器会在内部，把函数名称和参数列表一起存储在符号表中，这样编译器就知道了你用的是哪个重载之后的函数

就是，编译器在处理函数重载时，会将函数名称和参数列表一起存储在符号表（或类似符号表的数据结构）中。这样编译器就能够确定每个函数的唯一签名，并且在需要进行函数调用匹配时可以快速检索并确定调用哪个函数版本。

9.构造，析构的顺序

在C++中，对象的构造和析构顺序

最主要是

和对象的创建和销毁顺序相关。

一般情况下，对象的构造顺序与对象的创建顺序相同，对象的析构顺序与对象的销毁顺序相反。

比如说，如果一个类 A （包含类 B 和类 C 的对象作为成员），则在创建 A 的对象时，首先会调用 B 的构造函数，然后调用 C 的构造函数。

然后析构顺序就与构造顺序相反。也就说当销毁对象A时，析构函数会按照对象在类成员声明中的逆序依次调用。继续上面的例子，也就是说，他首先会调用 C 的析构函数，然后调用 B 的析构函数。

还有一种情况：就是父类和子类的析构与构造关系：

比如说现在有一个子类b,他继承了父类a,那么在创建子类b的对象时,

就会先调用父类a的构造函数,

再调用自己子类b的构造函数,

在析构的时候,顺序就反过来了,

就是先析构子类b,

最后再析构父类a

Base::fun()
Child::fun()
~Child::fun()
~Base::fun()

10.stl：vector、list、Map的区别

vector:底层是一个动态数组,可以通过下标进行快速随机访问,占据连续的内存,在不扩容的情况下,在尾部增删很快.在扩容的情况下,需要先开辟原来容器大小的1.5倍,再将原数据拷贝到新的内存,最后在释放原内存

==他的缺点是在数组的中间进行增加或者删除时的复杂度为O(n)==,但是==删除慢这个缺点可以用一些简单的算法进行优化==,比如说可变数组它最后一个位置删除很快,我们可以用swap将这个位置的数与尾部的数进行交换,再删除尾部这个数.

list:是一个双向链表,他访问一个元素的复杂度是o(n),他的内存是不连续的,节点之间通过指针连接.他唯一的优势是可以快速的在任意位置进行增删,但前提是先经过o(n)的复杂度找到这个位置

Map:是一个键值对,类似于json那种结构,底层是红黑树实现.

每个键都是唯一的(键和值可以为null,但是键只能出现一次),

map在插入好删除时会自动排序,他对元素的访问、插入和删除操作，这些操作的时间复杂度通常是对数时间（即O(log n)）。

#include<iostream>
#include<map>

using namespace std;

class A{};

int main()
{
    map<A*,int> m1,m2;
    m1[nullptr] = 1;
    A *a = new A();
    m2[a] = 2;
    
    printf("%d,%d",m1[nullptr],m2[a]);

    map<A*,A*> m3;
    m3[nullptr] = nullptr;
    return 0;
}

11.智能指针

智能指针有auto_ptr，share_ptr，unique_ptr还有shared_ptr

auto_ptr是C++98中引入的第一个智能指针，但是由于他的不安全性已被C++11弃用。他其实被unique_ptr给取代了,可以理解为auto_ptr他其实是一个浅拷贝,非常容易造成多个指针指向同一块内存区域的现象，这就引发非常多的潜在的问题:比如一些常见的段错误,多次析构,访问一段未定义的空间等,比如说你在文件中访问这个指针,但是其实你已经在其他地方释放这段内存了.

然后,unique_ptr 他提供了独占所有权的智能指针，允许有且仅有一个 unique_ptr 拥有资源。与 auto_ptr 不同，unique_ptr 实现了更安全和更完整的独占所有权语义

然后,shared_ptr,他允许多个指针共享同一块内存，并且会在最后一个 shared_ptr 被销毁时释放这段内存。它使用的是一种引用计数的技术来追踪资源的所有者数量，并在所有者数量为零时自动释放资源。

然后最后一个,是weak_ptr: 他是 shared_ptr 的伴侣类，它允许你共享资源但不拥有资源。weak_ptr 不会增加引用计数,它通常用于解决 shared_ptr 的循环引用问题。

循环引用的问题:

然后循环引用通常是shared_ptr互相引用造成的,两个或多个对象相互持有对方的 shared_ptr，导致它们的引用计数永远不会降为零，然后导致资源泄漏。我想到的一个例子是，比如说有一个双向列表，他们的每个节点对象都有两个指针,一个是前指针prior pointer，一个是next指针，

然后两个相邻的节点对象，节点1的next指针指向节点2自身，节点2的前指针prior pointer指向节点1自身，然后这两个节点都用share_ptr进行创建,在创建时,节点自身这段内存引用计数+1,然后被相邻指针指向时,引用计数再+1,这样每个节点的引用计数就都是2,

然后当我们销毁节点这个share_ptr后,前后节点的引用计数都降为了1,但是前节点在等着后节点的prior pointer放手,后节点在等着前节点的next pointer放手,这就形成了死锁,

造成的现象就是这两个节点的指针已经被销毁了,但是节点的内存迟迟无法析构,就造成了"内存泄漏",解决的办法就是把这个节点的prior指针和next指针都变成weak_ptr

12.项目中如何保证线程安全？(如何避免死锁)

加锁:互斥锁,读写锁,cpp中特有的智能锁

死锁；

产生的条件：互斥，请求保存，不可抢占，循环等待
可能产生的情况分为两种：

1)第一种是：用到了一把锁造成的死锁，产生的原因是操作失误，加了锁后忘记解锁了或者是一把锁被加了两次造成的死锁，你再去解锁就解不开了… 或者是你在解锁之前，因为满足某种条件提前return了
1 2 3 4 5 6

eg： void func（）{ 上锁 if（条件）return; 解锁 }
说是忘记，但有时候就是容易但这样的错误，而且在项目开发的时候调试起来没那么容易，比如说我们最容易犯的函数循环嵌套的死锁问题；函数a调用了函数b，但是函数a和b内部都用到了同一把锁，保护相同的共享资源，导致一个线程同时上两次锁，这个问题还是比较隐晦的，我遇到过一次

2)另一种是用到了多把锁，当多个线程访问了多块共享资源，就需要多把锁，（共享资源可以是一个全局变量，也可能是一段堆内存，还可能是一个静态资源，或者是在main函数中申请的一段栈空间，因为只要main函数不结束，这个资源就不会被回收，所以也可以做这个共享资源），所以说每个共享资源都需要一把锁。比如说两个共享资源两把锁，资源x被锁a锁住了，资源y被锁b锁住了，在资源x没有解锁的情况下，资源x去访问资源y，而资源y也在没有解锁的情况下去访问资源x，这样就僵持不下
死锁避免的解决办法：

第一种方法：你在访问其他共享资源时，需要先把你目前持有共享资源解开。
第二种方式：在访问共享资源时，不要直接加锁，而是尝试加锁()，因为我们提供的互斥锁里面都有一个trylock，如果尝试失败，你就先等一等，等其他线程解锁后，你再trylock就成功了
另外，cpp11还提供了lock_guard智能锁，和智能指针管理类似，使用了lock_guard我们就不需要去维护互斥锁的解锁操作。不过，lock_guard管理的是一个大括号这一段代码，假如说这段大括号有100多行代码，使用lock_guard就不太划算，因为锁住的太多了，这个使用还是使用常规锁，不要使用智能锁。

在项目中,我使用的是libevent+线程池,在线程池中有很多子线程,如果有子线程操作共享资源,那么需要加锁,

这里也是会有一个生产者消费者的概念,任务队列相当于那个容器,不断有生产者线程给任务队列中放任务,也不断有消费者线程从任务队列里面拿任务,生产者线程不只一个,消费者线程也不只一个.

如果只有一个任务队列,会出现惊群效应:只有一个任务可拿,但是却唤醒了所有的消费者线程,最后只有一人能够拿到这个任务,其他消费者都是无效唤醒

为了解决这个"惊群效应",我们采用建立多个任务队(有多少个线程,就创建多少个任务队列),每个线程都有属于自己的任务队列,那么此时就不再出现线程与线程之间的竞争了(就和libevent+线程池一样,每个线程都有属于自己的事件集合,为的就是避免线程竞争),既然该任务队列被一个线程独占,那么就不存在竞争了,就无需加锁,他在添加的时候不能处理,他在处理的时候不能添加

主线程负责两件事:

1)负责和新客户端建立连接

2)主线程还会给任务队列中添加任务,子线程负责从任务队列中取任务

有一个很傻的问题:

问任务队列加了互斥锁,其他线程想访问时会被阻塞,你还是如何唤醒他们的?

答:这个其实不用唤醒,我们在使用互斥锁保护一段共享资源时,

访问前上锁,访问后解锁,

当我们某一个线程正在访问这个共享资源时上锁保护,其他的线程就会被排斥在外,

然后这些线程就会不断地尝试加锁,

当正在操作共享资源的这个线程解锁后,哪个线程先抢到,哪个线程就使用共享资源,

是不需要唤醒的.

总结一下,如何唤醒阻塞?

1)如果是互斥锁导致的阻塞,阻塞的时候就使用lock加锁,要唤醒的时候使用ulock解锁就行了.

2)如果是条件变量导致的阻塞,那么当你要阻塞的时候就是wait函数,如果你要唤醒一个那就是notify_one,如果要唤醒全部那就是notify_all

再补充一点:读写事件

读事件是如果读缓冲区有数据可读,读事件自动就触发了

写事件是 在写之前,检查写缓冲区是否可写,如果可写写事件才会被处罚. 并不是写入之后才会被触发.

13.死锁

死锁产生的条件:

14.多线程中多个信号与主线程

主线程一般是负责控制和协调其他线程的任务。比如说我这个共享单车项目中的服务器,他的主线程主要是负责监听客户端的连接,一旦有客户端来进行连接,我们就会把这个客户端通过libevent变成一个事件,并把他加入到事件集合中去,然后由其他线程来监听该客户端的读写事件,并通过轮询的方式拿到线程池中的一个线程,然后由这个线程通过调用它自己的回调函数来处理这个读写事件.相当于主线程就是是负责统筹规划的,他只复制监听客户端,剩下的交给其他线程.

然后我的毕设的服务器是只用到了libevent,没有用到线程池,毕设主要的项目亮点是硬件的uboot系统移植以及arm架构下的库的交叉编译,还有qt的自定义部件、界面以及qt打包等,最终形成一个完善的项目.

然后硬件是用到的一个多进程通信，使用的是shm共享内存

在多线程编程中，主线程可以通过发送信号来与其他线程进行通信。

常见模式有：

1). 条件变量（Condition Variables）：相当于是一种基于互斥锁的线程间同步机制，通常情况下是和锁一起使用的。主线程可以使用条件变量来等待特定的条件达成，而其他线程则可以通过发送信号来通知主线程条件的改变。一旦条件满足，主线程就会被唤醒并继续执行。

2). 事件（Events）：事件也是一种用于线程间同步的通信机制，通常用于向其他线程发出信号以触发特定事件的发生，然后执行事件的回调函数。主线程可以等待某个事件的发生，其他线程可以通过发送信号来触发该事件。

3). 信号量（Semaphores）：

信号量维护一个计数器，表示可用资源的数量。线程可以通过请求（等待）和释放（发信号）操作来获取和释放资源。当计数器为正时，线程可以继续执行，否则线程会被阻塞直到资源可用。就是我们常说的那个操作系统pv操作，经常用来解决“生产者消费者的问题”,当然信号量也是可以的

伪代码：

生产者和消费者都可以有很多个

情况有三种:
1.队列已满,生产者停止生产商品  -> 生产者wait条件变量
2.队列为空,消费者无商品可取  -> 消费者wait条件变量
3.队列不满但非空,生产者正常生产商品,消费者正常取商品

#include "需要的头文件"

//wait()-> P()操作 --
//signal()-> V()操作  ++

typedef struct{
    int value; //剩余资源数
    struct process *list;//等待队列
} semaphore;

semaphore empty,full;//空位和产品的数量  空位数+产品数=最大容量
Mutex mutex1,mutex2;//两个互斥锁

//申请使用资源
void wait(semaphore s)
{
    s.value --;
    if(s.value < 0)//剪完1后,可能等于0(表示资源刚好用完,但是够用,所以不阻塞),也可能<0(资源早就用完了,再减一就没得用了,所以要阻塞)
    {
        block(s.list);
    }
}

//使用完释放资源
void signal(semaphore s)
{
    s.value ++;
    if(s.value <= 0)//刚释放完一个资源(也就是说现在有一个资源可用),发现资源数==0,说明说明之前是<0的,表示队列已经阻塞了;如果发现资源数<0,那就更不用说了,肯定有消费者在等待
    {
        wakeup(s.list);
    }
}



// 生产者函数
void producer() {
    while (1) {
        produce();//生产1个东西
        wait(empty);//空位减1个
        wait(mutex1);//上锁

        array[空位] = 产品;//给一个空位放产品

        signal(mutex1);//解锁
        signal(full);//产品数+1

    }
}

// 消费者函数
void consumer() {
    while (1) {
        wait(full);//产品数-1
        wait(mutex2);//上锁

        array[产品数] = null;//拿走一个产品

        signal(mutex2);//解锁
        signal(empty);//空位+1

        comsum();//消费这个产品
    }
}

int main() {
    std::thread prod(producer);
    std::thread cons(consumer);
    prod.join();
    cons.join();
    return 0;
}

1
2

信号量（Semaphore）：
信号量是一种用于控制对共享资源的访问的同步机制。它通常用于实现进程或线程间的协调。信号量主要包含两种操作：wait()（或称为P()操作）和 signal()（或称为V()操作）。wait()操作会减少信号量的计数，如果结果为负数，则线程会阻塞。signal()操作会增加信号量的计数，如果有线程正在阻塞，它会被唤醒。

4). 消息队列（Message Queues）：主线程可以通过发送消息到队列中来通知其他线程，而其他线程则可以从队列中接收消息并执行相应的操作。

15.qt信号槽中有第五个参数，有了解过吗？

信号槽中有第五个参数支持qt中,信号与槽进行跨跨线程通信,他是一个枚举值, 默认是自动连接,也比较智能,如果信号与槽是在同一个线程,就直接调用槽函数,如果不在同一个线程,会自动使用QueuedConnection.

然后支持多线程的枚举值其实有两个,一个是Queued Connection,另一个是BlockingQueuedConnection,这两个支持信号与槽的异步通信,唯一的区别是:

Queued Connection是异步非阻塞的，BlockingQueuedConnection是异步阻塞的,然后非阻塞是运行后直接返回,阻塞是运行结束后才返回. Queued Connection用的比较多,他可以保证槽函数的调用是在接收者的线程中进行的，所以就不会有多个线程同时访问槽函数中的共享资源的情况发生（除非槽函数内部又进行了不安全的跨线程操作）,这样就避免线程竞争,避免了线程安全的问题。

补充:

1)C语言链表

#include <stdio.h>
#include <stdlib.h>

typedef struct Node{
    int data;
    struct Node * prior;
    struct Node * next;
} Node;


int main ()
{
    /***
     * c语言像数组的链表
    */
   /*
    Node* list = (Node *)malloc(sizeof(Node) *5);


    if (list == NULL) {
        // 内存分配失败的处理
        fprintf(stderr, "Memory allocation failed.\n");
        return 1;
    }
    
    // 初始化链表节点
    for (int i = 0; i < 5; ++i) {
        list[i].data = i; // 数据域初始化为索引值或其他你选择的值
        
        if (i == 0) {
            // 第一个节点的前驱指向 NULL
            list[i].prior = NULL;
        } else {
            // 其他节点的前驱指向前一个节点
            list[i].prior = &list[i - 1];
        }
        
        if (i == 4) {
            // 最后一个节点的后继指向 NULL
            list[i].next = NULL;
        } else {
            // 其他节点的后继指向下一个节点
            list[i].next = &list[i + 1];
        }
    }
    
    // ... 使用链表
    for(int i = 0; i< 5;i++)
    {
        int num = list[i].data;
        printf("%d\n",num);
    }
    // 释放分配的内存
    free(list);
    */

   /******c语言链表********/
    Node *n1 = (Node *)malloc(sizeof(Node));
    Node *n2 = (Node *)malloc(sizeof(Node));
    Node *n3 = (Node *)malloc(sizeof(Node));
    n1->data = 1;
    n1->prior = NULL;
    n1->next = n2;

    n2->data = 2;
    n2->prior = n1;
    n2->next = n3;

    n3->data = 3;
    n3->prior = n2;
    n3->next = NULL;

    for(Node * node = n1; node != NULL;node = node->next)
    {
        int num = node->data;
        printf("[%d]\n",num);
    }
    
    return 0;
}

输出:
[1]
[2]
[3]

2)链表-智能指针版



#include <iostream>
#include <memory>//智能指针

using namespace std;

struct Node{
    int data;
    weak_ptr<Node> prior;
    weak_ptr<Node> next;
};


int main()
{
    shared_ptr<Node> n1 = make_shared<Node>();
    shared_ptr<Node> n2 = make_shared<Node>();
    shared_ptr<Node> n3 = make_shared<Node>();
    n1->data = 1;
    n1->prior.reset();//智能指针设置为空应该用reset函数,而不是n1->prior = nullptr;
    n1->next = n2;

    n2->data = 2;
    n2->prior = n1;
    n2->next = n3;

    n3->data = 3;
    n3->prior = n2;
    n3->next.reset();//n3->next = nullptr;

    for(shared_ptr<Node> node = n1 ; node != nullptr ; node = node -> next.lock()){//你需要先用lock将weak_ptr提升为shared_ptr才能够进行赋值
        int num = node ->data;
        printf("[%d]\n",num);
    }


    //销毁智能指针(你也可以不销毁,因为智能指针自己非常懂事)
    n1.reset();
    n2.reset();
    n3.reset();

    return 0;
}
输出:
[1]
[2]
[3]

3)链表-普通cpp版



#include <iostream>

using namespace std;

struct Node{
    int data;
    Node* prior;
    Node* next;
};


int main()
{
    Node * n1 = new Node;
    Node * n2 = new Node;
    Node * n3 = new Node;
    n1->data = 1;
    n1->prior = nullptr;
    n1->next = n2;

    n2->data = 2;
    n2->prior = n1;
    n2->next = n3;

    n3->data = 3;
    n3->prior = n2;
    n3->next = nullptr;

    for(Node * node = n1 ; node != nullptr ; node = node->next){
        int num = node ->data;
        printf("[%d]\n",num);
    }


    //销毁智能指针
    delete n1;
    delete n2;
    delete n3;

    return 0;
}
输出:
[1]
[2]
[3]

15. 面试补充

1)网络的状态码:

以5开头的一般表示的服务器状态的异常

302:本次请求成功了,你还需要继续请求

好,为什么还需要继续请求?资源可能由于维护、更新或其他原因临时移动到了新的位置,你请求的资源现在临时存在于另外一个地址，请去那里请求。

2)cpu调度算法

先来先服务：这是最简单的调度算法。按照请求CPU的顺序进行调度。一个进程完全执行完后，下一个进程才开始执行。其主要缺点是“饥饿”（某些进程可能需要等待很长时间）和“凸轮”现象（较短的任务可能要等待一个长任务执行完毕）。
短作业优先（SJF，Shortest Job First）：这个算法选择预计运行时间最短的进程并先执行它。虽然这可以减少平均等待时间，但实际上很难知道进程的预计运行时间，而且长作业可能遭到饥饿。
最短剩余时间优先（SRTF，Shortest Remaining Time First）：这是SJF(短作业优先)的抢占式版本，如果新到的进程的预计剩余运行时间比当前正在运行的进程的剩余时间短，CPU将被分配给新进程。这种方法也面临着长作业饥饿的问题。
轮转调度（RR，Round Robin）：这是最常用的抢占式调度算法。它将时间分为固定长度的片段，按顺序将CPU分配给进程。如果一个进程在其时间片结束时还没有完成，它将被放回就绪队列的末尾。这种方法提高了响应时间，但如果时间片设置得不合理，可能导致CPU效率低下。比如说只给你10分钟享受这个资源,10分钟你还没办完,你就先下去,重新排队,让后面的进程来
优先级调度：在这个算法中，每个进程都被分配一个优先级。具有最高优先级的进程将首先获得CPU，相同优先级的进程可以采用FCFS或RR等其他调度算法进行调度。问题在于低优先级进程可能会遭受无限期的饥饿。
多级反馈队列（MFQ，Multilevel Feedback Queue）：(太难了,不要背这个),这是一种复杂的调度算法，旨在克服上述算法的缺点。在这种方法中，进程根据其属性（如CPU使用时间、进程优先级）被分配到不同的队列，并在这些队列之间根据其行为（如执行时间、等待时间）动态移动。这种方法试图平衡响应时间和CPU利用率。

1.虚拟内存是一个什么样的概念?当物理内存消耗殆尽时,我们还想拥有更多的内存,这个时候系统只能从其他地方给你找点空间来进行临时的替代,而硬盘就是这个临时空间.

比如你运行一下3A大型游戏,你电脑的运存不够大,这个时候就需要开辟一段虚拟内存来支持这个程序的运行

2.虚拟内存从哪里来的?

物理内存有内存条,虚拟内存:硬盘来的

4)数据库的事务有哪些?

事务是指一系列操作的集合,要么都成功,要么都失败.

比如去购物,消费者扣钱是一个操作,超市账户加入等量的钱是第二个操作.这两个操作,你要么都成功,要么都失败,你不可以出现"消费者扣了钱,但是超市账户那里没收到钱"这样的现象.

所以我们可以开启一个事务(start transaction[船然可胜];)将这两个步骤加入到一个事务中,要么都成功要么都失败.

我们还可以在这个事务中保存一些节点,来方便我们回滚到某些节点,最后确保都成功后,我们在commit进行提交.

5)七层网络模型和tcp网络模型你能说出来嘛?

6)git在版本管理中的分区是怎样的呢?

工作区(你在电脑上进行的一些增删改)、暂存区(git add)、本地仓库(git commit)和远程仓库(git push)

7)应用程序占用哪些端口咋么看?

回答了netstat | grep 8000,其实完整的话是:

netstat -tlnp | grep 8000