C++笔试

大三寒假之前

第一次投递 CVTE，稀烂。

智能指针，父子析构函数，volatile，继承与虚函数

希尔排序，选择排序，插入排序，冒泡排序，用数组和链表的效率比较

2022/3/2 宝融科技

总的来说比上次好，背的C++八股文有点用，Linux也有点用，线程进程编程重点

已知：int m=10;下列表示引用的方法中，哪个是在正确的
A:int &x=m;
B:int &y=10;
C:int &z;
D:int &t=&m;
extern "C"：实现C++和C的混合编程

substr strstr sprint memcpy哪个不可以啥字符串赋值

三个线程 ，id分别是ABC，各自打印十次，要求顺序输出ABCABCABC。。。。。。。

2022/3/3 同讯科技

交了一份C语言实现红黑树小任务

花了两三天时间研究了下，发现是比以前做的平衡二叉树难多了，主要是插入和删除情况，红黑树它不一样。

不能是那种，先插入或者删除，然后调用一个平衡函数维护红黑树。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct RBTreeNode {
    int data; //数据域
    int color; //0黑色 1红色
    struct RBTreeNode *parent;//父亲结点
    struct RBTreeNode *left;  //左子结点
    struct RBTreeNode *right; //右子结点
} RBTreeNode;
RBTreeNode *RBTreeEndNode;
void search(RBTreeNode *root,int target){
    if (root == NULL)
        return ;
    if(target == root->data){
        printf("找到%d了，color:%d\n",root->data,root->color);
        return;
    }
    if(target < root->data)
        search(root->left,target);
    if(target > root->data)
        search(root->right,target);
    return ;
}
void preOrderTraverse(RBTreeNode *root){
    if (root == NULL)
        return ;
    if (root->parent != NULL)
        printf("%d color: %d parent:%d\n", root->data, root->color, root->parent->data);
    else
        printf("%d color: %d\n", root->data, root->color);     
    preOrderTraverse(root->left);
    preOrderTraverse(root->right);
}
RBTreeNode *left_rotation(RBTreeNode *root){
    //处理新根节点
    RBTreeNode *new_root = root->right;
    //处理新根父母
    new_root->parent = root->parent;
    if (root->parent != NULL){
        //判断父亲左右
        if (new_root->parent->left == root)
            new_root->parent->left = new_root;
        else
            new_root->parent->right = new_root;
    }
    //移走新根左节点
    root->right = new_root->left;
    if (new_root->left != NULL)new_root->left->parent = root;
    //新加新根左节点
    new_root->left = root;
    root->parent = new_root;

    return new_root;
}
RBTreeNode *right_rotation(RBTreeNode *root){
    //处理新根节点
    RBTreeNode *new_root = root->left;
    //处理新根父母
    new_root->parent = root->parent;
    if (root->parent != NULL){
        //判断父亲左右
        if (new_root->parent->left == root)
        {
            new_root->parent->left = new_root;
        }else{
            new_root->parent->right = new_root;
        }
    }
    //移走新根右节点
    root->left = new_root->right;
    if (new_root->right != NULL)new_root->right->parent = root;
    //新加新根右节点
    new_root->right   = root;
    root->parent = new_root;
    return new_root;
}
RBTreeNode *insert(RBTreeNode *root, int data, RBTreeNode *parent){
    if (NULL == root){
        RBTreeNode *node = (RBTreeNode *)malloc(sizeof(RBTreeNode));
        if (node == NULL){
            printf("malloc error \n");
            return NULL;
        }
        node->data  = data;
        node->parent= parent;
        node->color = 1;
        node->right = NULL;
        node->left  = NULL;
        RBTreeEndNode = node;
        return node;
    }
    if (data > root->data)
        root->right  = insert(root->right, data, root);
    else
        root->left   = insert(root->left, data, root);
    return root;
}
RBTreeNode *rebalance3(RBTreeNode *root, RBTreeNode *rootNode){//要放在insertRB之前
    //1 新节点在根节点
    if (root->parent == NULL){
        root->color = 0;
        return root;
    }
    //2 有父节点  
    //2.1 父节点是黑色，啥也不用干
    if (root->parent->color != 0){
    //2.2 父节点是红色,祖父一定是黑色啦，看叔叔是啥颜色
        RBTreeNode *parent, *gparent, *uncle;
        parent = root->parent;
        gparent = root->parent->parent;
        //先判断父节点是祖父节点的左节点还是右节点，即叔叔节点是啥
        //2.2.1 父节点是祖父节点的左节点
        if (parent == gparent->left){
            uncle = gparent->right;
            //2.2.1.1如果叔叔也是红色
            if (uncle != NULL && uncle->color == 1){
                parent->color = 0;
                uncle->color = 0;
                gparent->color = 1;
                
                return rebalance3(gparent, rootNode);
            }else{
            //2.2.1.2如果叔叔黑色 或不存在
                //2.2.1.2.1 root是左节点
                if (root == parent->left){
                    parent->color = 0;
                    gparent->color = 1;
                    gparent = right_rotation(gparent);
                }else{
                //2.2.1.2.2 root是右节点
                    //1.root与父节点交换 并把父节点设为新root的左节点,即转化为2.2.1.2.1
                    gparent->left = root;                       
                    root->parent = gparent;
                    root->left = parent;
                    parent->parent = root;
                    parent->right = NULL;
                    return rebalance3(parent, rootNode);
                }
            }
        }else{
        //2.2.2 父节点是祖父节点的右节点
            uncle = gparent->left;
            //2.2.2.1如果叔叔也是红色
            if (uncle != NULL && uncle->color == 1){
                parent->color = 0;
                uncle->color = 0;
                gparent->color = 1;
                return rebalance3(gparent, rootNode);
            }else{
            //2.2.2.2如果叔叔黑色 或不存在
                //2.2.2.2.1 root是左节点
                if (root == parent->left){
                    //1.root与父节点交换 并把父节点设为新root的左节点,即转化为2.2.2.2.2
                    gparent->right = root;
                    root->parent = gparent;
                    root->right = parent;
                    parent->parent = root;   
                    parent->left = NULL;
                    return rebalance3(parent, rootNode);
                }else{
                //2.2.2.2.2 root是右节点                        
                    parent->color = 0;
                    gparent->color = 1;
                    gparent = left_rotation(gparent);
                }
            }
        }
    }
    return rootNode;
}
RBTreeNode *inserRB(RBTreeNode *root, int data, RBTreeNode *parent){
    root = insert(root,data,parent);
    return rebalance3(RBTreeEndNode,root);
} 
RBTreeNode *FindMin(RBTreeNode *root)
{
    if (root == NULL||root->left ==NULL)
        return root;
    return FindMin(root->left);
}
RBTreeNode *Delete(RBTreeNode *root, int target, RBTreeNode *rootNode)
{
    if (root == NULL)
        return NULL;
    if (target > root->data)
        rootNode = Delete(root->right, target, rootNode);
    else if(target < root->data)
        rootNode  = Delete(root->left, target, rootNode);
    else if(target == root->data){  
        printf("%d删除成功！",target);      
        //删除根节点
        if (root->parent == NULL){
            free(root);
            root = NULL;
            return root;
        }
        RBTreeNode *parent, *brother;
        parent = root->parent;
        //1.没有左右节点
        if (root->left == NULL && root->right == NULL){
            //1.1被删除节点是红色，直接删除即可
            if (root->color == 1){
                if (root == parent->left){
                    parent->left = NULL;
                }else{
                    parent->right = NULL;
                }
                free(root);
                root = NULL;//删除自身
            }else{
            //1.2被删除节点是黑色，一定有兄弟节点 破坏了平衡性 需要重新平衡
                //1.2.1被删除节点在父节点的左数上
                if (root == parent->left){
                    free(root);
                    root = NULL;
                    parent->left = NULL;//删除自身
                    brother = parent->right;
                    //1.2.1.1兄弟节点是黑色
                    if (brother->color == 0){
                        //1.2.1.1.1 兄弟节点是黑色,且有一个右节点，右节点必然是红色
                        if (brother->right != NULL && brother->left == NULL){
                            brother->right->color = parent->color;
                            parent = left_rotation(parent);
                        }else if (brother->right == NULL && brother->left != NULL){
                            //1.2.1.1.2 兄弟节点是黑色,且有一个左节点，左节点必然是红色
                            brother->color = parent->color;
                            parent->right  = brother->left;

                            brother->parent = brother->left;
                            
                            brother->left->parent = parent;
                            brother->left->right  = brother;
                            brother->left   = NULL;

                            parent = left_rotation(parent);
                        }else if (brother->right != NULL && brother->left != NULL){
                        //1.2.1.1.3 兄弟节点是黑色,且有俩节点，必然都是红色
                            brother->color = parent->color;
                            brother->right->color = 0;
                            parent->color = 0;

                            parent = left_rotation(parent);
                        }else{
                        //1.2.1.1.4 兄弟节点是黑色,且没有节点 黑色路径必然要-1了 递归
                            parent->right->color = 1;
                            return rebalance3(parent->right,rootNode);
                        }
                    }else{
                    //1.2.1.2兄弟节点是红色，父节点一定是黑色，它一定有俩黑色子节点
                        //兄弟节点置黑,兄弟左节点置红
                        brother->color = 0;
                        brother->left->color  = 1;
                        parent = left_rotation(parent);
                    }
                }else{
                //1.2.2被删除节点在父节点的右数上
                    free(root);
                    root = NULL;
                    parent->right = NULL;//删除自身
                    brother = parent->left;
                    //1.2.2.1 兄弟节点是黑色
                    if (brother->color == 0){
                        //1.2.2.1.1 兄弟节点是黑色,且有一个左节点，左节点必然是红色 跟1.2.1.1.1是镜像关系
                        if (brother->right == NULL && brother->left != NULL){
                            //把父亲颜色赋值给兄弟节点的左节点
                            brother->left->color = parent->color;
                            parent = right_rotation(parent);
                        
                        }else if(brother->right != NULL && brother->left == NULL){
                            //1.2.2.1.2 兄弟节点是黑色,且有一个右节点，右节点必然是红色 跟1.2.1.1.2是镜像关系
                            parent->left = brother->right;                          
                            brother->color = parent->color;
                            brother->parent = brother->right;

                            brother->right->parent = parent;
                            brother->right->left   = brother;
                            brother->right  = NULL;
                            parent = right_rotation(parent);
                        }else if(brother->right != NULL && brother->left != NULL){
                            //1.2.2.1.3 兄弟节点是黑色,且有俩节点，必然都是红色 跟1.2.1.1.3是镜像关系
                            brother->left->color = 0;                          
                            brother->color = parent->color;
                            parent = right_rotation(parent);
                        }else{
                            //1.2.2.1.4 兄弟节点是黑色,且没有节点 黑色路径必然要-1了 递归
                            parent->left->color = 1;
                            return rebalance3(parent->left,rootNode);
                        }  
                    }else{
                        //1.2.2.2兄弟节点是红色，父节点一定是黑色，它一定有俩黑色子节点
                        //兄弟节点置黑,兄弟右节点置红
                        brother->color = 0;
                        brother->right->color  = 1;
                        parent = right_rotation(parent);
                    }
                }
            }
        }else if (root->left != NULL && root->right == NULL){
            //2.只有左节点 该左节点必然是红色，那root一定是黑色,root值替换为左节点的值，删除左节点
            root->data = root->left->data;
            free(root->left);
            root->left  = NULL;
        }else if (root->right != NULL && root->left == NULL){
            //3.只有右节点 该右节点必然是红色，那root一定是黑色,root值替换为右节点的值，删除右节点
            root->data = root->right->data;
            free(root->right);
            root->right  = NULL;
        }else{
        //4.左右都有的情况，选取后继节点
            RBTreeNode *min = FindMin(root->right);
            root->data = min->data;
            rootNode  = Delete(min, min->data, rootNode);
        }
    }
    
    return rootNode;
}

int main(){ 
    struct RBTreeNode *node = NULL;
    node = inserRB(node, 8, NULL);
    node = inserRB(node, 4, NULL);
    node = inserRB(node, 12, NULL);
    node = inserRB(node, 2, NULL);
    node = inserRB(node, 1, NULL);
    node = inserRB(node, 1, NULL);
    while(1){
        char operation[10000];
        int data;
        scanf("%s",operation);
        if(strcmp(operation, "quit") == 0)
            return 0;
        else if(strcmp(operation, "foreach") == 0)
            preOrderTraverse(node);
        else if(strcmp(operation, "search") == 0){
            scanf("%d",&data);
            search(node,data);
        }    
        else if(strcmp(operation, "add") == 0){
            scanf("%d",&data);
            node = inserRB(node, data, NULL);
        }
        else if(strcmp(operation, "del") == 0){
            scanf("%d",&data);
            node = Delete(node, data, node);
        }else{
            printf("你输入的格式有误，请重新输入。参考如下：\nadd 1\ndel 1\n foreach\nsearch 1\n quit\n");
        }
    }
    
    preOrderTraverse(node);
}

2022/3/4 美团 练习题

保留两位小数

#include<iostream>
#include<iomanip>
using namespace std;
int main()
{
    double a=3.14159265358;                    
   
    //加入setprecision(n)  设置浮点数有效数字 
    cout<<setprecision(3)<<a<<endl;        //将精度改为3（即有效数字三位） 输出3.14                        
   
    //加入setiosflags(ios::fixed)   设置浮点数以固定的小数位数显示
    cout<<setiosflags(ios::fixed)<<setprecision(2)<<a<<endl;    
    //控制精度为小数位  setprecision(3)即保留小数点2位    输出3.14 
    cout<<a<<endl;                //fixed和setprecision的作用还在，依然显示3.14
            
    return 0;
}

2022/3/5 美团笔试

第一道很简单，sort排序完一个for就解决了

#include<iostream>
#include<algorithm>
using namespace std;
int main(){
    int n;
    cin>>n;
    int a[n];
    int dp[n][2]={0};
    for(int i=0;i<n;i++){
        cin>>a[i];
        dp[i][1] = 1;
    }
    sort(a,a+n);//可打乱顺序的自己排序
    dp[0][0] = a[0];
    for(int i=1;i<n;i++){
        if(a[i]-dp[i-1][0]>1){
            dp[i][0] = a[i];
            dp[i][1] = dp[i-1][1]+1;
        }else{
            dp[i][0] = dp[i-1][0];
            dp[i][1] = dp[i-1][1];
        }
        
    }
    cout<<dp[n-1][1]<<endl;
    return 0;
}

第二道最大子段和，可翻转部分子数组，负数情况没处理好，91%。

#include<iostream>//i之前顺序，i之后逆序可翻。取和
#include<algorithm>
#include<math.h>
using namespace std;//9 -2 1 -3 4 -1 2 1 -5 4
int main(){// 6 -1 3 -5 2 -1 3
    int n;
    cin>>n;
    int a[n];
    for(int i=0;i<n;i++){
        cin>>a[i];
    }
    int dp[n]={0};
    int sum = 0;
      for(int i=0;i<n;i++){
          sum+=a[i];
        dp[i] = sum;
        sum = max(sum,0);
    }
    for(int i=0;i<n;i++)
        cout<<dp[i]<<" ";cout<<endl;
    int rdp[n] = {0};
    int rsum = 0;
    for(int i=n-1;i>=0;i--){
        rsum+=a[i];
        rdp[i] = rsum;
        rsum = max(rsum,0);
    }
    for(int i=0;i<n;i++)
        cout<<rdp[i]<<" ";cout<<endl;
    for(int i=n-1;i>=0;i--){//右边翻转数组的数如果小于0就不要了
        rdp[i] = max(rdp[i],0); 
    }
    for(int i=n-2;i>=0;i--){
        rdp[i] = max(rdp[i],rdp[i+1]); 
    }
    for(int i=0;i<n;i++)
        cout<<rdp[i]<<" ";cout<<endl;
    int result = a[0];
    for(int i=0;i<n-1;i++){
        result = max(result,dp[i]+rdp[i]);
    }
    cout<<result<<endl;
    return 0;
}

第三道空间几何切豆腐

第四道区间操作题，原数组和任意排序，多次查询和增加区间内的值，查询到的结果求和，要求和最大

2022/3/7 同讯科技

说我红黑树写的还行，然后笔试

一、单选

1、以下不属于socket的类型的是（ D ）
A 流式套接字
B 数据报套接字
C 网络套接字
D 原始套接字

2、如果进程A调用fork函数，创建进程B，然后进程B在调用fork函数，创建进程C，进程C调用exec执行新的程序，那么各个进程以什么顺序来执行：（ D ）。
A 以A、B、C的顺序执行
B 以C、B、A的顺序执行
C 以B、C、A的顺序执行
D 无固定执行顺序

3、内核的编译主要步骤不包括下面哪项( D )
A 内核配置
B 加载内核
C 建立内核
D 建立依存关系

4、以太头部大小 为（ ）byte，其实中目的MAC 的长度为（ ） byte.（ A  ）
A 14  6 
B 16  6 
C 24  6
D 14  8

5、数据库操作中，以下哪种操作能够实现实体完整性（D  ）
A 设置唯一键
B 设置外键
C 减少数据冗余
D 设置主键

6、下面的程序，在Ubuntu PC的terminal运行，打印几个hello_( A  )
main(){
       fork();
       printf("hello\n");
       fork();    
       printf("hello\n");
       while(1);
}
A 6
B 4
C 2
D 8
7、下面这个程序，三次打印的data分别是（ C  ）。
int data = 10;
int child_process()
{
        printf("Child process %d, data%d\n",getpid(),data);
        data = 30;
        printf("Child process %d, data%d\n",getpid(),data);
        _exit(0);
}
int main(int argc,char* argv[]){
        if(vfork()==0) {
                child_process();    
        }
        else{
                sleep(1);
                printf("Parent process %d,data %d\n",getpid(), data);
        }
}
A 10, 10,10
B 10, 30,30
C 10, 30,10
D 10, 10,30
8、MAC地址为01:80:C2:00:00:01,  该MAC地址类型为（ C  ）
A. 单播    B.组播    C.广播    D.任播

二、判断
1、可以使用signal()来给同一进程组中的所有进程发送信号。（对  ）
2、从一个空FIFO中读取数据时会发生阻塞，但从一个空PIPE中读取数据时不会发生阻塞。（  错）
3、路由器负责转发分组，但不知道转发的是UDP报文还是TCP报文。(   错 )
4、同一台机器上分别使用UDP和TCP通信的两个进程不能分配数值相同的端口号。（对  ）
5、在流式套接字编程中，客户端建立连接用的套接字不必调用bind()函数绑定本地IP地址和端口号，系统会自动为其分配。（ 错  ）
6、用于接收广播数据时，数据报套接字可不必绑定本地地址。（ 错  ）



三、填空题
1、标准以太网MTU 大小为（  1500   ）。 
2、你家的路由器如果是PPPoe拨号接入运营商，路由器上的MTU应该设置为（    1500   ）。
3、最大VLAN ID 是（  255.255.255.255   ）。
4、交换机端口 （port link-type） 常用的两种类型是（     trunk     ） 和 （    access   ）。

四、简答
1、某人想要访问淘宝,他在其浏览器中输入http://www.taobao.com并按回车，直到进入淘宝首页，问：在此过程中，按照TCP/IP参考模型，从应用层到网络层都用到了哪些协议？这些协议在这里的任务是什么？
DNS协议，解析url地址得到IP地址，
TCP/IP协议，三次握手建立连接，
Http协议，发送超文本格式数据









五、编程设计（头文件可忽略）
1、编写一个TCP并发服务器端程序，可以把客户端发来的消息回射给客户端。
Socket sk = new Socket();
sk.bind(IPAddress,port);
Listen(sk);
While(1){
accept(sk);
Recv(sk）；
Send(sk,”hello”);
Close(sk);
}

计网考的多，稀里糊涂的哈哈。应该是红黑树看代码能力，然后接下来笔试看计算机基础。