Offer必备算法12_链表_五道力扣题详解（由易到难）

news2025/9/20 22:27:26

目录

①力扣2. 两数相加

解析代码

②力扣24. 两两交换链表中的节点

解析代码

③力扣143. 重排链表

解析代码

④力扣23. 合并 K 个升序链表

解析代码1（小根堆优化）

解析代码2（递归_归并）

⑤力扣25. K 个一组翻转链表

解析代码

本篇完。

①力扣2. 两数相加

2. 两数相加

难度 中等

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例 1：

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.

示例 2：

输入：l1 = [0], l2 = [0]
输出：[0]

示例 3：

输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

提示：

  • 每个链表中的节点数在范围 [1, 100] 内
  • 0 <= Node.val <= 9
  • 题目数据保证列表表示的数字不含前导零
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {

    }
};

解析代码

        两个链表都是逆序存储数字的，即两个链表的个位数、十位数等都已经对应，可以直接相加。 在相加过程中要注意是否产生进位，产生进位时需要将进位和链表数字一同相加。如果产生进位的位置在链表尾部，即答案位数比原链表位数长一位，还需要再new一个结点储存最高位。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode *head = new ListNode(0);
        ListNode *ret = head;
        ListNode *cur1 = l1, *cur2 = l2;
        int carry = 0; // 进位
        while(cur1 || cur2 || carry)
        {
            int val = carry;
            if(cur1)
            {
                val += cur1->val;
                cur1 = cur1->next;
            }
            if(cur2)
            {
                val += cur2->val;
                cur2 = cur2->next;
            }
            head->next = new ListNode(val % 10);
            head = head->next;
            carry =  val / 10;
        }
        return ret->next;
    }
};

②力扣24. 两两交换链表中的节点

24. 两两交换链表中的节点

难度 中等

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

示例 1：

输入：head = [1,2,3,4]
输出：[2,1,4,3]

示例 2：

输入：head = []
输出：[]

示例 3：

输入：head = [1]
输出：[1]

提示：

  • 链表中节点的数目在范围 [0, 100] 内
  • 0 <= Node.val <= 100
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {

    }
};

解析代码

递归法在下面链接讲过：

Offer必备算法07_递归_五道力扣题详解（由易到难）-CSDN博客

        迭代法就是自己画图，不要吝啬定义指针，直接定义四个指针，在前面new一个头结点视为prev，让cur和next1交换，然后四个指针像后走，结束条件是cur或者next1为空。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode *newHead = new ListNode(0);
        if(head == nullptr || head->next == nullptr)
            return head;
        // newHead -> 1 -> 2 -> 3
        // 1和2换 -> cur和next1换
        // prev -> cur -> next1 -> next2
        // cur -> prev -> next1 -> next2
        ListNode *prev=newHead, *cur=head, *next1=head->next, *next2=next1->next;
        while(cur && next1)
        {
            prev->next = next1;
            next1->next = cur;
            cur->next = next2;

            prev = cur;
            cur = next2;
            if(cur)
                next1 = cur->next;
            if(next1)
                next2 = next1->next;
        }
        cur = newHead->next;
        delete newHead;
        return cur;
        // 递归法
        // if(head == nullptr || head->next == nullptr)
        //     return head;
        // ListNode* tmp = swapPairs(head->next->next); // 把两个结点之外的看成另一部分
        // head->next->next = head;
        // auto ret = head->next; // 保存一下要返回的结点
        // head->next = tmp;
        // return ret;
    }
};

③力扣143. 重排链表

难度 中等

给定一个单链表 L 的头节点 head ，单链表 L 表示为：

L0 → L1 → … → Ln - 1 → Ln

请将其重新排列后变为：

L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …

不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例 1：

输入：head = [1,2,3,4]
输出：[1,4,2,3]

示例 2：

输入：head = [1,2,3,4,5]
输出：[1,5,2,4,3]

提示：

  • 链表的长度范围为 [1, 5 * 10^4]
  • 1 <= node.val <= 1000
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    void reorderList(ListNode* head) {

    }
};

解析代码

在C语言讲的数据结构里讲过这三道OJ：

206. 反转链表

876. 链表的中间结点

21. 合并两个有序链表

这道题就是先找到中间结点，分为两部分链表，然后翻转后部分链表，最后合并两个链表：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    void reorderList(ListNode* head) {
        if(head==nullptr || head->next==nullptr || head->next->next==nullptr)
            return; // 处理边界情况

        ListNode *fast = head, *slow = head;
        while(fast && fast->next) // 找到中间结点
        {
            slow = slow->next;
            fast = fast->next->next;
        }

        ListNode* slowNext = slow->next;
        slow->next = nullptr; // 两个链表断开
        slow = slowNext;
        ListNode *reverseList = nullptr;
        while(slow) // 中间结点后面的头插到翻转链表
        {
            slowNext = slow->next;
            slow->next = reverseList;
            reverseList = slow;
            slow = slowNext;
        }

        ListNode* tmp = head; // 合并两个链表
        ListNode *cur1 = head->next, *cur2 = reverseList;
        while(cur1 && cur2)
        {
            tmp->next = cur2;
            tmp = tmp->next;
            cur2 = cur2->next;

            tmp->next = cur1;
            cur1 = cur1->next;
            tmp = tmp->next;
        }
    }
};

④力扣23. 合并 K 个升序链表

23. 合并 K 个升序链表

 难度 困难

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

示例 1：

输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
  1->4->5,
  1->3->4,
  2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6

示例 2：

输入：lists = []
输出：[]

示例 3：

输入：lists = [[]]
输出：[]

提示：

  • k == lists.length
  • 0 <= k <= 10^4
  • 0 <= lists[i].length <= 500
  • -10^4 <= lists[i][j] <= 10^4
  • lists[i] 按 升序 排列
  • lists[i].length 的总和不超过 10^4
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {

    }
};

解析代码1（小根堆优化）

        之前写过合并两个有序链表的题，此题暴力解法就是依次合并两个有序链表，合并K次。时间复杂度是O（N*K^2），是N^3级别的。

        在暴力解法基础上可以使用小根堆优化，合并 K 个升序链表时，选择 K 个链表中，头结点值最小的那⼀个的插入到新链表，时间复杂度是O（N*K*logK）。下面是小根堆优化的代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
    struct cmp
    {
        bool operator()(const ListNode* l1, const ListNode* l2)
        {
            return l1->val > l2->val;
        }
    };

public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        priority_queue<ListNode*, vector<ListNode*>, cmp> heap;

        for(auto& e : lists) // 所有头结点进入小根堆
        {
            if(e)
                heap.push(e);
        }
        ListNode* newHead = new ListNode(0);
        ListNode* tmp = newHead;
        while(!heap.empty())
        {   // 尾插堆顶结点到新链表，再把旧链表下个结点插入小根堆
            ListNode* cur = heap.top();
            heap.pop();
            tmp->next = cur;
            tmp = cur;
            if(cur->next)
            {
                heap.push(cur->next);
            }
        }
        tmp = newHead->next;
        delete newHead;
        return tmp;
    }
};

解析代码2（递归_归并）

  1. 递归出口：如果当前要合并的链表编号范围左右值相等，无需合并，直接返回当前链表。
  2. 应用二分思想，等额划分左右两段需要合并的链表，使这两段合并后的长度尽可能相等。
  3. 对左右两段分别递归，合并[left，right]范围内的链表。
  4. 最后调用合并两个链表函数进行合并。
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        return merge(lists, 0, lists.size() - 1);
    }

    ListNode* merge(vector<ListNode*>& lists, int left, int right)
    {
        if(left > right) // 区间不存在
            return nullptr;
        if(left == right) // 只有一个链表
            return lists[left];
        
        int mid = (left + right) >> 1;
        ListNode* list1 = merge(lists, left, mid);
        ListNode* list2 = merge(lists, mid+1, right);
        // 上面递归得到一个/两个链表
        return mergeTwoLists(list1, list2);
    }

    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(list2->next, list1);
            return list2;
        }
    }
};

⑤力扣25. K 个一组翻转链表

25. K 个一组翻转链表

 难度 困难

给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。

k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

示例 1：

输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]

示例 2：

输入：head = [1,2,3,4,5], k = 3
输出：[3,2,1,4,5]

提示：

  • 链表中的节点数目为 n
  • 1 <= k <= n <= 5000
  • 0 <= Node.val <= 1000

进阶：你可以设计一个只用 O(1) 额外内存空间的算法解决此问题吗？

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {

    }
};

解析代码

        可以把链表按 K 个为一组进行分组，组内进行反转，并且记录反转后的头尾结点，使其可以和前后连接起来。先求出⼀共需要逆序多少组（假设逆序 n 组），然后重复 n 次长度为 k 的链表的逆序即可。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        int n = 0;
        ListNode* cur = head;
        while(cur)
        {
            cur = cur->next;
            ++n;
        }
        n /= k;

        cur = head;
        ListNode* newHead = new ListNode();
        ListNode* prev = newHead;
        while(n--)
        {
            ListNode* tmp = cur;
            int cnt = k;
            while(cnt--)
            {
                ListNode* prevNext = cur->next;
                cur->next = prev->next; // cur头插到prev
                prev->next = cur;
                cur = prevNext;
            }
            prev = tmp;
        }
        prev->next = cur;
        cur = newHead->next;
        delete newHead;
        return cur;
    }
};

本篇完。

下一篇动态规划的类型的路径dp类型的OJ。

下下篇数据结构类型的是哈希表类型的OJ。

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

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

相关文章

【从部署服务器到安装autodock vina】

【从部署服务器到安装autodock vina】

注意&#xff1a;服务器 linux系统选用ubuntu 登录系统&#xff0c;如果没有图形化见面可以先安装图形化界面 可以参考该视频 --> linux安装图形化界面 非阿里云ubuntu 依次执行以下命令 sudo apt-get update sudo apt-get install gnome sudo reboot阿里云ubuntu 需多执…
阅读更多...
Glip模型

Glip模型

Yolos 完全使用Transformer做目标检测 Detr 先使用CNN提取特征然后再使用transformerDetr和Yolos共同的缺点：需要事先知道所有的类别 Glip Zero-shot, 目标检测的类别可以不在训练类别中目标框进行视觉编码，然后和文本进行匹配文本和视觉特征是通过Clip模型提取的，所以视觉向…
阅读更多...
从功能测试进阶自动化测试全套进阶指南，亲身经验分享

从功能测试进阶自动化测试全套进阶指南，亲身经验分享

因为我最近在分享自动化测试技术&#xff0c;经常被问到&#xff1a; 功能测试想转自动化&#xff0c;请问应该怎么入手&#xff1f;有没有好的资源推荐&#xff1f; 那么&#xff0c;接下来我就结合自己的经历聊一聊我是如何在工作中做自动化测试的。&#xff08;学习路线放…
阅读更多...
蓝桥杯python常用内置函数

蓝桥杯python常用内置函数

一、 abs() #返回数字的绝对值 例&#xff1a; 二、 all() #判断给定的可迭代参数中的所有元素是否都为True&#xff0c;若是则返回True&#xff0c;反之返回False 例&#xff1a; 三、 any() #判断给定的可迭代参数是否都为False&#xff0c;全为False则返回False&am…
阅读更多...
光明网发布稿件多少钱？新闻投稿低价渠道推荐，附光明网价格明细表

光明网发布稿件多少钱？新闻投稿低价渠道推荐，附光明网价格明细表

想要在光明网发稿&#xff1f;不知道费用是多少&#xff1f;媒介多多告诉你答案&#xff01; 在当今数字化时代&#xff0c;媒体平台的重要性日益突出&#xff0c;而光明网作为国内知名的新闻门户网站&#xff0c;吸引了大量的目标受众。许多企业和个人都希望能够在光明网上投…
阅读更多...
Dubbo-记录

Dubbo-记录

1.概念 Apache Dubbo 是一款 RPC 服务开发框架&#xff0c;用于解决微服务架构下的服务治理与通信问题&#xff0c;官方提供了 Java、Golang 等多语言 SDK 实现。使用 Dubbo 开发的微服务原生具备相互之间的远程地址发现与通信能力&#xff0c; 利用 Dubbo 提供的丰富服务治理…
阅读更多...
【SQL】550. 游戏玩法分析 IV (关键点：确定连续两次登录)

【SQL】550. 游戏玩法分析 IV (关键点：确定连续两次登录)

前述 常见函数用法示例&#xff1a; DATEDIFF(col1, col2) 1DATE_ADD(MIN(col), INTERVAL 1 DAY)ROUND(3.1415926,3) > 四舍五入得到 3.142 题目描述 leetcode原题&#xff1a;550. 游戏玩法分析 IV 思路 确定连续两次登录统计&#xff0c;保留两位小数 写法一 关键…
阅读更多...
FME快速批量提取图斑四至点，提取四至坐标，并输出shapefile数据的实现方法

FME快速批量提取图斑四至点，提取四至坐标，并输出shapefile数据的实现方法

目录 一、实现效果 二、实现过程 1.读取图斑 2.提取图斑坐标极值 3.提取图斑坐标 4.提取四至方位的坐标 5.创建四至点 6.输出成果 7.模板的使用 三、总结 在遇到需要提取图斑四至点的工作时&#xff0c;要如何进行方便快速的批量提取&#xff0c;方法有很多。今天…
阅读更多...
webhook详解

webhook详解

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 webhook简介 在当今高度连接的网络世界中,没有什么可以孤立地发挥最佳作用。完成一项任务(几乎)总是需要多个实体的参与。电子商务应用程序需要与支付系统通信,支付…
阅读更多...
【软件工程导论】——软工学绪论及传统软件工程（学习笔记）

【软件工程导论】——软工学绪论及传统软件工程（学习笔记）

&#x1f4d6; 前言&#xff1a;随着软件产业的发展&#xff0c;计算机应用逐步渗透到社会生活的各个角落&#xff0c;使各行各业都发生了很大的变化。这同时也促使人们对软件的品种、数量、功能和质量等提出了越来越高的要求。然而&#xff0c;软件的规模越大、越复杂&#xf…
阅读更多...
【react框架】跟我一起速读Next.js官方入门教学课程文档

【react框架】跟我一起速读Next.js官方入门教学课程文档

文章目录 前言目录结构样式方案正常引入样式文件Tailwind方案CSS Modules方案clsx方案 文字和图片优化文字图片 Pages和Layout的机制PagesLayout 通过Link组件改变路由并且拆分打包提供Hooks未完待续... 前言 对于那些对Next.js一无所知的前端伙伴来说&#xff0c;最佳的快速入…
阅读更多...
IPsec VPN配置方式

IPsec VPN配置方式

一、手工方式建立 手工方式建立IPsec的场景&#xff0c;全部参数需要手工配置&#xff0c;工作量大&#xff0c;适用于小型静态网络。 当企业总部与分支通过FW1和FW2之间建立的IPsec隧道进行安全通信。 手工配置步骤主要有四个&#xff1a; ①定义需要保护的数据流&#xff1…
阅读更多...
使用 Mendix 中的 OIDC 模块集成 Azure AD SSO

使用 Mendix 中的 OIDC 模块集成 Azure AD SSO

前言 在当今快速发展的数字化世界中&#xff0c;企业追求高效率和灵活性已成为常态。Mendix&#xff0c;作为一个先进的低代码开发平台&#xff0c;正是企业快速响应市场需求、加速数字化转型过程的利器。通过其直观的可视化开发环境&#xff0c;即使是非技术背景的用户也能设…
阅读更多...
c#触发事件

c#触发事件

Demo1 触发事件 <Window x:Class"WPFExample.MainWindow"xmlns"http://schemas.microsoft.com/winfx/2006/xaml/presentation"xmlns:x"http://schemas.microsoft.com/winfx/2006/xaml"Title"WPF Example" Height"600" Wi…
阅读更多...
谷歌 Gemma 安装教程

谷歌 Gemma 安装教程

目录 一、概述 二、安装 Ollama 三、安装 Docker 四、安装 Open WebUI 五、测试 结束 一、概述 Gemma 是谷歌推出了全新的开源模型。Gemma 是免费的&#xff0c;模型权重也一并开源了&#xff0c;并且允许商用&#xff0c;支持安装在本地&#xff0c;即使了断网依然使用…
阅读更多...
PyQt5开发基础知识【一】

PyQt5开发基础知识【一】

零.前言&#xff1a; 作者写这篇博客的目的主要在于巩固PyQt5的基础知识&#xff0c;例如PyQt5的几个核心模块&#xff0c;分别有什么功能&#xff0c;PyQt5的所有控件的使用方法等。 一.PyQt5的常见模块 1.1QtCore&#xff1a; 该模块包含了非GUI的功能设计。 这个模块被…
阅读更多...
二 centos 7.9 磁盘挂载

二 centos 7.9 磁盘挂载

上一步 一 windso10 笔记本刷linux cent os7.9系统-CSDN博客 笔记本有两个盘,系统装在128G的系统盘上,现在把另外一个盘挂载出来使用 lsblk 发现磁盘已经分好了,直接挂载就好了,参考文章:Centos7.9 挂载硬盘_centos7.9挂载硬盘-CSDN博客 永久挂载 lsblk -f分区格式化 mkfs…
阅读更多...
图形库实战丨C语言扫雷小游戏（超2w字，附图片素材）

图形库实战丨C语言扫雷小游戏（超2w字，附图片素材）

目录 效果展示 游玩链接&#xff08;无需安装图形库及VS&#xff09; 开发环境及准备 1.VS2022版本 2.图形库 游戏初始化 1.头文件 2.创建窗口 3.主函数框架 开始界面函数 1.初始化 1-1.设置背景颜色及字体 1-2.处理背景音乐及图片素材 1-3.处理背景图位置 2.选…
阅读更多...
数据结构从入门到精通——队列

数据结构从入门到精通——队列

队列 前言一、队列1.1队列的概念及结构1.2队列的实现1.3队列的实现1.4扩展 二、队列面试题三、队列的具体实现代码Queue.hQueue.ctest.c队列的初始化队列的销毁入队列出队列返回队头元素返回队尾元素检测队列是否为空检测元素个数 前言 队列是一种特殊的线性数据结构&#xff…
阅读更多...
141 Linux 系统编程18 ，线程，线程实现原理，ps –Lf 进程 查看

141 Linux 系统编程18 ，线程，线程实现原理，ps –Lf 进程 查看

一 线程概念 什么是线程 LWP&#xff1a;light weight process 轻量级的进程&#xff0c;本质仍是进程(在Linux环境下) 进程&#xff1a;独立地址空间&#xff0c;拥有PCB 线程&#xff1a;有独立的PCB&#xff0c;但没有独立的地址空间(共享) 区别&#xff1a;在于是否共…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023