【LeetCode】递归精选8题——基础递归、链表递归

目录

基础递归问题：

1. 斐波那契数（简单）

1.1 递归求解

1.2 迭代求解

2. 爬楼梯（简单）

2.1 递归求解

2.2 迭代求解

3. 汉诺塔问题（简单）

3.1 递归求解

4. Pow(x, n)（中等）

4.1 递归求解

4.2 迭代求解

链表递归问题：

1. 合并两个有序链表（简单）

1.1 递归求解

1.2 迭代求解

2. 反转链表（简单）

2.1 递归求解

2.2 迭代求解

3. 两两交换链表中的节点（中等）

3.1 递归求解

3.2 迭代求解

4. 合并 K 个升序链表（困难）

4.1 递归求解

4.2 迭代求解

在解决一个规模为n的问题时，如果满足以下条件，我们可以使用递归来解决：

  1. 问题可以被划分为规模更小的子问题，并且这些子问题具有与原问题相同的解决方法。
  2. 当我们知道规模更小的子问题（规模为n-1）的解时，我们可以直接计算出规模为n的问题的解。
  3. 存在一种简单情况，或者说当问题的规模足够小时，我们可以直接求解问题。

一般的递归求解过程如下：

  1. 验证是否满足简单情况。
  2. 假设较小规模的问题已经解决，解决当前问题。

上述步骤可以通过数学归纳法来证明。

基础递归问题：

1. 斐波那契数（简单）

1.1 递归求解

重复的子问题——函数头设计

int fib(int n)

子问题在做什么——函数体设计

fib(n - 1) + fib(n - 2)

递归出口

fib(0) = 0

fib(1) = 1

class Solution {
public:
    int fib(int n) {
        if (n <= 1)
            return n;

        return fib(n - 1) + fib(n - 2);
    }
};

1.2 迭代求解

递归算法在计算时存在着大量的重复计算，执行效率低，n值稍大时非常耗费时间。斐波那契数列用迭代算法更高效。

class Solution {
public:
    int fib(int n) {
        if (n <= 1)
            return n;

        int a = 0;
        int b = 1;
        int c = 0;
        for (int i = 2; i <= n; i++)
        {
            c = a + b;
            a = b;
            b = c;
        }
        return c;
    }
};

2. 爬楼梯（简单）

2.1 递归求解

重复的子问题——函数头设计

int climbStairs(int n)

子问题在做什么——函数体设计

如果先走1级台阶，还剩n - 1级台阶，有climbStairs(n - 1)种走法；如果先走2级台阶，还剩n - 2级台阶，有climbStairs(n - 2)种走法。一共的走法：

climbStairs(n - 1) + climbStairs(n - 2)

递归出口

当n == 1时，只有1种走法。

当n == 2时，可以一次走1级台阶，走两次；也可以一次走2级台阶，走一次。所以一共有2种走法。

climbStairs(1) = 1

climbStairs(2) = 2

class Solution {
public:
    int climbStairs(int n) {
        if (n <= 2)
            return n;

        return climbStairs(n - 1) + climbStairs(n - 2);
    }
};

（But这题在LeetCode上用递归会超时o(´^｀)o）

可以看出爬楼梯是斐波那契数的应用。

2.2 迭代求解

class Solution {
public:
    int climbStairs(int n) {
        if (n <= 2)
            return n;

        int a = 1;
        int b = 2;
        int c = 0;
        for (int i = 3; i <= n; i++)
        {
            c = a + b;
            a = b;
            b = c;
        }
        return c;
    }
};

3. 汉诺塔问题（简单）

3.1 递归求解

​​

重复的子问题——函数头设计

有三根柱子A、B、C，A柱上有n个盘子，将所有盘子从A柱经B柱全部移到C柱上。

void dfs(int n, vector<int>& A, vector<int>& B, vector<int>& C)

子问题在做什么——函数体设计

该问题可划分成2个自相似问题和1次移动：

  1. 将n-1个盘子从A柱经C柱全部移到B柱上：dfs(n - 1, A, C, B);
  2. 将第n个盘子从A柱移到C柱上：C.push_back(A.back());    A.pop_back();
  3. 将n-1个盘子从B柱经A柱全部移到C柱上：dfs(n - 1, B, A, C);

递归出口

当A柱只剩1个盘子时（即n == 1时），将其从A柱移到C柱上。

C.push_back(A.back());

A.pop_back();

class Solution {
public:
    void hanota(vector<int>& A, vector<int>& B, vector<int>& C) {
        if (A.empty())
            return;
        dfs(A.size(), A, B, C);
    }

private:
    // n个盘子从A经B移到C
    void dfs(int n, vector<int>& A, vector<int>& B, vector<int>& C)
    {
        if (n == 1)
        {
            C.push_back(A.back());
            A.pop_back();
            return;
        }
        dfs(n - 1, A, C, B);
        C.push_back(A.back());
        A.pop_back();
        dfs(n - 1, B, A, C);
    }
};

4. Pow(x, n)（中等）

4.1 递归求解

快速幂算法的核心思想就是每一步都把指数分成两半，而相应的底数做平方运算。这样不仅能把非常大的指数给不断变小，所需要执行的循环次数也变小，而最后表示的结果却一直不会变。其时间复杂度为 O(log₂N)， 与朴素的O(N)相比效率有了极大的提高。

x^{n} = (x^{2})^{\frac{n}{2}}

如果n是负数，x^{n} = \frac{1}{x^{-n}}，所以只需考虑n是自然数的情况：

假设n/2向下取整，则需要分奇偶两种情况：

  • 当n是偶数时，x^{n} = (x^{2})^{\frac{n}{2}}
  • 当n是奇数时，x^{n} = (x^{2})^{\frac{n}{2}} * x

重复的子问题——函数头设计

double dfs(double x, long long n)    n是非负数

用long long接收n，防止-2^31转换成2^31越界。

子问题在做什么——函数体设计

判断n的奇偶性，带入不同的公式。

偶数：return dfs(x * x, n / 2);    偶数：return dfs(x * x, n / 2) * x;

递归出口

当 n == 0 时，任何数的0次幂都等于1，返回1.0

class Solution {
public:
    double myPow(double x, int n) {
        return n < 0 ? 1.0 / dfs(x, -(long long)n) : dfs(x, n);
    }

private:
    double dfs(double x, long long n)
    {
        if (n == 0)
            return 1.0;

        return n % 2 == 0 ? dfs(x * x, n / 2) : dfs(x * x, n / 2) * x;
    }
};

4.2 迭代求解

二进制角度的快速幂算法：

假设n的二进制为bk .….. b2 b1 b0，则：

n = b_{0} * 2^{0} + b_{1} * 2^{1} + b_{2} * 2^{2} + ... + b_{k} * 2^{k}

x^{n} = x^{b_{0} * 2^{0} + b_{1} * 2^{1} + b_{2} * 2^{2} + ... + b_{k} * 2^{k}} = x^{2^{0} * b_{0}} * x^{2^{1} * b_{1}} * x^{2^{2} * b_{2}} * ... * x^{2^{k} * b_{k}}

当bi == 0时，x^{2^{i} * b_{i}} = 1

当bi == 1时，x^{2^{i} * b_{i}} = x^{2^{i}}

我们从x开始不断地进行平方，如果bi == 1，就将对应的x^{2^{i}}计入答案。

举个例子：

计算x^{11}：ans初始值为1.0，11的二进制表示为1011，

b_{0}=1，将x^{1}计入答案，

b_{1}=1，将x^{2}计入答案，

b_{2}=0，将x^{4}不计入答案，

b_{3}=1，将x^{8}计入答案，

即x^{11}=x^{1}*x^{2}*x^{8}

class Solution {
public:
    double myPow(double x, int n) {
        return n < 0 ? 1.0 / quickPower(x, -(long long)n) : quickPower(x, n);
    }

private:
    double quickPower(double x, long long n)
    {
        double ans = 1.0;
        while (n)
        {
            // 如果最低位为1，将对应的x的幂值计入答案
            if ((n & 1) == 1)
            {
                ans *= x;
            }
            x *= x;
            // 舍弃n的二进制的最低位，这样每次只要判断最低位即可
            n >>= 1;
        }
        return ans;
    }
};

链表递归问题：

1. 合并两个有序链表（简单）

1.1 递归求解

​​

​​

重复的子问题——函数头设计

ListNode* mergeTwoLists(ListNode* list1, ListNode* list2)

子问题在做什么——函数体设计

选择两个链表的头节点中值较小的那一个作为最终合并的新链表的头节点，然后将剩下的链表交给递归函数去处理。

  1. 比较list1->val和list2->val的大小（假设list1->val较小）
  2. list1->next = mergeTwoLists(list1->next, list2);
  3. return list1;

递归出口

当某一个链表为空的时候，返回另外一个链表。

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        if (list1 == nullptr)
            return list2;
        if (list2 == nullptr)
            return list1;

        if (list1->val < list2->val)
        {
            list1->next = mergeTwoLists(list1->next, list2);
            return list1;
        }
        else
        {
            list2->next = mergeTwoLists(list1, list2->next);
            return list2;
        }
    }
};

1.2 迭代求解

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        ListNode* preHead = new ListNode; // 哨兵节点
        ListNode* tail = preHead;

        // 取小的尾插
        while (list1 && list2)
        {
            if (list1->val < list2->val)
            {
                tail->next = list1;
                tail = tail->next;
                list1 = list1->next;
            }
            else
            {
                tail->next = list2;
                tail = tail->next;
                list2 = list2->next;
            }
        }

        if (list1)
        {
            tail->next = list1;
        }
        if (list2)
        {
            tail->next = list2;
        }

        return preHead->next;
    }
};

2. 反转链表（简单）

2.1 递归求解

​​

重复的子问题——函数头设计

ListNode* reverseList(ListNode* head)

子问题在做什么——函数体设计

将当前结点之后的链表反转，然后把当前结点添加到反转后的链表后面即可，返回反转后的头节点。

  1. ListNode* newHead = reverseList(head->next);
  2. head->next->next = head;    head->next = nullptr;
  3. return newHead;

递归出口

当前结点为空或者当前只有一个结点的时候，不用反转，直接返回。

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if (head == nullptr || head->next == nullptr)
            return head;

        ListNode* newHead = reverseList(head->next);
        head->next->next = head;
        head->next = nullptr;
        return newHead;
    }
};

2.2 迭代求解

​​

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* pre = nullptr;
        ListNode* cur = head;
        while (cur)
        {
            ListNode* next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }

        return pre;
    }
};

3. 两两交换链表中的节点（中等）

3.1 递归求解

​​

重复的子问题——函数头设计

ListNode* swapPairs(ListNode* head)

子问题在做什么——函数体设计

将从第三个节点开始的链表两两交换节点，然后再把前两个节点交换一下，链接上刚才处理过的链表，并返回。

  1. ListNode* tmp = swapPairs(head->next->next);
  2. ListNode* newHead = head->next;    newHead->next = head;
  3. head->next = tmp;
  4. return newHead;

递归出口

当前结点为空或者当前只有一个结点的时候，不用两两交换，直接返回。

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if (head == nullptr || head->next == nullptr)
            return head;

        ListNode* tmp = swapPairs(head->next->next);
        ListNode* newHead = head->next;
        newHead->next = head;
        head->next = tmp;
        return newHead;
    }
};

3.2 迭代求解

​​

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* preHead = new ListNode(0, head); // 哨兵节点
        ListNode* cur = preHead;
        // cur后面的两个节点交换
        while (cur->next && cur->next->next)
        {
            ListNode* node1 = cur->next;
            ListNode* node2 = cur->next->next;
            cur->next = node2;
            node1->next = node2->next;
            node2->next = node1;
            cur = node1;
        }
        return preHead->next;
    }
};

4. 合并 K 个升序链表（困难）

4.1 递归求解

分治的思想，类似归并排序：

  1. 划分两个子区间

  2. 分别对两个子区间的链表进行合并，形成两个有序链表

  3. 合并两个有序链表

重复的子问题——函数头设计

ListNode* merge(vector<ListNode*>& lists, int begin, int end)

子问题在做什么——函数体设计

  1. 划分两个子区间：int mid = (begin + end) / 2;
  2. 递归合并两个子区间：
    ListNode* l1 = merge(lists, begin, mid);
    ListNode* l2 = merge(lists, mid + 1, end);
  3. 合并两个有序链表：return mergeTowList(l1, l2);

递归出口

当区间只有一个链表时，不合并。另外，当题目给出空链表时，不合并。

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        return merge(lists, 0, lists.size() - 1);
    }

private:
    ListNode* merge(vector<ListNode*>& lists, int begin, int end)
    {
        if (begin > end)
            return nullptr;
        if (begin == end)
            return lists[begin];

        int mid = (begin + end) / 2;
        ListNode* l1 = merge(lists, begin, mid);
        ListNode* l2 = merge(lists, mid + 1, end);
        return mergeTwoLists(l1, l2);
    }
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2)
    {
        ListNode* preHead = new ListNode; // 哨兵节点
        ListNode* tail = preHead;

        // 取小的尾插
        while (list1 && list2)
        {
            if (list1->val < list2->val)
            {
                tail->next = list1;
                tail = tail->next;
                list1 = list1->next;
            }
            else
            {
                tail->next = list2;
                tail = tail->next;
                list2 = list2->next;
            }
        }

        if (list1)
        {
            tail->next = list1;
        }
        if (list2)
        {
            tail->next = list2;
        }

        return preHead->next;
    }
};

4.2 迭代求解

和“合并两个有序链表”类似，就是取小的尾插。怎么判断K个链表未合并的头节点中最小的那个？利用堆这个数据结构即可。把K个链表未合并的头节点放进一个小根堆，堆顶就是最小的那个。

class Solution {
    struct cmp
    {
        bool operator()(ListNode* n1, ListNode* n2)
        {
            return n1->val > n2->val;
        }
    };

public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        // 创建小根堆
        priority_queue<ListNode*, vector<ListNode*>, cmp> heap;
        // 将所有头节点放进小根堆
        for (auto& l : lists)
        {
            if (l)
            {
                heap.push(l);
            }
        }
        // 合并链表
        ListNode* preHead = new ListNode; // 哨兵节点
        ListNode* tail = preHead;
        while (!heap.empty())
        {
            // 取堆顶节点尾插
            tail->next = heap.top();
            heap.pop();
            tail = tail->next;
            // 将刚才合并的节点的下一个节点补充进堆
            if (tail->next)
            {
                heap.push(tail->next);
            }
        }
        return preHead->next;
    }
};

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/398643.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【linux】查看openssl程序的安装情况

【linux】查看openssl程序的安装情况

【linux】查看openssl程序的安装情况 1、查看安装包信息 $ rpm -qa |grep openssl 2、安装路径 $ rpm -ql openssl $ rpm -ql openssl-libs $ rpm -ql openssl-devel 3、相关文件和目录 /usr/bin/openssl /usr/include/openssl /usr/lib64/libssl.so.* /usr/lib64/libcrypto…
阅读更多...
直接查看电脑几核芯几线程的方法

直接查看电脑几核芯几线程的方法

之前查看电脑几核芯几线程时都是点击 此电脑->属性->设备管理器->处理器 但是这样并不能判断是否有多线程 譬如这里&#xff0c;是2核芯2线程还是4核芯&#xff1f; 实际上&#xff0c;打开任务管理器后点击性能查看核芯线程数即可 所以示例这台电脑是4核芯而不是2…
阅读更多...
视频生成模型：构建虚拟世界的模拟器 [译]

视频生成模型：构建虚拟世界的模拟器 [译]

原文&#xff1a;Video generation models as world simulators 我们致力于在视频数据上开展生成模型的大规模训练。具体来说&#xff0c;我们针对不同时长、分辨率和宽高比的视频及图像&#xff0c;联合训练了基于文本条件的扩散模型。我们采用了一种 Transformer 架构&#…
阅读更多...
多维时序 | Matlab实现BiLSTM-MATT双向长短期记忆神经网络融合多头注意力多变量时间序列预测模型

多维时序 | Matlab实现BiLSTM-MATT双向长短期记忆神经网络融合多头注意力多变量时间序列预测模型

多维时序 | Matlab实现BiLSTM-MATT双向长短期记忆神经网络融合多头注意力多变量时间序列预测模型 目录 多维时序 | Matlab实现BiLSTM-MATT双向长短期记忆神经网络融合多头注意力多变量时间序列预测模型预测效果基本介绍程序设计参考资料 预测效果 基本介绍 1.多维时序 | Matlab…
阅读更多...
回显服务器

回显服务器

. 写一个应用程序,让这个程序可以使用网络通信,这里就需要调用传输层提供的api,传输层提供协议,主要是两个: UDP,TCP,它们分别提供了一套不同的api,socket api. UDP和TCP UDP:无连接,不可靠传输,面向数据报,全双工 TCP:有连接,可靠传输,面向字节流,全双工 一个客户端可以连接…
阅读更多...
仪表板展示｜DataEase看中国：历年研究生报考数据分析

仪表板展示｜DataEase看中国：历年研究生报考数据分析

背景介绍 在信息时代的浪潮中&#xff0c;研究生教育作为培养高层次专业人才的重要通道&#xff0c;不断吸引着广大毕业生和在职人士的关注。今天我们结合2018年&#xff5e;2024年的研究生报考数据&#xff0c;以数字为镜&#xff0c;深入了解近年来研究生培养态势。 本文将…
阅读更多...
Redis篇----第七篇

Redis篇----第七篇

系列文章目录 文章目录 系列文章目录前言一、Redis 的回收策略（淘汰策略）?二、为什么 edis 需要把所有数据放到内存中？三、Redis 的同步机制了解么？四、Pipeline 有什么好处，为什么要用 pipeline？前言 前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍…
阅读更多...
机器学习：逻辑回归原理

机器学习：逻辑回归原理

逻辑回归模型是一种广泛应用于分类问题的统计方法。尽管名为“回归”&#xff0c;但它实际上是一种分类算法&#xff0c;主要用于预测观察对象属于某个类别的概率。逻辑回归模型特别适用于二分类问题&#xff0c;但也可以通过一些策略扩展到多分类问题。 逻辑回归的应用与优化…
阅读更多...
gazebo 中使用gmaping 建图

gazebo 中使用gmaping 建图

一、使用gmapping 建图 启动roscoreroslaunch wpr_simulation wpb_stage_robocup.launchsudo apt install ros-noetic-gmappingrosrun gmapping slam_gmapping启动rviz (rosrun rviz rviz)。添加RobotModel、LaserScan、Map后 显示如下&#xff1a; 6.rosrun wpr_simulation k…
阅读更多...
网络爬虫基础（上）

网络爬虫基础（上）

1. 爬虫的基本原理 爬虫就是在网页上爬行的蜘蛛&#xff0c;每爬到一个节点就能够访问该网页的信息&#xff0c;所以又称为网络蜘蛛&#xff1b; 网络爬虫就是自动化从网页上获取信息、提取信息和保存信息的过程&#xff1b; 2. URL的组成部分 URL全称为Uniform Resource L…
阅读更多...
UG NX二次开发(C#)-PMI-获取PMI尺寸数据

UG NX二次开发(C#)-PMI-获取PMI尺寸数据

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 1、前言2、在UG NX的三维模型中添加PMI尺寸信息3、采用二次开发获取尺寸数据4、测试结果1、前言 PMI（Product and Manufacturing Information）是产品和制造信息的简称，主要用于将产品部件设计的…
阅读更多...
python 与 neo4j 交互（py2neo 使用）

python 与 neo4j 交互（py2neo 使用）

参考自&#xff1a;neo4j的python.py2neo操作入门 官方文档&#xff1a;The Py2neo Handbook — py2neo 2021.1 安装&#xff1a;pip install py2neo -i https://pypi.tuna.tsinghua.edu.cn/simple 1 节点 / 关系 / 属性 / 路径 节点(Node)和关系(relationship)是构成图的基础…
阅读更多...
代码随想录算法训练营第二十三天 | 669. 修剪二叉搜索树，108.将有序数组转换为二叉搜索树，538.把二叉搜索树转换为累加树 [二叉树篇]

代码随想录算法训练营第二十三天 | 669. 修剪二叉搜索树，108.将有序数组转换为二叉搜索树，538.把二叉搜索树转换为累加树 [二叉树篇]

代码随想录算法训练营第二十三天 LeetCode 669. 修剪二叉搜索树题目描述思路递归参考代码 LeetCode 108.将有序数组转换为二叉搜索树题目描述思路参考代码 LeetCode 538.把二叉搜索树转换为累加树题目描述思路参考代码 LeetCode 669. 修剪二叉搜索树 题目链接&#xff1a;669. …
阅读更多...
《Solidity 简易速速上手小册》第9章：DApp 开发与 Solidity 集成（2024 最新版）

《Solidity 简易速速上手小册》第9章：DApp 开发与 Solidity 集成（2024 最新版）

文章目录 9.1 DApp 的架构和设计9.1.1 基础知识解析更深入的理解实际操作技巧 9.1.2 重点案例&#xff1a;去中心化社交媒体平台案例 Demo&#xff1a;创建去中心化社交媒体平台案例代码SocialMedia.sol - 智能合约前端界面 测试和验证拓展功能 9.1.3 拓展案例 1&#xff1a;去…
阅读更多...
LabVIEW高速信号测量与存储

LabVIEW高速信号测量与存储

LabVIEW高速信号测量与存储 介绍了LabVIEW开发的高速信号测量与存储系统&#xff0c;解决实验研究中信号捕获的速度和准确性问题。通过高效的数据处理和存储解决方案&#xff0c;本系统为用户提供了一种快速、可靠的信号测量方法。 项目背景 在科学研究和工业应用中&#xf…
阅读更多...
百度RT-DETR ：基于视觉变换器的实时物体检测器

百度RT-DETR ：基于视觉变换器的实时物体检测器

概述 实时检测转换器 (RT-DETR) 由百度开发&#xff0c;是一种尖端的端到端物体检测器&#xff0c;可在保持高精度的同时提供实时性能。它利用视觉转换器&#xff08;ViT&#xff09;的强大功能&#xff0c;通过解耦尺度内交互和跨尺度融合&#xff0c;高效处理多尺度特征。RT…
阅读更多...
think-cell Round 1

think-cell Round 1

think-cell Round 1 A. Maximise The Score 题意&#xff1a;给出2n个数&#xff0c;每次选两个取较小值加到分数里&#xff0c;分数最大为多少。 思路&#xff1a;排序&#xff0c;奇数位和。 AC code&#xff1a; void solve() {cin >> n;int ans 0;int a[N];for…
阅读更多...
EXCEL使用VBA一键批量转换成PDF

EXCEL使用VBA一键批量转换成PDF

EXCEL使用VBA一键批量转换成PDF 上图是给定转换路径 Sub 按钮1_Click() Dim a(1 To 1000) As String Dim a2 As String Dim myfile As String Dim wb As Workbook a2 Trim(Range("a2"))myfile Dir(a2 & "\" & "*.xls")k 0Do While m…
阅读更多...
如何创建WordPress付款表单(简单方法)

如何创建WordPress付款表单(简单方法)

您是否正在寻找一种简单的方法来创建付款功能WordPress表单&#xff1f; 小企业主通常需要创建一种简单的方法来在其网站上接受付款&#xff0c;而无需设置复杂的购物车。简单的付款表格使您可以轻松接受自定义付款金额、设置定期付款并收集自定义详细信息。 在本文中&#x…
阅读更多...
django请求生命周期流程图，路由匹配，路由有名无名反向解析，路由分发，名称空间

django请求生命周期流程图，路由匹配，路由有名无名反向解析，路由分发，名称空间

django请求生命周期流程图 浏览器发起请求。 先经过网关接口&#xff0c;Django自带的是wsgiref&#xff0c;请求来的时候解析封装&#xff0c;响应走的时候打包处理&#xff0c;这个wsgiref模块本身能够支持的并发量很少&#xff0c;最多1000左右&#xff0c;上线之后会换成u…
阅读更多...
最新文章

Copyright @ 2022~2023