【LeetCode】链表精选12题

news2024/9/26 5:15:18

目录

快慢指针：

1. 相交链表（简单）

2. 环形链表（简单）

3. 快乐数（简单）

4. 环形链表 II（中等）

5. 删除链表的倒数第 N 个节点（中等）

递归迭代双解法：

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

1.1 递归求解

1.2 迭代求解

2. 反转链表（简单）

2.1 递归求解

2.2 迭代求解

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

3.1 递归求解

3.2 迭代求解

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

4.1 递归解法

4.2 迭代解法

综合题：

1. 随机链表的复制（中等）

2. 重排链表（中等）

3. K个一组翻转链表（困难）

快慢指针：

1. 相交链表（简单）

找两个链表的尾结点，尾结点不相同则不相交。假设相交，长短链表之间差距gap步。假设i指向长链表的头节点，j指向短链表的头节点，i先走gap步，然后ij同时走，每次走1步。当ij相遇时，相遇点就是相交点。

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        // 找两个链表的尾结点，尾结点不相同则不相交
        ListNode* tailA = headA;
        ListNode* tailB = headB;
        int lenA = 0;
        int lenB = 0;
        while (tailA->next)
        {
            ++lenA;
            tailA = tailA->next;
        }
        while (tailB->next)
        {
            ++lenB;
            tailB = tailB->next;
        }
        if (tailA != tailB)
            return nullptr;

        // 判断长短链表
        ListNode* longList = headA;
        ListNode* shortList = headB;
        if (lenB > lenA)
        {
            longList = headB;
            shortList = headA;
        }

        // 长链表先走gap步
        int gap = abs(lenA - lenB);
        while (gap--)
        {
            longList = longList->next;
        }
        
        // 同时走，找交点
        while (longList != shortList)
        {
            longList = longList->next;
            shortList = shortList->next;
        }
        return longList;
    }
};

2. 环形链表（简单）

慢指针每次走1步，快指针每次走2步，慢指针进环后，快指针一定能追上慢指针，它们会在环中某点相遇。

为什么慢指针每次走1步，快指针要每次走2步，它们才能相遇？

假设慢指针进环时，快慢指针之间差距gap步。

如果快指针每次走2步，每走一次，它们之间的差距减1，gap一定会减到0。

如果快指针每次走3步，每走一次，它们之间的差距减2。如果gap为偶数，gap一定会减到0。如果gap为奇数，gap会减到-1，表示它们之间的距离变成C - 1（C是环的周长），如果C - 1是偶数，它们会相遇，如果C - 1是奇数，它们永远不会相遇。

class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode* slow = head;
        ListNode* fast = head;
        while (fast && fast->next)
        {
            slow = slow->next;
            fast = fast->next->next;
            if (slow == fast)
                return true;
        }
        return false;
    }
};

3. 快乐数（简单）

不是链表题，但是和上一题“环形链表”类似，慢指针每次走1步，快指针每次走2步，慢指针进环后，快指针一定能追上慢指针，它们会在环中某点相遇。如果相遇点为1，则为快乐数，否则不是快乐数。这里的指针表示的是值本身。

class Solution {
public:
    bool isHappy(int n) {
        int slow = n;
        int fast = bitSquareSum(n);
        while (slow != fast)
        {
            slow = bitSquareSum(slow);
            fast = bitSquareSum(bitSquareSum(fast));
        }
        return slow == 1;
    }

private:
    // 计算n的每一位的平方和
    int bitSquareSum(int n)
    {
        int sum = 0;
        while (n)
        {
            int tmp = n % 10;
            sum += tmp * tmp;
            n /= 10;
        }
        return sum;
    }
};

4. 环形链表 II（中等）

慢指针每次走1步，快指针每次走2步，慢指针进环后，快指针一定能追上慢指针，它们会在环中某点相遇。

假设在相遇点，慢指针一共走了k步，那么快指针一定一共走了2k步，所以快指针比慢指针多走了k步。另外，在相遇点，快指针一定比慢指针在环中多走了若干圈。所以，k一定是环的周长（环中节点个数）的整数倍。

此时，让i指向相遇点，j指向链表头节点，它们之间差距k步（慢指针走过的步数），如果i到达了环的入口，j也一定到达了环的入口，因为它们之间差距k步，k一定是环的周长的整数倍。

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while (fast && fast->next)
        {
            fast = fast->next->next;
            slow = slow->next;
            if (fast == slow) // 相遇
            {
                ListNode* i = slow; // 相遇点
                ListNode* j = head;
                while (i != j)
                {
                    i = i->next;
                    j = j->next;
                }
                return i;
            }
        }
        return nullptr;
    }
};

5. 删除链表的倒数第 N 个节点（中等）

快指针先走n步，然后快慢指针同时走，每次走1步。当快指针指向最后一个节点时，慢指针指向倒数第n + 1个节点。

例如，删除链表的倒数第2个节点：

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* preHead = new ListNode(0, head); // 哨兵节点
        ListNode* fast = preHead; // 快指针
        ListNode* slow = preHead; // 慢指针
        // 快指针先走n步
        while (n--)
        {
            fast = fast->next;
        }
        // 快慢指针同时走，每次走1步，直到快指针走到最后一个节点停止
        while (fast->next)
        {
            fast = fast->next;
            slow = slow->next;
        }
        // 此时慢指针指向倒数第n+1个节点
        // 让倒数第n+1个节点的next域直接指向倒数第n-1个节点
        slow->next = slow->next->next;
        return preHead->next;
    }
};

递归迭代双解法：

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 {
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;
    }

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

综合题：

1. 随机链表的复制（中等）

class Solution {
public:
    Node* copyRandomList(Node* head) {
        if (head == nullptr)
            return nullptr;

        // A->B->C->null --> A->A'->B->B'->C->C'->null
        Node* cur = head;
        while (cur)
        {
            Node* copy = new Node(cur->val); // 拷贝结点
            copy->next = cur->next;
            cur->next = copy;
            cur = cur->next->next;
        }

        // 设置拷贝结点的random，假如A的random域指向C，就让A'的random域指向C'
        cur = head;
        while (cur)
        {
            Node* copy = cur->next;
            if (cur->random == nullptr)
            {
                copy->random = nullptr;
            }
            else
            {
                copy->random = cur->random->next;
            }
            cur = cur->next->next;
        }

        // 将A'、B'、C'链接在一起，并且还原原链表
        Node* preHead = new Node(0); // 哨兵节点
        Node* tail = preHead;
        cur = head;
        while (cur)
        {
            tail->next = cur->next;
            tail = tail->next;
            cur->next = cur->next->next;
            cur = cur->next;
        }

        return preHead->next;
    }
};

2. 重排链表（中等）

把链表后半段反转，再合并起来：

链表长度是偶数：1 2 3 4    （2是中间节点）

1 2

4 3

合并起来：1 4 2 3

链表长度是奇数：1 2 3 4 5    （3是中间节点）

1 2 3

5 4（4 5反转）

合并起来：1 5 2 4 3

class Solution {
public:
    void reorderList(ListNode* head) {
        ListNode* mid = midNode(head);
        ListNode* l2 = reverseList(mid->next);
        mid->next = nullptr;
        ListNode* l1 = head;
        mergeLists(l1, l2);
    }

private:
    // 快慢指针找链表的中间节点，如果节点个数为偶数，取靠左的
    ListNode* midNode(ListNode* head)
    {
        ListNode* fast = head;
        ListNode* slow = head;
        // 慢指针每次走1步，快指针每次走2步
        // 如果节点个数为奇数，当快指针指向最后一个节点时，慢指针指向中间节点
        // 如果节点个数为奇数，当快指针指向倒数第二个节点时，慢指针指向靠左的中间节点
        while (fast->next && fast->next->next)
        {
            fast = fast->next->next;
            slow = slow->next;
        }
        return slow;
    }
    // 反转链表
    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;
    }
    // 合并链表
    void mergeLists(ListNode* l1, ListNode* l2)
    {
        ListNode* cur1 = l1;
        ListNode* cur2 = l2;
        while (cur1 && cur2)
        {
            ListNode* next1 = cur1->next;
            ListNode* next2 = cur2->next;
            cur1->next = cur2;
            cur2->next = next1;
            cur1 = next1;
            cur2 = next2;
        }
    }
};

3. K个一组翻转链表（困难）

头插法。

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        // 求出需要翻转多少组
        int n = 0;
        ListNode* cur = head;
        while (cur)
        {
            cur = cur->next;
            n++;
        }
        n /= k;

        // 重复n次：长度为k的链表翻转
        ListNode* preHead = new ListNode; // 哨兵节点
        ListNode* pre = preHead;
        cur = head;
        for (int i = 0; i < n; i++)
        {
            ListNode* tmp = cur;
            for (int j = 0; j < k; j++)
            {
                ListNode* next = cur->next;
                cur->next = pre->next;
                pre->next = cur;
                cur = next;
            }
            pre = tmp;
        }

        // 把不需要翻转的部分接上
        pre->next = cur;
        
        return preHead->next;
    }
};

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

WPF中数据绑定转换器Converter

WPF中数据绑定转换器Converter

使用场景&#xff1a;ViewModel中的数据如果跟View中的数据类型不匹配。 下面是以int类型调控是否可见为例子 步骤一&#xff1a;创建转换器类 在xaml中查看Converter的定义可以知道Converter是一个接口类型&#xff0c;因此转换器的类定义需要使用这个接口 internal class Vi…
阅读更多...
【UML】第13篇 序列图（2/2）——建模的方法

【UML】第13篇 序列图（2/2）——建模的方法

目录 三、序列图建模 3.1 概述 3.2 建模的步骤 3.3 举例说明步骤 1.确定主要场景和流程 2.确定参与的对象 3.绘制序列图 4.注意事项 3.4 特殊的情况 序列图是我个人认为&#xff0c;UML中最重要的图之一。 而且序列图&#xff0c;对于业务建模&#xff0c;也有非常好…
阅读更多...
echarts 柱状图

echarts 柱状图

注意点 1.y轴显示的序号和名称需要在数据中拼接&#xff0c;而不是在y轴data中拼接&#xff0c; 数据过多会导致下拉的时候&#xff0c;触发y轴formatter&#xff0c;更新序号&#xff0c;序号会重新排列&#xff0c;不准确。 2.需用到堆叠效果&#xff0c;三个柱子。如果想…
阅读更多...
PyTorch官网demo解读——第一个神经网络（3）

PyTorch官网demo解读——第一个神经网络（3）

上一篇&#xff1a;PyTorch官网demo解读——第一个神经网络&#xff08;2&#xff09;-CSDN博客 上一篇文章我们讲解了第一个神经网络的模型&#xff0c;这一篇我们来聊聊梯度下降。 大佬说梯度下降是深度学习的灵魂&#xff1b;梯度是损失函数&#xff08;代价函数&#xff…
阅读更多...
百度百科词条编辑需要提供参考资料，那么如何找参考资料呢。

百度百科词条编辑需要提供参考资料，那么如何找参考资料呢。

百度百科相信大家都不陌生&#xff0c;在查询一个概念、新事物&#xff0c;或者我们想要了解的企业和人物时&#xff0c;我们一般都会求助百度百科&#xff0c;因为百度百科上面的信息相较于其他平台更值得我们相信。从词条所属主体来说&#xff0c;百度百科平台也是向其他用户…
阅读更多...
20231224解决outcommit_id.xml1 parser error Document is empty的问题

20231224解决outcommit_id.xml1 parser error Document is empty的问题

20231224解决outcommit_id.xml1 parser error Document is empty的问题 2023/12/24 18:13 在开发RK3399的Android10的时候&#xff0c;出现&#xff1a;rootrootrootroot-X99-Turbo:~/3TB/Rockchip_Android10.0_SDK_Release$ make installclean PLATFORM_VERSION_CODENAMEREL…
阅读更多...
Ubuntu18.04安装GTSAM库（亲测可用）

Ubuntu18.04安装GTSAM库（亲测可用）

在SLAM&#xff08;Simultaneous Localization and Mapping&#xff09;和SFM&#xff08;Structure from Motion&#xff09;这些复杂的估计问题中&#xff0c;因子图算法以其高效和灵活性而脱颖而出&#xff0c;成为图模型领域的核心技术。GTSAM&#xff08;Georgia Tech Smo…
阅读更多...
不用再找了，这就是 NLP 方向最全面试题库

不用再找了，这就是 NLP 方向最全面试题库

大家好&#xff0c;本篇文章总结了自然语言处理(NLP)面试需要准备的学习笔记与资料&#xff0c;该资料目前包含自然语言处理各领域的面试题积累。 热门面试题&#xff08;校招、社招&#xff09;、公司级专项真题、大厂常考题等&#xff0c;在我们社群具有总结&#xff0c;喜欢…
阅读更多...
DevC++ easyx实现视口编辑，在超过屏幕大小的地图上画点，与解决刮刮乐bug效果中理解C语言指针的意义

DevC++ easyx实现视口编辑，在超过屏幕大小的地图上画点，与解决刮刮乐bug效果中理解C语言指针的意义

继上篇文案&#xff0c; DevC easyx实现地图拖动&#xff0c;超过屏幕大小的巨大地图的局部显示在屏幕的方法——用悬浮窗的原理来的实现一个视口-CSDN博客 实现了大地图拖动&#xff0c;但是当时野心不止&#xff0c;就想着一气能搓啥就继续搓啥&#xff0c;看着地图移动都搓…
阅读更多...
转录组无参比对教程

转录组无参比对教程

写在前面 2023年将结束&#xff0c;小杜的生信笔记分享个人学习笔记也有2年的时间。在这2年的时间中&#xff0c;分享算是成为工作、学习和生活中的一部分。自己为了运行和维护社群也算花费大量的时间和精力&#xff0c;自己认为还算满意吧。对于个人来说&#xff0c;自己一直…
阅读更多...
Docker介绍、常用命令与操作

Docker介绍、常用命令与操作

Docker介绍、常用命令与操作 学习前言为什么要学习DockerDocker里的必要基础概念常用命令与操作1、基础操作a、查看docker相关信息b、启动或者关闭docker 2、容器操作a、启动一个镜像i、后台运行ii、前台运行 b、容器运行情况查看c、日志查看d、容器删除 3、镜像操作a、镜像拉取…
阅读更多...
使用 Docker 部署企业培训系统 PlayEdu

使用 Docker 部署企业培训系统 PlayEdu

1&#xff09;PlayEdu 介绍 官网&#xff1a;https://www.playedu.xyz/ GitHub&#xff1a;https://github.com/PlayEdu/PlayEdu PlayEdu 是一款适用于搭建内部培训平台的开源系统&#xff0c;旨在为企业/机构打造自己品牌的内部培训平台。PlayEdu 基于 Java MySQL 开发&…
阅读更多...
C语言--直接插入排序【排序算法|图文详解】

C语言--直接插入排序【排序算法|图文详解】

一.直接插入排序介绍&#x1f357; 直接插入排序又叫简单插入排序&#xff0c;是一种简单直观的排序算法&#xff0c;它通过构建有序序列&#xff0c;对于未排序的数据&#xff0c;在已排序序列中从后向前扫描&#xff0c;找到相应位置并插入。 算法描述&#xff1a; 假设要排序…
阅读更多...
Golang实现JAVA虚拟机-运行时数据区

Golang实现JAVA虚拟机-运行时数据区

一、运行时数据区概述 JVM学习&#xff1a; JVM-运行时数据区 运行时数据区可以分为两类&#xff1a;一类是多线程共享的&#xff0c;另一类则是线程私有的。 多线程共享的运行时数据区需要在Java虚拟机启动时创建好&#xff0c;在Java虚拟机退出时销毁。对象实例存储在堆区类信…
阅读更多...
2023.12.22 关于 Redis 数据类型 String 常用命令

2023.12.22 关于 Redis 数据类型 String 常用命令

目录 引言 String 类型基本概念 SET & GET SET 命令 GET 命令 MSET & MGET MSET 命令 MGET 命令 SETNX & SETEX & PSETEX SETNX 命令 SETEX 命令 PSETEX 命令 计数命令 INCR 命令 INCRBY 命令 DECR 命令 DECRBY 命令 INCRBYFLOAT 命令 总结…
阅读更多...
【GoLang】Go语言几种标准库介绍(一)

【GoLang】Go语言几种标准库介绍(一)

你见过哪些令你膛目结舌的代码技巧&#xff1f; 文章目录 你见过哪些令你膛目结舌的代码技巧&#xff1f;前言几种库bufio&#xff08;带缓冲的 I/O 操作&#xff09;特性示例 bytes (实现字节操作)特性示例 总结专栏集锦写在最后 前言 随着计算机科学的迅猛发展&#xff0c;编…
阅读更多...
复试情报准备

复试情报准备

英语自我介绍&#xff0c;介绍完老师会根据你的回答用英语问你问题&#xff0c;比如介绍一下你的本科学校&#xff0c;或者家乡什么的。计网过一遍&#xff0c;会问两道题。接下来是重点&#xff0c;我当时是根据我成绩单&#xff0c;问了我本科学过的科目&#xff0c;比如pyth…
阅读更多...
【Docker容器精解篇 】深入探索Docker技术的概念与容器思想

【Docker容器精解篇 】深入探索Docker技术的概念与容器思想

&#x1f3ac; 鸽芷咕&#xff1a;个人主页 &#x1f525; 个人专栏: 《docker容器精解篇》《粉丝福利》 ⛺️生活的理想&#xff0c;就是为了理想的生活! 文章目录 前言一、Docker 的介绍1.1 Docker 的由来1.1.1 环境不一致1.1.2 隔离性1.1.3 弹性伸缩1.1.4 学习成本 1.2 Doc…
阅读更多...
推荐五个免费的网络安全工具

推荐五个免费的网络安全工具

导读&#xff1a; 在一个完美的世界里&#xff0c;信息安全从业人员有无限的安全预算去做排除故障和修复安全漏洞的工作。但是&#xff0c;正如你将要学到的那样&#xff0c;你不需要无限的预算取得到高质量的产品。这里有SearchSecurity.com网站专家Michael Cobb推荐的五个免费…
阅读更多...
网站检测有哪些好用的监测工具

网站检测有哪些好用的监测工具

目前网站监测工具良莠不齐&#xff0c;网站监控工具有很多&#xff0c;选择合适功能强大的网站监控工具&#xff0c;对我们的业务安全有非常大的帮助。目前市场上好用的一些网站监测工具如德迅云眼、观测云等&#xff0c;它们都提供了网站性能监测、安全防护、故障预警等功能&a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023