第2周 数据结构-链表

最新推荐文章于 2021-09-27 14:44:27 发布
原创 最新推荐文章于 2021-09-27 14:44:27 发布 · 219 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

Leetcode 题解 - 链表

文章目录

链表部分经验谈
  1. 取next前一定先判断当前节点是否为NULL
  2. 更改next前先存个next的备份，否则可能导致无法访问后续节点
  3. 对链表进行分割时不但要关心头节点是否对，还要关心尾是否断开连接
  4. 关于链表的环或公共节点等问题可以往双指针+追及问题考虑
交换链表中的相邻结点

经验:适当定义局部变量减少代码中的->next可以增加代码可读性

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        /*
        思路：每两个一组，可迭代替换，也可递归
        时间复杂度：O(n)
        空间复杂度：O(1)
        */
        // 递归式
        // if(head == NULL || head->next == NULL)
        //     return head;
        // ListNode* tailSwaped = swapPairs(head->next->next);
        // ListNode* nextCopy = head->next;
        // head->next->next = head;
        // head->next = tailSwaped;
        // return nextCopy;

        // 迭代式
        if(head == NULL || head->next == NULL)
            return head;
        ListNode dummyHead = ListNode(0);
        ListNode* headCopy = &dummyHead, *tempHead = &dummyHead;
        tempHead->next = head;
        while(tempHead->next != NULL && tempHead->next->next != NULL){
            // headTemp后面有两个节点才发生交换，交换node1和node2
            ListNode* tailList = tempHead->next->next->next, *node1 = tempHead->next, *node2 = tempHead->next->next;
            node2->next = node1;
            node1->next = tailList;
            tempHead->next = node2;
            tempHead = node1;
        }
        return headCopy->next;
    }
};
链表求和
class Solution {
public:
    int getLen(ListNode* node){
        int len = 0;
        while(node != NULL){
            len += 1;
            node = node->next;
        }
        return len;
    }

    int sumHelper(ListNode* num1, ListNode* num2, int diff){
        // 如果diff<=0，则说明此时的链表num1,num2已经等长
        // 否则num1还比num2更长，还不能直接加
        if(num1 == NULL && num2 == NULL)
            return 0;

        int v1 = num1->val;
        int v2 = diff > 0 ? 0 : num2->val;
        int carry;

        if(diff > 0)
            carry = sumHelper(num1->next, num2, diff-1);
        else
            carry = sumHelper(num1->next, num2->next, diff-1);

        int sum = v1 + v2 + carry;
        num1->val = sum % 10;
        return sum / 10;
    }

    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        /*
        思路：不用栈中转，直接对链表进行相加
        时间复杂度：O(n)
        空间复杂度：O(1)
        */

        // 使得num1的长度不小于num2
        int len1 = getLen(l1), len2 = getLen(l2);
        if(len2 > len1)
            swap(l1, l2);
        int diff = abs(len1 - len2);

        // 链表前增加一个0
        ListNode* num1 = new ListNode(0);
        num1->next = l1;
        diff += 1;

        // 第一个值是0，直接把进位加上就行
        num1->val += sumHelper(num1->next, l2, diff-1);

        return num1->val == 0 ? num1->next : num1;

        // /*
        // 思路：用栈做中转，先将两个链表转入两个栈中，由于栈顶存的低位数所以可以直接对两个栈做加法，将相加后的结果存入栈中，最后再将栈转为链表。
        // 时间复杂度：O(n)
        // 空间复杂度：O(n)
        // */
        // stack<int> sk1, sk2, sum;
        // while(l1 != NULL){
        //     sk1.push(l1->val);
        //     l1 = l1->next;
        // }
        // while(l2 != NULL){
        //     sk2.push(l2->val);
        //     l2 = l2->next;
        // }
        // int carry = 0, tempSum;  // 存进位
        // while(!sk1.empty() || !sk2.empty()){
        //     if(!sk1.empty() && !sk2.empty()){
        //      tempSum = sk1.top() + sk2.top() + carry;
        //      sk1.pop();
        //      sk2.pop();
        //     }
        //     else if(sk1.empty()){
        //      tempSum = sk2.top() + carry;
        //      sk2.pop();
        //     }
        //     else if(sk2.empty()){
        //      tempSum = sk1.top() + carry;
        //      sk1.pop();
        //     }
        //     carry = tempSum / 10;
        //     sum.push(tempSum % 10);
        // }
        // if(carry > 0)
        //     sum.push(carry);
        // ListNode* head = new ListNode(sum.top());
        // ListNode* ans = head;
        // sum.pop();
        // while(!sum.empty()){
        //     head->next = new ListNode(sum.top());
        //     head = head->next;
        //     sum.pop();
        // }
        // return ans;
    }
};
回文链表

思路一：用栈，先得到链表的倒序，然后逐个对比
思路二：在遍历链表的同时，进行反转，如果发现当前节点可能是回文字符串的中心就进行对比
思路三：先用快慢指针找链表中心节点，然后再翻转前半部分，然后判断是否为回文字符串（未实现）

class Solution {
public:
    bool compare(ListNode* a, ListNode* b){
        if(a == NULL && b == NULL)
            return true;
        if(a == NULL || b == NULL)
            return false;
        return a->val == b->val && compare(a->next, b->next);
    }

    bool isPalindrome(ListNode* head) {
        /*
        思路：遍历链表的过程中反转链表，并且寻找链表的中间节点
        时间复杂度：O(n)
        空间复杂度：O(1)
        */
        if(head == NULL || head->next == NULL)
            return true;

        ListNode* revHead = NULL;
        ListNode* seqHead = head;

        while(seqHead != NULL){
            ListNode* seqNext = seqHead->next;
            seqHead->next = revHead;
            revHead = seqHead;
            seqHead = seqNext;
            if(compare(seqHead, revHead))
                return true;
            if(seqHead != NULL && compare(seqHead->next, revHead))
                return true;
        }
        return false;


    }
    bool isPalindrome_stack(ListNode* head) {
        /*
        思路：将链表的值逐个存入栈中，栈弹出的顺序即为反序，然后将其和原始链表对比
        时间复杂度：O(n)
        空间复杂度：O(n)
        */
        stack<int> sk;
        ListNode* headCopy = head;
        while(headCopy != NULL){
            sk.push(headCopy->val);
            headCopy = headCopy->next;
        }
        while(head != NULL){
            if(head->val != sk.top())
                return false;
            head = head->next;
            sk.pop();
        }
        return true;
    }
};
分隔链表

注意：不单单是将子链表的头节点存入数组，还要把后面的部分断掉

class Solution {
public:
    vector<ListNode*> splitListToParts(ListNode* root, int k) {
        /*
        思路：先根据链表长度和k算出指针数组中子链表的长度
        时间复杂度：O(n)
        空间复杂度：O(n)
        */
        if(root == NULL){
            vector<ListNode*> ans;
            for(int i = 0;i < k; i++)
                ans.push_back(NULL);
            return ans;
        }

        int len = 0;
        ListNode* head = root;
        while(head != NULL){
            len += 1;
            head = head->next;
        }
        vector<int> lens(k, len/k);
        int remain = len % k;
        for(int i = 0;i < remain; i++)
            lens[i] += 1;

        vector<ListNode*> ans;
        for(int i = 0;i < k; i++){
            ans.push_back(root);
            int temp_len = 0;
            ListNode* lastElem;
            while(temp_len < lens[i]){
                temp_len += 1;
                lastElem = root;
                root = root->next;
            }
            lastElem->next = NULL;
        }
        return ans;
    }
};
链表元素按奇偶聚集
class Solution {
public:
    ListNode* oddEvenList(ListNode* head) {
        /*
        思路：创建两个新的head，分别连接奇节点和偶节点
        时间复杂度：O(n)
        空间复杂度：O(1)
        */
        if(head == NULL || (head != NULL && head->next == NULL))
            return head;
        ListNode* oddHead = head;
        ListNode* evenHead = head->next;
        ListNode* oddHeadCopy = oddHead, *evenHeadCopy = evenHead;
        head = head->next->next;
        int cnt = 3;
        while(head != NULL){
            if(cnt % 2 == 1){
                oddHead->next = head;
                oddHead = oddHead->next;
            }
            else{
                evenHead->next = head;
                evenHead = evenHead->next;
            }
            head = head->next;
            cnt += 1;
        }
        oddHead->next = evenHeadCopy;
        evenHead->next = NULL;
        return oddHeadCopy;
    }
};
C语言数据结构-链表
2302_81072215的博客
11-26 2083
图中指针变量plist保存的是第一个结点的地址，我们称plist此时“指向”第一个结点，如果我们希望plist“指向”第二个结点时，只需要修改plist保存的内容为0x0012FFA0.在前面说的单链表中的“头结点”，该头结点是链表的首节点（第一个结点），实际这样的称呼是错误的，因为链表中存在一种链表叫做带头链表（不是指链表里第一个有效的结点），这里的头结点指的是，在这里直接使用plist来遍历结果也是一样的，重新创建个pcur指针，是为了避免由于指针指向的改变，导致无法重新找到链表的首结点。
Leetcode 24:两两交换链表中的节点（最详细解决方案！！！）
coordinate的博客
06-13 8652
给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。 示例: 给定 1-&gt;2-&gt;3-&gt;4, 你应该返回 2-&gt;1-&gt;4-&gt;3. 说明: 你的算法只能使用常数的额外空间。 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。 解题思路 我们首先需要建立pre、node1、node2和lat四个指针即可。 cur nod...
数据结构Week2-1：线性表的顺式和链式表达
QXK_Jack的博客
02-25 662
问题引入：如何表示多项式： 方法一： 数组分量对应多项式各项： A[ i ]=表示第 i 项数的系数，下表表示次数 ？缺点：数组不能太大，浪费空间 方法二： 顺序存储结构表示非零项， 相加过程：从头开始，比较两个多项式当前对应项的指数，返回指数大的，如果两指数相等，则返回系数和。类似归并排序的那种思路。 方法三： 链表结构存储非0项。 线性表 ： 由同类型数据元素构成...
将链表所有目标字符聚在一起，求最小交换次数 (由Leetcode 1151想到的)
Stupid_human的博客
09-26 578
题目描述： 将一个链表通过交换节点位置的操作使链表中的value为k的节点都聚集在一起，给出最少需要的交换次数。 输入描述： 第一行为链表的长度，取值范围为1~1000 第二行为链表的节点，如 1 2 3 代表1->2->3，每个节点value为整数，取值范围0~10000 第三行为k 输出描述： 输出需要的最少交换次数 例子： 输入： 5 1 2 1 2 1 2 输出： 1 解法： 这道题其实链表和数组是一样的，所以直接用数组来存即可。 一开始的思路是，找出这个数
leetcode之链表十二: 1721-交换链表中的节点
infi
05-03 210
原题:https://leetcode-cn.com/problems/swapping-nodes-in-a-linked-list/ 一、题目要求 给你链表的头节点head和一个整数k。 交换链表正数第k个节点和倒数第k个节点的值后，返回链表的头节点（链表从 1 开始索引）。 示例 1： 输入：head = [1,2,3,4,5], k = 2 输出：[1,4,3,2,5] 示例 2： 输入：head = [7,9,6,6,7,8,3,0,9,5], k...
【链表*】交换结点
It's the Climb
06-21 6240
只要涉及到链表结点的删除或交换，就必须新建虚拟头结点newHead->next=head，让f指针指向newHead作为前置结点指针（删除和交换都需要前置结点指针的），newHead当然不动，程序最后返回的是newHead->next。 两个两个地交换结点 两个两个地就地交换结点。 大致思路： 一定要先新建一个虚拟结点newHead，newHead->nex...
关于链表的常见算法题(二)
weixin_33796177的博客
06-17 416
关于链表的常见算法题(一) 关于链表的常见算法题(二) 从有序链表中删除重复的节点 给定一个有序链表，请删除其中的重复元素，使得这个元素仅出现一次 Input: 1->1->2->3->3 Output: 1->2->3 复制代码其实这个题比上篇讲的juejin.im/post/5d067f…中删除重复的节点还要容易一些，因为在此处，有重复的值时，是保留一个...
第11章 动态数据结构-链表-21
08-03
在本章中，我们探讨了如何使用C语言实现动态数据结构——单向链表。单向链表是一种线性数据结构，其中每个节点包含数据以及指向下一个节点的指针。以下是一些关于单向链表的关键知识点： 1. **节点定义**：在C语言...
数据结构-链表.pdf
08-15
数据结构-链表 数据结构是计算机科学和信息技术领域中的一个基础概念，指的是数据在计算机中的组织和存储方式。链表是数据结构中的一种重要类型，广泛应用于计算机科学和信息技术领域。 数据结构可以分为两大类：...
数据结构-图书管理系统-链表
最新发布
01-02
在实际的系统设计中，链表需要和其他数据结构或算法相结合，例如为了提高检索效率，可以在链表的基础上结合二分查找算法，或者使用跳表等更加高级的数据结构。 链表作为数据结构中的一种，无论是在理论教学还是实际...
数据结构-链表的C语言使用
03-25
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在处理动态数据集合时。在C语言中，链表不像是数组那样在内存中连续存储元素，而是通过一系列分散的内存块（称为节点）来表示数据。每个...
字节跳动2022秋招研发笔试题(2)--链表聚集交换问题
江七
09-27 330
时间限制: C/C++ 1秒，其他语言2秒 空间限制: C/C++ 32768K，其他语言 65536K 题目描述： 将一个链表通过交换节点位置的操作使链表中的 value 为 k 的节点都聚集到一起,给出最少需要的交换次数 输入描述: 输入第一行为链表的长度，取值范围1~1000 输入第二行为链表的节点，如1 23代表链表1->2->3，每个节点value为整数，取值范围0~10000 输入第三行为k 输出描述: 输出需要的最少交换次数 示例 输入： 5 1 2 .
链表-结点间交换
myblog
05-19 1300
利用第三个变量实现交换，冒泡法进行排序。
给定一个链表，交换每两个相邻节点并返回其头部。
i_am_bird的博客
11-28 1457
本题源自leetcode 24 ---------------------------------------------------------------------- 思路1： 创建一个头节点。然后从头结点之后开始遍历，每次翻转俩个节点，并保留前驱指针。最后返回头结点的下一个节点。 思路2： 用一个指针的指针来保留第一个节点。每次交换完，把双指针节点更新为下一次要交换的第一个节点。
Leetcode016--链表相邻元素进行交换
蜕变的快乐
12-07 3323
将两个链表的相邻元素进行交换
单链表交换节点算法
糖炒栗子的博客
08-04 6465
单链表  #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef struct Node { int data; struct Node *next; }* LinkList,LinkNode; void Init(LinkList *L) { int i; *L=(LinkList)malloc(s...
链表节点交换
wxxgreat的专栏
07-08 1422
链表节点定义如下：
双向链表的节点交换
crazybears的专栏
09-19 7817
这两天关于双向链表的节点的交换,用了很长的时间去学习,理解,敲了好多次,总是达不到效果,就是能想明白,但是在写的时候不是出现这样就是那样的问题,最后参照另外一位优快云博主的帖子,才写出一个完整的函数, 贴上代码,以便自己以后随时查看,没有图. void swap(USERINFO *head,USERINFO *left,USERINFO *right) { USERINFO *temp...
Leetcode 题解 - 链表
Cybenko
06-30 354
链表是空节点，或者有一个值和一个指向下一个链表的指针，因此很多链表问题可以用递归来处理。 找出两个链表的交点 160. Intersection of Two Linked Lists (Easy) A: a1 → a2 ↘ c1 → c2 → c3 ↗ B: b1 → b2 → b3 要求：时间复杂度为 O(N)，空间复杂度为 O(1) 设 A 的长度为 a
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值