程序员经验分享-hwhale

集美大学 - 2840 - 实验11-2 - 函数题

2023-05-16

实验11-2-1 链表 建立学生信息链表

本题要求实现一个将输入的学生成绩组织成单向链表的简单函数。

函数接口定义：

void input();

该函数利用scanf从输入中获取学生的信息，并将其组织成单向链表。链表节点结构定义如下：

struct stud_node {
    int              num;      /*学号*/
    char             name[20]; /*姓名*/
    int              score;    /*成绩*/
    struct stud_node *next;    /*指向下个结点的指针*/
};

单向链表的头尾指针保存在全局变量head和tail中。

输入为若干个学生的信息（学号、姓名、成绩），当输入学号为0时结束。

裁判测试程序样例：

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

struct stud_node {
     int    num;
     char   name[20];
     int    score;
     struct stud_node *next;
};
struct stud_node *head, *tail;

void input();

int main()
{
    struct stud_node *p;
    
    head = tail = NULL;
    input();
    for ( p = head; p != NULL; p = p->next )
        printf("%d %s %d\n", p->num, p->name, p->score);

    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

1 zhang 78
2 wang 80
3 li 75
4 zhao 85
0

输出样例：

1 zhang 78
2 wang 80
3 li 75
4 zhao 85

void input() {
    struct stud_node *p;
    int num;
    scanf("%d", &num);
    while (num != 0) {
        p = (struct stud_node *) malloc(sizeof(struct stud_node));
        p->num = num;
        scanf("%s%d", p->name, &p->score);
        p->next = NULL;
        if (head == NULL) head = p;
        else tail->next = p;
        tail = p;
        scanf("%d", &num);
    }
}

实验11-2-2 链表 学生成绩链表处理

本题要求实现两个函数，一个将输入的学生成绩组织成单向链表；另一个将成绩低于某分数线的学生结点从链表中删除。

函数接口定义：

struct stud_node *createlist();
struct stud_node *deletelist( struct stud_node *head, int min_score );

函数createlist利用scanf从输入中获取学生的信息，将其组织成单向链表，并返回链表头指针。链表节点结构定义如下：

struct stud_node {
    int              num;      /*学号*/
    char             name[20]; /*姓名*/
    int              score;    /*成绩*/
    struct stud_node *next;    /*指向下个结点的指针*/
};

输入为若干个学生的信息（学号、姓名、成绩），当输入学号为0时结束。

函数deletelist从以head为头指针的链表中删除成绩低于min_score的学生，并返回结果链表的头指针。

裁判测试程序样例：

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

struct stud_node {
     int    num;
     char   name[20];
     int    score;
     struct stud_node *next;
};

struct stud_node *createlist();
struct stud_node *deletelist( struct stud_node *head, int min_score );

int main()
{
    int min_score;
    struct stud_node *p, *head = NULL;

    head = createlist();
    scanf("%d", &min_score);
    head = deletelist(head, min_score);
    for ( p = head; p != NULL; p = p->next )
        printf("%d %s %d\n", p->num, p->name, p->score);

    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

1 zhang 78
2 wang 80
3 li 75
4 zhao 85
0
80

输出样例：

2 wang 80
4 zhao 85

struct stud_node *createlist() {
    struct stud_node *head = NULL, *rear = head, *p;
    int num;
    scanf("%d", &num);
    while (num != 0) {
        p = (struct stud_node *) malloc(sizeof(struct stud_node));
        p->num = num;
        scanf("%s %d", p->name, &p->score);
        if (head == NULL) head = p;
        else rear->next = p;
        rear = p;
        p->next = NULL;
        scanf("%d", &num);
    }
    return head;
}

struct stud_node *deletelist(struct stud_node *head, int min_score) {
    struct stud_node *p = NULL, *q = NULL, *x = NULL, *y = NULL;
    if (head == NULL) return NULL;
    p = head;
    while (p->score < min_score) {
        p = p->next;
        if (p == NULL) return p;
    }
    head = p;
    q = p->next;
    if (q == NULL) return p;
    while (q != NULL) {
        if (q->score < min_score) {
            x = q;
            q = q->next;
            free(x);
            p->next = q;
        } else {
            p = q;
            q = p->next;
        }
    }
    return head;
}

实验11-2-3 链表 逆序数据建立链表

本题要求实现一个函数，按输入数据的逆序建立一个链表。

函数接口定义：

struct ListNode *createlist();

函数createlist利用scanf从输入中获取一系列正整数，当读到−1时表示输入结束。按输入数据的逆序建立一个链表，并返回链表头指针。链表节点结构定义如下：

struct ListNode {
    int data;
    struct ListNode *next;
};

裁判测试程序样例：

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

struct ListNode {
    int data;
    struct ListNode *next;
};

struct ListNode *createlist();

int main()
{
    struct ListNode *p, *head = NULL;

    head = createlist();
    for ( p = head; p != NULL; p = p->next )
        printf("%d ", p->data);
    printf("\n");

    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

1 2 3 4 5 6 7 -1

输出样例：

7 6 5 4 3 2 1 

struct ListNode *createlist() {
    struct ListNode *head = NULL, *p, *x;
    int num;
    scanf("%d", &num);
    if (num == -1) return NULL;
    while (num != -1) {
        p = (struct ListNode *) malloc(sizeof(struct ListNode));
        p->data = num;
        p->next = NULL;
        if (head == NULL) {
            head = p;
        } else {
            p->next = head;
            head = p;
        }
        scanf("%d", &num);
    }
    return head;
}

实验11-2-4 链表 删除单链表偶数节点

本题要求实现两个函数，分别将读入的数据存储为单链表、将链表中偶数值的结点删除。链表结点定义如下：

struct ListNode {
    int data;
    struct ListNode *next;
};

函数接口定义：

struct ListNode *createlist();
struct ListNode *deleteeven( struct ListNode *head );

函数createlist从标准输入读入一系列正整数，按照读入顺序建立单链表。当读到−1时表示输入结束，函数应返回指向单链表头结点的指针。

函数deleteeven将单链表head中偶数值的结点删除，返回结果链表的头指针。

裁判测试程序样例：

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

struct ListNode {
    int data;
    struct ListNode *next;
};

struct ListNode *createlist();
struct ListNode *deleteeven( struct ListNode *head );
void printlist( struct ListNode *head )
{
     struct ListNode *p = head;
     while (p) {
           printf("%d ", p->data);
           p = p->next;
     }
     printf("\n");
}

int main()
{
    struct ListNode *head;

    head = createlist();
    head = deleteeven(head);
    printlist(head);

    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

1 2 2 3 4 5 6 7 -1

输出样例：

1 3 5 7 

struct ListNode *createlist() {
    struct ListNode *head = NULL, *rear = head, *p;
    int num;
    scanf("%d", &num);
    if (num == -1) return NULL;
    while (num != -1) {
        p = (struct ListNode *) malloc(sizeof(struct ListNode));
        p->data = num;
        p->next = NULL;
        if (head == NULL) head = p;
        else rear->next = p;
        rear = p;
        scanf("%d", &num);
    }
    return head;
}

struct ListNode *deleteeven(struct ListNode *head) {
    struct ListNode *p, *q, *x;
    if (head == NULL) return NULL;
    while (head->data % 2 == 0) {
        head = head->next;
        if (head == NULL) return NULL;
    }

    p = head;
    q = p->next;
    while (q != NULL) {
        if ((q->data) % 2 == 0) {
            x = q;
            q = q->next;
            free(x);
            p->next = q;
        } else {
            p = q;
            q = p->next;
        }
    }
    return head;
}

实验11-2-5 链表 链表拼接

本题要求实现一个合并两个有序链表的简单函数。链表结点定义如下：

struct ListNode {
    int data;
    struct ListNode *next;
};

函数接口定义：

struct ListNode *mergelists(struct ListNode *list1, struct ListNode *list2);

其中list1和list2是用户传入的两个按data升序链接的链表的头指针；函数mergelists将两个链表合并成一个按data升序链接的链表，并返回结果链表的头指针。

裁判测试程序样例：

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

struct ListNode {
    int data;
    struct ListNode *next;
};

struct ListNode *createlist(); /*裁判实现，细节不表*/
struct ListNode *mergelists(struct ListNode *list1, struct ListNode *list2);
void printlist( struct ListNode *head )
{
     struct ListNode *p = head;
     while (p) {
           printf("%d ", p->data);
           p = p->next;
     }
     printf("\n");
}

int main()
{
    struct ListNode  *list1, *list2;

    list1 = createlist();
    list2 = createlist();
    list1 = mergelists(list1, list2);
    printlist(list1);
    
    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

1 3 5 7 -1
2 4 6 -1

输出样例：

1 2 3 4 5 6 7 

struct ListNode *mergelists(struct ListNode *list1, struct ListNode *list2) {
    struct ListNode *fuzhu, *p, *head;
    int i = 0, j, cnt = 0, a[1000] = {0}, e;
    if (list1 == NULL) return list2;
    head = list1;
    fuzhu = list1;
    while (fuzhu != NULL) {
        if (fuzhu->next == NULL) break;
        fuzhu = fuzhu->next;
    }
    fuzhu->next = list2;
    p = head;
    while (p != NULL) {
        a[i++] = p->data;
        cnt++;
        p = p->next;
    }
    for (i = 0; i < cnt; i++) {
        for (j = 1; j < cnt - i; j++) {
            if (a[j - 1] >= a[j]) {
                e = a[j];
                a[j] = a[j - 1];
                a[j - 1] = e;
            }
        }
    }
    i = 0;
    struct ListNode *head1 = NULL, *rear = head1;
    while (i < cnt) {
        p = (struct ListNode *) malloc(sizeof(struct ListNode));
        p->data = a[i++];
        if (head1 == NULL) head1 = p;
        else rear->next = p;
        rear = p;
        p->next = NULL;
    }
    return head1;
}

实验11-2-6 链表 奇数值结点链表

本题要求实现两个函数，分别将读入的数据存储为单链表、将链表中奇数值的结点重新组成一个新的链表。链表结点定义如下：

struct ListNode {
    int data;
    ListNode *next;
};

函数接口定义：

struct ListNode *readlist();
struct ListNode *getodd( struct ListNode **L );

函数readlist从标准输入读入一系列正整数，按照读入顺序建立单链表。当读到−1时表示输入结束，函数应返回指向单链表头结点的指针。

函数getodd将单链表L中奇数值的结点分离出来，重新组成一个新的链表。返回指向新链表头结点的指针，同时将L中存储的地址改为删除了奇数值结点后的链表的头结点地址（所以要传入L的指针）。

裁判测试程序样例：

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

struct ListNode {
    int data;
    struct ListNode *next;
};

struct ListNode *readlist();
struct ListNode *getodd( struct ListNode **L );
void printlist( struct ListNode *L )
{
     struct ListNode *p = L;
     while (p) {
           printf("%d ", p->data);
           p = p->next;
     }
     printf("\n");
}

int main()
{
    struct ListNode *L, *Odd;
    L = readlist();
    Odd = getodd(&L);
    printlist(Odd);
    printlist(L);

    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

1 2 2 3 4 5 6 7 -1

输出样例：

1 3 5 7 
2 2 4 6 

struct ListNode* readlist() {
    struct ListNode* head=NULL, * rear = head, * p;
    int num;
    scanf("%d", &num);
    while (num != -1) {
        p = (struct ListNode*)malloc(sizeof(struct ListNode));
        p->data = num;
        if (head == NULL) head = p;
        else rear->next = p;
        rear = p;
        rear->next = NULL;
        scanf("%d", &num);
    }
    return head;
}
struct ListNode* getodd(struct ListNode** L){
    struct ListNode* p, * str1, * str2, * head = NULL, * rear = head,*fuzhu,*q;
    str1 = *L;
    if (str1 == NULL) return NULL;
    while (str1->data%2!=0) {
        p = (struct ListNode *) malloc(sizeof(struct ListNode));
        p->data = str1->data;
        if (head == NULL) head = p;
        else rear->next = p;
        rear = p;
        rear->next = NULL;
        str1 = str1->next;
        if (str1 == NULL) {
            *L = NULL;
            return head;
        }
    }
    q = str1;
    str2 = str1->next;
    if (str2 == NULL) {
        *L = str1;
    }
    while (str2 != NULL) {
        if (str2->data % 2 != 0) {
            p = (struct ListNode *) malloc(sizeof(struct ListNode));
            p->data = str2->data;
            if (head == NULL) head = p;
            else rear->next = p;
            rear = p;
            rear->next = NULL;

            fuzhu = str2;
            str2 = str2->next;
            str1->next = str2;
            free(fuzhu);
        } else {
            str1 = str2;
            str2 = str2->next;
        }
    }
    *L = q;
    return head;
}

实验11-2-7 链表 统计专业人数

本题要求实现一个函数，统计学生学号链表中专业为计算机的学生人数。链表结点定义如下：

struct ListNode {
    char code[8];
    struct ListNode *next;
};

这里学生的学号共7位数字，其中第2、3位是专业编号。计算机专业的编号为02。

函数接口定义：

int countcs( struct ListNode *head );

其中head是用户传入的学生学号链表的头指针；函数countcs统计并返回head链表中专业为计算机的学生人数。

裁判测试程序样例：

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

struct ListNode {
    char code[8];
    struct ListNode *next;
};

struct ListNode *createlist(); /*裁判实现，细节不表*/
int countcs( struct ListNode *head );

int main()
{
    struct ListNode  *head;

    head = createlist();
    printf("%d\n", countcs(head));
    
    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

1021202
2022310
8102134
1030912
3110203
4021205
#

输出样例：

3

int countcs(struct ListNode *head) {
    int cnt = 0;
    struct ListNode *p = head;
    while (p != NULL) {
        if (p->code[1] == '0' && p->code[2] == '2') {
            cnt++;
        }
        p = p->next;
    }
    return cnt;
}

实验11-2-8 链表 单链表结点删除

本题要求实现两个函数，分别将读入的数据存储为单链表、将链表中所有存储了某给定值的结点删除。链表结点定义如下：

struct ListNode {
    int data;
    ListNode *next;
};

函数接口定义：

struct ListNode *readlist();
struct ListNode *deletem( struct ListNode *L, int m );

函数readlist从标准输入读入一系列正整数，按照读入顺序建立单链表。当读到−1时表示输入结束，函数应返回指向单链表头结点的指针。

函数deletem将单链表L中所有存储了m的结点删除。返回指向结果链表头结点的指针。

裁判测试程序样例：

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

struct ListNode {
    int data;
    struct ListNode *next;
};

struct ListNode *readlist();
struct ListNode *deletem( struct ListNode *L, int m );
void printlist( struct ListNode *L )
{
     struct ListNode *p = L;
     while (p) {
           printf("%d ", p->data);
           p = p->next;
     }
     printf("\n");
}

int main()
{
    int m;
    struct ListNode *L = readlist();
    scanf("%d", &m);
    L = deletem(L, m);
    printlist(L);

    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

10 11 10 12 10 -1
10

输出样例：

11 12 

struct ListNode *readlist() {
    struct ListNode *head = NULL, *rear = head, *p;
    int num;
    scanf("%d", &num);
    while (num != -1) {
        p = (struct ListNode *) malloc(sizeof(struct ListNode));
        p->data = num;
        if (head == NULL) head = p;
        else rear->next = p;
        rear = p;
        rear->next = NULL;
        scanf("%d", &num);
    }
    return head;
}

struct ListNode *deletem(struct ListNode *L, int m) {
    struct ListNode *str1, *str2, *p, *fuzhu;
    if (L == NULL) return L;
    str1 = L;
    while (str1->data == m) {
        str1 = str1->next;
        if (str1->next == NULL) return NULL;
    }
    p = str1;
    if (str1 == NULL) return str1;
    str2 = str1->next;
    if (str2 == NULL) return p;
    while (str2 != NULL) {
        if (str2->data == m) {
            fuzhu = str2;
            str2 = str2->next;
            free(fuzhu);
            str1->next = str2;
        } else {
            str1 = str2;
            str2 = str2->next;
        }
    }
    return p;
}

实验11-2-9 链表 链表逆置

本题要求实现一个函数，将给定单向链表逆置，即表头置为表尾，表尾置为表头。链表结点定义如下：

struct ListNode {
    int data;
    struct ListNode *next;
};

函数接口定义：

struct ListNode *reverse( struct ListNode *head );

其中head是用户传入的链表的头指针；函数reverse将链表head逆置，并返回结果链表的头指针。

裁判测试程序样例：

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

struct ListNode {
    int data;
    struct ListNode *next;
};

struct ListNode *createlist(); /*裁判实现，细节不表*/
struct ListNode *reverse( struct ListNode *head );
void printlist( struct ListNode *head )
{
     struct ListNode *p = head;
     while (p) {
           printf("%d ", p->data);
           p = p->next;
     }
     printf("\n");
}

int main()
{
    struct ListNode  *head;

    head = createlist();
    head = reverse(head);
    printlist(head);
    
    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

1 2 3 4 5 6 -1

输出样例：

6 5 4 3 2 1 

struct ListNode *reverse(struct ListNode *head) {
    struct ListNode *p, *head1 = NULL, *rear = head1;
    int i = 0, cnt = 0, a[1000] = {0};
    if (head == NULL) return NULL;
    while (head != NULL) {
        a[i++] = head->data;
        cnt++;
        head = head->next;
    }
    for (i = cnt - 1; i >= 0; i--) {
        p = (struct ListNode *) malloc(sizeof(struct ListNode));
        p->data = a[i];
        if (head1 == NULL) head1 = p;
        else rear->next = p;
        rear = p;
        rear->next = NULL;
    }
    return head1;
}
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

集美大学 - 2840 - 实验11-2 - 函数题 的相关文章

  • VSCode调试C++代码的多种方案

    以下内容均针对 Linux 操作系统 xff08 包括Windows的Linux子系统WSL2 xff09 本文是对Linux系统中使用VSCode编译调试C 43 43 代码的系列文章的总结 xff0c 前面三篇文章如下 xff1a 详解

  • 【ROS】rostopic常用命令

    记录ROS查看话题的常用命令 xff1a rostopic 查看节点列表 xff1a rostopic list 查看节点信息 xff0c 如相机节点的内参K矩阵 畸变D矩阵 分辨率等等 rostopic echo camera camer

  • 【ROS笔记】设置、修改ROS环境变量

    ROS设置环境变量 ROS安装到Ubuntu后 xff0c 默认在 opt路径下 xff0c 由于在使用过程中需要频繁在终端使用ROS命令 xff0c 需要对其环境变量进行设置 Ubuntu默认使用终端为bash xff0c 在bash中设

  • 【ROS笔记】工作空间(workspace)、功能包(package)的介绍及创建

    初接触ROS时 xff0c 对其文件结构容易产生困惑和混淆 xff0c 比如 catkin ws到底是什么 xff1f catkin ws src目录下存放的是什么 xff1f catkin ws src路径下怎么还会有其他的src 目录

  • RecyclerView中倒计时item的优雅方案

    本文介绍在RecyclerView中使用倒计时楼层 xff0c 并且每秒刷新显示倒计时 没有纠结于样式 xff0c 主要介绍代码结构和设计模式 先看一下效果 xff1a 我们采取的是观察者模式的方法 xff0c 启动一个handler xf

  • bluerov

    ov这个东西其实不难 xff0c 比较麻烦的是密封 xff0c 防水等工作 xff0c 而非一些技术性工作 xff08 所谓技术性工作就是算法 xff0c 人工智能等 xff09 现在供玩家玩的Rov xff0c 基本模式是这样的 xff0

  • 在线教程 | 用「网红项目」DeepSOCIAL 进行社交距离监测

    首发自 xff1a 公众号 HyperAI超神经 内容一览 xff1a YOLO v4 是一个实时的 高精度的目标检测模型 xff0c 本教程将详细讲解如何基于 YOLO v4 和 SORT 算法 xff0c 实现在多目标条件下的人群距离检

  • C#实现服务端/客户端的tcp异步通信完整示例

    demo 通过一个简单的demo xff0c 实现服务器和客户端之间的tcp异步通信 消息进行了Des加密和解密 运行动图如下 xff1a 图中有三个程序在运行 xff0c 最左边是服务端 xff0c 另外两个是客户端 xff0c 客户端可

  • C++封装HTTP

    C 43 43 封装HTTP Client 简介HTTP请求头封装HTTP请求头基本格式post请求头封装post请求头 HTTP Client 以及HTTP Server交互HTTP消息解析TCP封装HTTP Client的坑 Trans

  • android 自定义多功能进度条

    自定义进度条 xff0c 直接在布局文件里传入颜色值 xff0c 不用自己再去写样式 xff0c 还可以 效果图 xff1a git地址

  • 树莓派L298N电机驱动程序连接图文教程

    手里有一块树莓派3闲置很久 xff0c 不知干点啥好呢 看到不少网友用树莓派做智能小车 xff0c 好像很好玩的酱紫 xff0c 就到淘宝买了一些配件 对于硬件小白的我来说安装过程并不轻松 xff0c 网上看了很多资料但有的地方介绍的并不很

  • 一个比较好用的socket 类封装(封装http 请求)

    name myhttp h function http 请求 copyright author mark date 2008 05 13 ifndef MY HTTP INCLUDE define MY HTTP INCLUDE inclu

  • Odroid U3 烧写镜像文件

    在Ubuntu下往Odroid U3板子的eMMC卡里烧写xubuntu镜像文件 xff0c 主要步骤如下 xff1a 1 下载要烧写的镜像文件 xff0c 按照需要 xff0c 我下载的是桌面版的xubuntu 13 04 desktop

  • 解决odroid-XU3的HDMI输出问题

    odroid XU3的板子直接通过microHDMI口连接显示器 xff0c 并没有显示 解决方法是修改 media boot boot ini文件 xff0c 取消屏蔽与HDMI设置相关语句 重启之后 xff0c 解决问题 由于不同的显示

  • 现有的 TypeRef 应有对应的 TypeDef(Impl)，但它没有

    现有的 TypeRef 应有对应的 TypeDef Impl xff0c 但它没有 本人需要在C 中调用C 43 43 代码 xff0c 故而建立了一个CLR项目 xff0c 建立了四个文件 xff0c 分别是两个纯C 43 43 文件 C

  • [zed2i] 相机内参数获取

    内置对应的程序 xff1a 双目SDK校正方法 关灯避免反射 xff0c 使得房间的灯光尽可能的黑 xff0c 拿着相机对准屏幕的标定板 xff08 可以不关灯 xff09 开始校正 xff0c 红圈是目标 xff0c 需要移动蓝圈 xff

  • Unity 2D独立开发手记（八）：基于A*算法的简易寻路

    被生活 43 43 了一个多月 xff0c 都没时间上来吹比了 因为破游戏准备设计敌人了 xff0c 苦于Unity自带的导航系统迟迟不适配2D项目 xff0c 即便用最新的NavMeshSurface把3D当成2D来用 xff0c 也和我

  • 新建keil工程每一个文件夹的作用

    问 xff1a 头文件stm32f10x sdio c的作用 xff1f 有时候在添加路径的时候为什么不添加src xff1f 有些工程里就添加了 新建工程的每一个文件夹的作用 core xff0c obj xff0c STM32 FWLI

  • VScode使用时常见问题

    写在篇首 xff0c vscode各种蜜汁bug xff0c 记录一下解决方案供大家参考 1 无法使用C 43 43 万能头文件 include xff1c bits stdc 43 43 h xff1e 解决方案 在刷题的时候 xff0c

  • Socket网络编程总结

    网络中进程之间如何通信 Java最初是作为网络编程语言出现的 xff0c 其对网络提供了高度的支持 xff0c 使得客户端和服务器的沟通变成了现实 xff0c 而在网络编程中 xff0c 使用最多的就是Socket 像大家熟悉的QQ MSN

随机推荐

热门标签