首页 > 编程语言 >Day5网络编程：epoll+服务器模型+ftp

Day5网络编程：epoll+服务器模型+ftp

时间：2024-09-10 18:49:53浏览次数：12  
标签：ftp epoll int Day5 描述符 acceptfd sockfd include buf

1.io多路复用：epoll

epoll的提出--》它所支持的文件描述符上限是系统可以最大打开的文件的数目；

eg：1GB机器上，这个上限10万个左右。

每个fd上面有callback(回调函数)函数，只有产生事件的fd才有主动调用callback，不需要轮询。

注意：

Epoll处理高并发，百万级

1. 红黑树： 是特殊的二叉树(每个节点带有属性)，Epoll怎样能监听很多个呢？首先创建树的根节点，每个节点都是一个fd以结构体的形式存储（节点里面包含了一些属性，callback函数）

2. 就绪链表： 当某一个文件描述符产生事件后，会自动调用callback函数，通过回调callback函数来找到链表对应的事件（读时间还是写事件)。

1.特点

1.监听的文件描述符没有限制

2.异步io，epoll当有事件唤醒之后，发生事件的文件描述符会主动的调用callback回调函数，拿到对应的文件描述符。不需要轮询，效率高

3.epoll不需要构造表，只需要从用户空间拷贝到内核空间一次

2.编程步骤

1.创建红黑树和就绪链表epoll_create

2.将关心的文件描述符和事件上树epoll_ctl

3.阻塞等待事件产生，一旦产生事件，则会进行处理epoll_wait

4.根据链表中准备好的文件描述符进行处理

3.函数接口

epoll_create（intsize）

功能：创建红黑树根节点（创建epoll实例），同时也会创建就绪列表

返回值：成功时返回一个实例epfd（二叉树句柄），失败时返回-1.

epoll_ctrl(int epfd, int op, int fd, struct epoll_event *event);

功能：控制epoll属性,比如给红黑树添加节点

参数: 1. epfd: epoll_create函数的返回句柄。//一个标识符

2. op:表示动作类型,有三个宏:

EPOLL_CTL_ADD：注册新的fd到epfd中

EPOLL_CTL_MOD：修改已注册fd的监听事件

EPOLL_CTL_DEL：从epfd中删除一个fd

3. 要操作的文件描述符

4. 结构体信息:

typedef union epoll_data {

int fd; //要添加的文件描述符

uint32_t u32; typedef unsigned int

uint64_t u64; typedef unsigned long int

} epoll_data_t;

struct epoll_event {

uint32_t events； 事件

epoll_data_t data； //共用体(看上面)

};

关于events事件:

EPOLLIN: 表示对应文件描述符可读

EPOLLOUT: 可写

EPOLLPRI：有紧急数据可读；

EPOLLERR：错误；

EPOLLHUP：被挂断；

EPOLLET：触发方式，边缘触发；(默认使用边缘触发)

ET模式：表示状态的变化；

NULL: 删除一个文件描述符使用,无事件

返回值：成功:0， 失败:-1

int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);

功能：等待事件产生

内核会查找红黑树中有事件响应的文件描述符, 并将这些文件描述符放入就绪链表

就绪链表中的内容, 执行epoll_wait会同时复制到第二个参数events

参数: epfd:句柄；

events：用来保存从就绪链表中响应事件的集合；

maxevents: 表示每次在链表中拿取响应事件的个数；

timeout：超时时间，毫秒，0立即返回 ，-1阻塞

返回值: 成功: 实际从链表中拿出的文件描述符数目 失败时返回-1

4.总结

selectpollepoll
监听个数一个进程最多监听1024个文件描述符由程序员决定百万级
方式每次都需要被唤醒，都需要重新轮询每次都需要被唤醒，都需要重新轮询红黑树内callback自动回调，不需要轮询
效率文件描述符越多，轮询越多，效率越低文件描述符越多，轮询也就越多，效率低不需要轮询，效率高
原理

每次使用select后，都会清空表

每次调用select，都需要拷贝用户空间的表到内核空间

内核空间负责轮询监视表内的文件描述符，将发生事件的文件描述符拷贝到用户空间，再次调用select，如此循环

不会清空结构体数组

每次调用poll，都需要拷贝用户空间的结构体到内核空间

内核空间负责轮询监视结构体数组内的文件描述符，将发生事件的文件描述符拷贝到用户空间，再次调用poll，如此循环

不会清空表

epoll中每个fd只会从用户空间到内核空间只拷贝一次（上树时）

通过epoll_ctl将文件描述符交给内核监管，一旦fd就绪，内核就会采用callback的回调机制来激活该fd，epoll_wait便可以收到通知（内核空间到用户空间的拷贝

特点
  1. 一个进程最多能监听1024个文件描述符
  2. select每次被唤醒，都要重新轮询表，效率低
  3. select每次都清空未发生相应的文件描述符，每次都要拷贝用户空间的表到内核空间
  1. 优化文件描述符的个数限制
  2. poll每次被唤醒，都要重新轮询，效率比较低（耗费cpu）
  3. poll不需要构造文件描述符表（也不需要清空表），采用结构体数组，每次也需要从用户空间拷贝到内核空间
  1. 监听的文件描述符没有个数限制（取决于自己的系统）
  2. 异步IO，epoll当有事件产生被唤醒，文件描述符会主动调用callback函数拿到唤醒的文件描述符，不需要轮询，效率高
  3. epoll不需要构造文件描述符的表，只需要从用户空间拷贝到内核空间一次。
结构

文件描述符表（位表）

结构体数组

红黑树和就绪链表

开发复杂度低低中

2.服务器模型

在网络通信中，通常一个服务器要连接多个客户端

为了处理多个客户端的请求，通常有多种表现形式

1.循环服务器：一个服务器在同一时间只能处理一个客户端的请求

tcp进程：

1.创建套接字socket

2.指定网络信息（服务器的）

3.绑定套接字bind

4.监听套接字listen

while（1）

{

5.接收客户端的连接请求

while（1）

{

接收发送数据

}

关闭套接字

}
 

2.并发服务器：一个服务器在同一时间可以处理多个客户端的请求

2.1多进程：每有一个客户端连接创建一个进程进行通信

为什么要创建进程-------->通信

什么时间创建进程--------->accept之后fork

子进程;通信

父进程;循环等待下一个客户端连接

进程资源回收------->子进程退出-------》客户端退出

wait();  waitpid();

SIGCHLD:当子进程退出给父进程发的信号

#include <stdio.h>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/wait.h>

void handler(int sig)
{
    wait(NULL);
}

int main(int argc, char const *argv[])
{
    pid_t pid;
    char buf[128] = {0};
    int ret, acceptfd;
    // 1.创建套接字（socket）---------------》有手机
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket err");
        return -1;
    }
    printf("sockfd:%d\n", sockfd); // 3
    // 2.指定网络信息---------------------------》有号码
    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;            // IPV4
    saddr.sin_port = htons(atoi(argv[1])); // 端口号
    // saddr.sin_addr.s_addr = inet_addr("192.168.50.13"); // 虚拟机IP
    // saddr.sin_addr.s_addr = inet_addr("0.0.0.0");
    saddr.sin_addr.s_addr = INADDR_ANY;
    int len = sizeof(caddr);
    // 3.绑定套接字（bind）------------------》绑定手机（插卡）
    if (bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
    {
        perror("bind err");
        return -1;
    }
    printf("bind ok\n");
    // 4.监听套接字（listen）-----------------》待机
    if (listen(sockfd, 6) < 0)
    {
        perror("listen err");
        return -1;
    }
    printf("listen ok\n");
    // 5.接收客户端连接连接请求（accept）--》接电话
    // tcp服务器一共有两类文件描述符,一类用于连接,一类用于通信
    // socket函数返回值:用于连接的文件描述符
    // accept函数返回值:用于通信的文件描述符
    signal(SIGCHLD, handler);//设置信号处理方式
    while (1)
    {
        acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &len);
        if (acceptfd < 0)
        {
            perror("accept err");
            return -1;
        }
        printf("port:%d ip:%s\n", ntohs(caddr.sin_port), inet_ntoa(caddr.sin_addr));
        printf("acceptfd:%d\n", acceptfd);
        pid = fork();
        if (pid < 0)
        {
            perror("fork err");
            return -1;
        }
        else if (pid == 0)
        {
            // 6.接收、发送数据（recv send）---》通话
            while (1)
            {
                // read/write()
                ret = recv(acceptfd, buf, sizeof(buf), 0);
                if (ret < 0)
                {
                    perror("recv err");
                    break;
                }
                else if (ret == 0)
                {
                    printf("client exit\n");
                    break;
                }
                else
                {
                    printf("buf:%s\n", buf);
                    memset(buf, 0, sizeof(buf));
                }
            }
            // 7.关闭套接字（close）-----------------》挂电话
            close(acceptfd);
            exit(0);
        }
        else
            close(acceptfd);
    }

    close(sockfd);

    return 0;
}

2.2多线程：每一个客户端连接创建一个线程进行通信

为什么要创建线程：通信

什么时候创建线程，acceot之后pthread_create

子线程：通信

主线程：循环等待下一个客户端连接

通信的文件描述符：线程传参

#include <stdio.h>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
#include <stdlib.h>
#include <pthread.h>

void *handler(void *arg)
{
    int ret, acceptfd;
    acceptfd = *((int *)arg);
    char buf[128] = {0};
    // 6.接收、发送数据（recv send）---》通话
    while (1)
    {
        // read/write()
        ret = recv(acceptfd, buf, sizeof(buf), 0);
        if (ret < 0)
        {
            perror("recv err");
            return NULL;
        }
        else if (ret == 0)
        {
            printf("client exit\n");
            break;
        }
        else
        {
            printf("buf:%s\n", buf);
            memset(buf, 0, sizeof(buf));
        }
        // 7.关闭套接字（close）-----------------》挂电话
        }
    close(acceptfd);
    pthread_exit(NULL);
}

int main(int argc, char const *argv[])
{

    int acceptfd;
    pthread_t tid;
    // 1.创建套接字（socket）---------------》有手机
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket err");
        return -1;
    }
    printf("sockfd:%d\n", sockfd); // 3
    // 2.指定网络信息---------------------------》有号码
    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;            // IPV4
    saddr.sin_port = htons(atoi(argv[1])); // 端口号
    // saddr.sin_addr.s_addr = inet_addr("192.168.50.13"); // 虚拟机IP
    // saddr.sin_addr.s_addr = inet_addr("0.0.0.0");
    saddr.sin_addr.s_addr = INADDR_ANY;
    int len = sizeof(caddr);
    // 3.绑定套接字（bind）------------------》绑定手机（插卡）
    if (bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
    {
        perror("bind err");
        return -1;
    }
    printf("bind ok\n");
    // 4.监听套接字（listen）-----------------》待机
    if (listen(sockfd, 6) < 0)
    {
        perror("listen err");
        return -1;
    }
    printf("listen ok\n");
    // 5.接收客户端连接连接请求（accept）--》接电话
    // tcp服务器一共有两类文件描述符,一类用于连接,一类用于通信
    // socket函数返回值:用于连接的文件描述符
    // accept函数返回值:用于通信的文件描述符
    while (1)
    {

        acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &len);
        if (acceptfd < 0)
        {
            perror("accept err");
            return -1;
        }
        printf("port:%d ip:%s\n", ntohs(caddr.sin_port), inet_ntoa(caddr.sin_addr));
        printf("acceptfd:%d\n", acceptfd);

        pthread_create(&tid, NULL, handler, &acceptfd);
        pthread_detach(tid);
    }
    close(sockfd);

    return 0;
}

2.3io多路复用

select，poll，epoll

2.4并发服务器总结

多进程;

优点：服务器更加稳定，父子进程资源相互独立，安全性高

缺点：需要开辟多个进程，大量的消耗资源，系统开销大

多线程：

优点：相对于多进程，资源开销小，多个线程共享同一个进程的资源

缺点：需要开辟多个线程，安全性比较差

io多路复用

优点：节约资源，系统开销小，性能高

缺点：代码复杂度高

FTP

服务器

#include <stdio.h>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
#include <stdlib.h>
#include <dirent.h>
#include <fcntl.h>

void list(int acceptfd);
void putfile(int acceptfd, char *p);
void getfile(int acceptfd, char *p);

int main(int argc, char const *argv[])
{
    char buf[128] = {0};
    int ret, acceptfd;
    // 1.创建套接字（socket）---------------》有手机
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket err");
        return -1;
    }
    printf("sockfd:%d\n", sockfd); // 3
    // 2.指定网络信息---------------------------》有号码
    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;            // IPV4
    saddr.sin_port = htons(atoi(argv[1])); // 端口号
    // saddr.sin_addr.s_addr = inet_addr("192.168.50.13"); // 虚拟机IP
    // saddr.sin_addr.s_addr = inet_addr("0.0.0.0");
    saddr.sin_addr.s_addr = INADDR_ANY;
    int len = sizeof(caddr);
    // 3.绑定套接字（bind）------------------》绑定手机（插卡）
    if (bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
    {
        perror("bind err");
        return -1;
    }
    printf("bind ok\n");
    // 4.监听套接字（listen）-----------------》待机
    if (listen(sockfd, 6) < 0)
    {
        perror("listen err");
        return -1;
    }
    printf("listen ok\n");
    // 5.接收客户端连接连接请求（accept）--》接电话
    // tcp服务器一共有两类文件描述符,一类用于连接,一类用于通信
    // socket函数返回值:用于连接的文件描述符
    // accept函数返回值:用于通信的文件描述符
    while (1)
    {

        acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &len);
        if (acceptfd < 0)
        {
            perror("accept err");
            return -1;
        }
        printf("port:%d ip:%s\n", ntohs(caddr.sin_port), inet_ntoa(caddr.sin_addr));
        printf("acceptfd:%d\n", acceptfd);

        // 6.接收、发送数据（recv send）---》通话
        while (1)
        {
            // read/write()
            ret = recv(acceptfd, buf, sizeof(buf), 0);
            if (ret < 0)
            {
                perror("recv err");
                return -1;
            }
            else if (ret == 0)
            {
                printf("client exit\n");
                break;
            }
            else
            {
                printf("buf:%s\n", buf);
                if (!strcmp(buf, "list"))
                    list(acceptfd);
                if (!strncmp(buf, "put ", 4))
                    putfile(acceptfd, buf);
                if (!strncmp(buf, "get ", 4))
                    getfile(acceptfd, buf);
                if (!strcmp(buf, "quit"))
                    break;
                memset(buf, 0, sizeof(buf));
            }
        }
        // 7.关闭套接字（close）-----------------》挂电话
        close(acceptfd);
    }
    close(sockfd);

    return 0;
}

void list(int acceptfd)
{
    struct dirent *d;
    // 打开目录文件
    DIR *dir = opendir(".");
    if (dir == NULL)
    {
        perror("opendir err");
        return;
    }
    // 循环读目录
    while ((d = readdir(dir)) != NULL)
    {
        // 判断是否为普通文件
        if (d->d_type == DT_REG)
            // 发送给客户端
            send(acceptfd, d->d_name, 128, 0);
    }
    // 发送一个结束的标志
    send(acceptfd, "end", 128, 0);
    return;
}

void putfile(int acceptfd, char *p)
{
    char buf[128] = {0};
    int ret;
    int fd = open(p + 4, O_WRONLY | O_CREAT | O_TRUNC, 0666);
    if (fd < 0)
    {
        perror("open err");
        return;
    }
    // 接受客户端传来的文件内容
    while (1)
    {
        ret = recv(acceptfd, buf, sizeof(buf), 0);
        if (ret < 0)
        {
            perror("recv err");
            return;
        }
        else
        {
            // 写到目标文件里面
            if (!strcmp(buf, "end"))
                break;
            write(fd, buf, strlen(buf));
            memset(buf, 0, sizeof(buf));
        }
    }
    close(fd);
    return;
}

void getfile(int acceptfd, char *p)
{
    char buf[128] = {0};
    ssize_t s;
    int fd = open(p + 4, O_RDONLY);
    if (fd < 0)
    {
        perror("open err");
        return;
    }
    // 循环读文件
    while (1)
    {
        s = read(fd, buf, sizeof(buf) - 1);
        buf[s] = '\0';
        if (s == 0)
        {
            printf("send end\n");
            send(acceptfd, "end", sizeof(buf), 0);
            break;
        }
        // 发送给服务器
        send(acceptfd, buf, sizeof(buf), 0);
        memset(buf, 0, sizeof(buf));
    }
    close(fd);
    return;
}

客户端

#include <stdio.h>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>

void show();
void list(int sockfd);
void putfile(int sockfd, char *p);
void getfile(int sockfd, char *p);

int main(int argc, char const *argv[])
{
    char buf[128] = {0};
    // 1.创建套接字（socket）------------》有手机
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket err");
        return -1;
    }
    printf("sockfd:%d\n", sockfd);
    // 2.指定（服务器）网络信息--------》有对方的号码
    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[2]));
    saddr.sin_addr.s_addr = inet_addr(argv[1]);
    // 3.连接（connect）-------------------》拨打电话
    if (connect(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
    {
        perror("connect err");
        return -1;
    }
    printf("connect okk\n");
    // 4.接收发送消息（recv send）---》通话
    while (1)
    {
        show();
        fgets(buf, sizeof(buf), stdin);
        if (buf[strlen(buf) - 1] == '\n')
            buf[strlen(buf) - 1] = '\0';

        // write(sockfd, buf, sizeof(buf));
        send(sockfd, buf, sizeof(buf), 0);
        if (!strcmp(buf, "list"))
            list(sockfd);
        if (!strcmp(buf, "quit"))
            break;
        if (!strncmp(buf, "put ", 4))
            putfile(sockfd, buf);
        if (!strncmp(buf, "get ", 4))
            getfile(sockfd, buf);
    }
    // 5.关闭套接字（close）------------》挂电话
    close(sockfd);
    return 0;
}

void show()
{
    printf("----------------list----------------\n");
    printf("------------put filename------------\n");
    printf("------------get filename------------\n");
    printf("----------------quit----------------\n");
}

void list(int sockfd)
{
    char buf[128] = {0};
    int ret;
    while (1)
    {
        ret = recv(sockfd, buf, sizeof(buf), 0);
        if (ret < 0)
        {
            perror("recv err");
            return;
        }
        if (!strcmp(buf, "end"))
            break;
        printf("%s ", buf);
    }
    putchar(10);
    return;
}

void putfile(int sockfd, char *p)
{
    char buf[128] = {0};
    ssize_t s;
    int fd = open(p + 4, O_RDONLY);
    if (fd < 0)
    {
        perror("open err");
        return;
    }
    // 循环读文件
    while (1)
    {
        s = read(fd, buf, sizeof(buf) - 1);
        buf[s] = '\0';
        if (s == 0)
        {
            printf("send end\n");
            send(sockfd, "end", sizeof(buf), 0);
            break;
        }
        // 发送给服务器
        send(sockfd, buf, sizeof(buf), 0);
        memset(buf, 0, sizeof(buf));
    }
    close(fd);
    return;
}

void getfile(int sockfd, char *p)
{
    char buf[128] = {0};
    int ret;
    int fd = open(p + 4, O_WRONLY | O_CREAT | O_TRUNC, 0666);
    if (fd < 0)
    {
        perror("open err");
        return;
    }
    // 接受客户端传来的文件内容
    while (1)
    {
        ret = recv(sockfd, buf, sizeof(buf), 0);
        if (ret < 0)
        {
            perror("recv err");
            return;
        }
        else
        {
            // 写到目标文件里面
            if (!strcmp(buf, "end"))
                break;
            write(fd, buf, strlen(buf));
            memset(buf, 0, sizeof(buf));
        }
    }
    close(fd);
    return;
}

标签：ftp,epoll,int,Day5,描述符,acceptfd,sockfd,include,buf
From： https://blog.csdn.net/weixin_64032452/article/details/142103714

相关文章

  • Linux：多路转接 select、poll、epoll
    1：select#include<sys/select.h>intselect(intnfds,fd_set*readfds,fd_set*writefds,fd_set*exceptfds,structtimeval*timeout);   select函数是POSIX标准定义的一个系统调用，用于监视多个文件描述符（filedescriptors），以确定它们是否具有可读、可写或异常......
  • 代码随想录day55 || 图论5
    并查集197图中是否存在有效路径varfather[]intfuncvalidPath(nint,edges[][]int,sourceint,destinationint)bool{ //使用并查集算法，涉及到的操作，包括init，find，issample，join father=make([]int,n) fori,_:=rangefather{//init father[i]=i }......
  • Ftrans无缝替代FTP方案：保障数据传输的安全性与合规性！
    FTP（文件传输协议）是一种用于在网络上进行文件传输的标准网络协议，历史悠久并且被广泛使用。但随着业务规模和文件体量的快速增长，在应用实践中，FTP存在一些安全和效率问题。因此政府单位需要可以平滑替代FTP的文件传输解决方案，从而更好的保障数据安全、提升工作效率。具体存在以下问题......
  • 代码随想录训练营 Day53打卡 图论part04 110. 字符串接龙 105. 有向图的完全可达性 10
    代码随想录训练营Day53打卡图论part04一、卡码110.字符串接龙本题与力扣127题是一样的，所以这里使用力扣127题。字典wordList中从单词beginWord到endWord的转换序列是一个按下述规格形成的序列beginWord->s1->s2->…->sk：    每一对相邻的单词只......
  • CentOS 8FTP服务器
    FTP（文件传输协议）是一种客户端-服务器网络协议，允许用户在远程计算机之间传输文件。这里有很多可用于Linux的开源FTP服务软件，最流行最常用的FTP服务软件有PureFTPd,ProFTPD,和vsftpd。在本教程中，我们将在CentOS8[4]上安装vsftpd（非常安全的Ftp守护程序）。这是一个稳定，安全......
  • 代码随想录day52 || 图论3
    岛屿最大的孤岛面积packagemainimport"fmt"vardirPath=[4][2]int{{0,-1},{1,0},{0,1},{-1,0}}varvisited[][]boolvarflagboolvarresintfuncmain(){ varx,yint fmt.Scanf("%d%d",&x,&y) //x行y列初始化临界矩阵 vargra......
  • 【代码随想录训练营第42期 Day51打卡 - 岛屿问题 - 卡码网 99. 岛屿数量 100. 岛屿的
    目录一、做题心得二、题目与题解题目一：99.岛屿数量题目链接题解1：DFS 题解2：BFS 题目二：100.岛屿的最大面积题目链接题解：DFS 三、小结一、做题心得今天打卡的是经典的岛屿问题：分别从两个方向进行探讨--深搜（DFS）与广搜（BFS）。作为这两大基本搜索最经典的例题，今天......
  • 代码随想录day52 || 图论搜索 岛屿数量，岛屿的最大面积
    图遍历dfs深度优先搜索bfs广度优先搜索200岛屿数量（dfs）vardirPath=[][]int{{0,-1},{1,0},{0,1},{-1,0}}//上，右，下，左varvisited[][]boolfuncnumIslands(grid[][]byte)int{ //dfs深度优先遍历，对于每一个节点，按照上下左右四个固定顺序遍历，然后到下......
  • select、poll、epoll的原理
    目录1.IO多路复用2.select原理3.poll原理4.epoll原理5.select、poll、epoll总结6.epoll原理详解6.1内核收包的过程6.2进程调度时的阻塞6.3再来看一下内核收网络数据的过程6.4select的原理6.5epoll的设计原理6.6补充6.7总结1.IO多路复用IO多路复用就是一个线程......
  • 代码随想录训练营 Day50打卡 图论part01 理论基础 98. 所有可达路径
    代码随想录训练营Day50打卡图论part01一、理论基础DFS（深度优先搜索）和BFS（广度优先搜索）在图搜索中的核心区别主要体现在搜索策略上：1、搜索方向：DFS：深度优先，一条路走到黑。DFS从起点开始，选择一个方向深入到底，遇到死胡同再回溯，换一个方向继续探索。这种方式适合解决路径......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99