手撕代码之链表

最新推荐文章于 2024-05-06 16:18:35 发布
最新推荐文章于 2024-05-06 16:18:35 发布
阅读量1k 收藏 12
点赞数 3
分类专栏： # 手撕代码 文章标签： 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/daaikuaichuan/article/details/89155180
版权

文章目录

  【注意1】：对于链表的问题，根据以往的经验一般都是要建一个dummy node，连上原链表的头结点，这样的话就算头结点变动了，我们还可以通过dummy->next来获得新链表的头结点。。

  【注意2】：链表的问题很多都可以使用双指针解决，有时候是快慢指针。

// 创建链表和输出链表
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

struct ListNode
{
	int val;
	ListNode *next;
	ListNode(int value) : val(value), next(nullptr) { }
};

ListNode *test_fun(ListNode *l1) {

}

int main() {
	vector<int> data1 = { 2,4,3 };
	ListNode *head1 = new ListNode(data1[0]), *ptr1 = head1;
	for (int i = 1; i < data1.size(); ++i) {
		ListNode *tmp1 = new ListNode(data1[i]);
		ptr1->next = tmp1;
		ptr1 = tmp1;
	}
	ptr1->next = nullptr;
	
	ListNode *ptr_tmp = test_fun(head1);
	while (ptr_tmp) {
		cout << ptr_tmp->val << endl;
		ptr_tmp = ptr_tmp->next;
	}
	system("pause");
	return 0;
}

一、反转链表（leetcode 206）

在这里插入图片描述
  思路：用两个指针记录下当前指针的前驱和后继，然后不断更新指针的指向，保存当前结点的下一个结点，防止链表断裂找不到后继。

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        // 用两个指针记录下当前指针的前驱和后继，然后不断更新指针的指向
        ListNode *pPre = nullptr, *pNext; 
        while (head != nullptr){
            // 保存当前结点的下一个结点，防止链表断裂找不到后继
            pNext = head->next;
            // 修改当前结点的指向
            head->next = pPre;
            // 更新指针
            pPre = head;
            head = pNext;
        }
        return pPre;
    }
};

二、两个链表的交点（leetcode 160）

在这里插入图片描述
  思路：先计算两个链表的长度，让长度较长的链表先走一段距离，之后两个结点齐头并进，如果相遇则找到相交的结点了。

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        int len1 = 0, len2 = 0;
        ListNode *tmpA = headA;
        ListNode *tmpB = headB;
        // 先计算两个链表的长度
        while (tmpA != nullptr){
            len1++;
            tmpA = tmpA->next;
        }
        while (tmpB != nullptr){
            len2++;
            tmpB = tmpB->next;
        }
        if (len1 > len2){
            int tmp = len1 - len2;
            // 让长度较长的链表先走一段距离
            for (int i = 0; i < tmp; ++i)
                headA = headA->next;
            // 之后两个结点齐头并进，如果相遇则找到相交的结点了
            while (headA != nullptr && headB != nullptr){
                if (headA == headB)
                    return headA;
                headA = headA->next;
                headB = headB->next;
            }
        }
        else{
            int tmp = len2 - len1;
            for (int i = 0; i < tmp; ++i)
                headB = headB->next;
            while (headB != nullptr && headA != nullptr){
                if (headB == headA)
                    return headB;
                headA = headA->next;
                headB = headB->next;
            }
        }
        return nullptr;
    }
};

三、链表的中间结点（leetcode 876）

在这里插入图片描述
  思路：快慢指针，快指针每次走两步，慢指针每次走一步，当快指针到头了，那么慢指针就是中间结点。

class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        ListNode *pTmp = head;
        while (head != nullptr && head->next != nullptr){
            // 快慢指针，快指针每次走两步，慢指针每次走一步，当快指针到头了，
            // 那么慢指针就是中间结点
            pTmp = pTmp->next;
            head = head->next->next;
        }
        return pTmp;
    }
};

四、判断链表是否存在环（leetcode 141）

在这里插入图片描述
  思路：快慢指针，快指针每次走两步，慢指针每次走一步，当快慢指针相遇时，即链表存在环。

class Solution {
public:
    bool hasCycle(ListNode *head) {
        // 快慢指针
	    ListNode *pSlow = head, *pFast = head;
	    while (pSlow != nullptr && pFast != nullptr && pFast->next != nullptr)
	    {
	    	pSlow = pSlow->next;
	    	pFast = pFast->next->next;
            // 当快慢指针相遇时，即链表存在环
            if (pSlow == pFast)
	    		return true;
		}
		return false;
    }
};

五、输出链表环的入口结点（leetcode 142）

在这里插入图片描述
  思路：先使用快慢指针找到相遇的结点，将慢指针移动到头结点，然后快慢指针前进速度变为一样，之后再相遇则为入口结点。
在这里插入图片描述
  图中，head到环路起点的距离为K，起点到fast和slow的相遇点的距离为M，环路周长为L。假设，在fast和slow相遇时，fast走过了Lfast，slow走过了Lslow。根据题意：Lslow=K+M；Lfast=K+M+nL（n为正整数）；Lfast=2Lslow。可以推出：Lslow=nL；K=nL-M。则当slow重新回到head，而fast还在相遇点，slow和fast都向前走，且每次走一个节点。则slow从head走到起点走了K，而fast从相遇点出发也走了K，而fast向前走了距离K后到了哪里呢？由于K=（n-1）*L+（L-M），所以fast转了n-1圈，再走L-M，也到了起点。这样起点就找到了。

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *pSlow = head, *pFast = head;
        // 先使用快慢指针找到相遇的结点
        while (pFast != nullptr && pFast->next != nullptr){
            pSlow = pSlow->next;
            pFast = pFast->next->next;
            if (pSlow == pFast)
                break;
        }
        if (pFast == nullptr || pFast->next == nullptr)
            return nullptr;
        // 将慢指针移动到头结点，然后快慢指针前进速度变为一样，之后再相遇则为入口结点
        pSlow = head;
        while (pSlow != pFast){
            pSlow = pSlow->next;
            pFast = pFast->next;            
        }
        return pSlow;
    }
};

六、删除链表中倒数第k个节点（leetcode 19）

在这里插入图片描述
  思路：使用双指针，让其中一个指针先走K步，当它到达链表尾部了，则另一个指针为倒数第K个结点。

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        if (head == nullptr) return nullptr;
        ListNode *p1 = head, *p2 = head;
        // 使用双指针找到倒数第K个结点
        for (int i = 0; i < n; ++i){
            p2 = p2->next;
        }
        if (p2 == nullptr)
            return head->next;
        while (p2->next != nullptr){
            p1 = p1->next;
            p2 = p2->next;
        }
        // 删除第K个结点
        p1->next = p1->next->next;
        return head;
    }
};

七、合并两个排序链表（leetcode 21）

在这里插入图片描述
  思路：新链表的头结点是两个链表中较小的一个，头结点的下一个结点则是由原来较小的链表的下一个结点和原来较长的链表产生，是一个递归过程。

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode *pHead;
        // 某一个链表为空则返回较长的那个
        if (l1 == nullptr) return l2;
        if (l2 == nullptr) return l1;
        if (l1->val <= l2->val){
            // 新链表的头结点是两个链表中较小的一个
            pHead = l1;
            // 新链表的下一个结点则是由原来较小的链表的下一个结点和原来较长的链表产生
            pHead->next = mergeTwoLists(l1->next, l2);
        }
        else{
            pHead = l2;
            pHead->next = mergeTwoLists(l1, l2->next);               
        }
        return pHead;
    }
};

八、O(1)时间删除链表中的一个结点（leetcode 237）

在这里插入图片描述
  思路：保存当前结点的下一个结点，把下一个结点复制给当前结点，删除下一个结点。

class Solution {
public:
    void deleteNode(ListNode* node) {
        // 保存当前结点的下一个结点
        ListNode *pTemp = node->next;
        // 把下一个结点复制给当前结点
        node->val = pTemp->val;
        node->next = pTemp->next;
        // 删除下一个结点
        delete pTemp;
        pTemp = nullptr;
    }
};

九、删除重复的结点（leetcode 83）

在这里插入图片描述
  思路：双指针，记录下一个结点是否和当前结点相等，如果两个结点相等，则删除后面一个结点。

class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if (head == nullptr || head->next == nullptr) return head;
        // 双指针，记录下一个结点是否和当前结点相等，如果两个结点相等，则删除后面一个结点
        ListNode *p1 = head, *p2 = head->next;
        while (p2 != nullptr){
            if (p1->val == p2->val){
                p1->next = p2->next;
                p2 = p2->next;
            }else{
                p1 = p1->next;
                p2 = p2->next;
            }
        }
        return head;
    }
};

十、删除链表中所有指定的节点（leetcode 203）

在这里插入图片描述
  思路：对于要删除节点的题目，可以先创建一个不存在的新节点。至于本题，对于当前的指针，如果下一个节点值和当前想等，则直接移动指针指向。

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        if (head == nullptr) return head;
        // 创建一个不存在的新节点
        ListNode* ptr_newhead = new ListNode(-1);
        ptr_newhead->next = head;
        ListNode *cur = ptr_newhead;
        while (cur != nullptr && cur->next != nullptr) {
            // 遇到相同的元素则移动当前指针的指向
            if (cur->next->val == val){
                cur->next = cur->next->next;
            } else {
                cur = cur->next;
            }
        }
        return ptr_newhead->next;
    }
};

十一、链表重排/对折（leetcode 143）

在这里插入图片描述
  思路：分三步走：第一步，使用快慢指针找到中间节点；第二步，翻转后半段；第三步，将两段连接起来。
在这里插入图片描述

class Solution {
public:
    void reorderList(ListNode* head) {
        if (head == nullptr || head->next == nullptr) return;
        // 先使用快慢指针找到中间节点
        ListNode *fast = head, *slow = head;
        while (fast->next != nullptr && fast->next->next != nullptr) {
            slow = slow->next;
            fast = fast->next->next;
        }
        // 然后翻转后半部分的链表
        ListNode *cur = slow->next;
        slow->next = nullptr;
        ListNode *cur_pre = nullptr;
        while (cur != nullptr) {
            ListNode *cur_next = cur->next;
            cur->next = cur_pre;
            cur_pre = cur;
            cur = cur_next;
        }
        // 最后将两段链表插空连接起来
        ListNode *first = head, *second = cur_pre;
        while (first != nullptr && second != nullptr) {
            ListNode *first_next = first->next;
            first->next = second;
            ListNode *second_next = second->next;
            second->next = first_next;
            first = first_next;
            second = second_next;
        }
    }
};

十二、链表排序（leetcode 148）

在这里插入图片描述
  思路：使用快排对链表排序。

class Solution {
public:
    ListNode* sortList(ListNode* head) {
        QuickSortList(head, nullptr);
        return head;
    }
    // 分别对前半部分和后半部分排序
    void QuickSortList(ListNode* pBegin, ListNode* pEnd) {
        if (pBegin != pEnd){
            ListNode *pMid = partition(pBegin, pEnd);
            QuickSortList(pBegin, pMid);
            if (pMid->next)
                QuickSortList(pMid->next, pEnd);
        }
    }
    // 一次划分（和数组类似）
    ListNode* partition(ListNode* pBegin, ListNode* pEnd){
        ListNode *pMid = pBegin, *pTmp = pMid->next;
        while (pTmp != pEnd){
            if (pTmp->val < pBegin->val){
                pMid = pMid->next;
                swap(pMid->val, pTmp->val);
            }
            pTmp = pTmp->next;
        }
        swap(pMid->val, pBegin->val);
        return pMid;
    }
};

十三、调整链表顺序使奇数位置的结点位于偶数位置结点的前面（leetcode 328）

在这里插入图片描述
  思路：用两个奇偶指针分别指向奇偶节点的起始位置，用一个单独的指针even_head来保存偶节点的起点位置，然后把奇节点的指向偶节点的下一个(一定是奇节点)，把奇节点后移一步，再把偶节点指向下一个奇节点的下一个(一定是偶节点)，把偶节点后移一步，以此类推直至末尾，此时把分开的偶节点的链表连在奇节点的链表后即可。

class Solution {
public:
    ListNode* oddEvenList(ListNode* head) {
        if (!head || !head->next) return head;
        ListNode *odd = head, *even = head->next, *even_head = even;
        while (even != nullptr && even->next != nullptr){
            odd = odd->next = even->next;
            even = even->next = odd->next;
        }
        odd->next = even_head;
        return head;
    }
};

十四、合并k个有序链表（leetcode 23）

在这里插入图片描述
  思路：使用优先队列存储k个链表的每一个元素，它们会自动排好序，然后重新建立一个新的链表。

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        // 使用优先队列存储k个链表的每一个元素，它们会自动排好序
        priority_queue<int, vector<int>, greater<int>> pq;
        for (auto node : lists) {
            while (node) pq.push(node->val), node = node->next;
        }
        // 先创建一个首节点
        ListNode *ptr_pre = new ListNode(-1), *ptr = ptr_pre;
        while (!pq.empty()) {
            ListNode *node = new ListNode(pq.top());
            ptr->next = node;
            ptr = ptr->next;
            pq.pop();
        }
        return ptr_pre->next;
    }
};

十五、部分翻转链表（leetcode 92）

在这里插入图片描述
  思路：建一个dummy node，连上原链表的头节点，定义pre、cur节点。后续的操作是先取出当前节点的下一个节点，然后插入到要翻转的位置上，不断把后面的元素插入到前面。

class Solution {
public:
    ListNode *reverseBetween(ListNode *head, int m, int n) {
        // 建一个dummy node，连上原链表的头结点
        ListNode *dummy = new ListNode(-1), *pre = dummy;
        dummy->next = head;
        for (int i = 0; i < m-1; ++i)
            pre = pre->next;
        ListNode *cur = pre->next;
        // 后续的操作是先取出当前节点的下一个节点，然后插入到要翻转的位置上，不断把后面的元素插入到前面
        for (int i = m; i < n; ++i) {
            ListNode *tmp = cur->next;
            cur->next = tmp->next;
            tmp->next = pre->next;
            pre->next = tmp;
        }
        return dummy->next;
    }
};

十六、链表相加（leetcode 2）

在这里插入图片描述
  思路：每次加完之后，创造一个新的结点，让当前结点指向它，并移动当前结点。

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        int carry = 0, sum = 0;
        // 先创造一个前驱结点，并赋值给当前结点
        ListNode *ptr_pre = new ListNode(-1);
        ListNode *ptr = ptr_pre;
        while (l1 || l2 || carry){
            if (l1){
                sum += l1->val;
                l1 = l1->next;
            }
            if (l2){
                sum += l2->val;
                l2 = l2->next;
            }
            if (carry){
                sum += carry;
                carry = 0;
            }
            // 计算进位
            carry = sum / 10;
            sum %= 10;
            // 创造一个新的结点，让当前结点指向它，并移动当前结点
            ptr->next = new ListNode(sum);
            ptr = ptr->next;
            sum = 0;
        }
        ptr->next = nullptr;
        // 返回前驱结点的下一个结点
        ptr = ptr_pre->next;
        return ptr;
    }
};
~青萍之末~
关注
  • 3
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
用BIND建立DNS服务器
邢明权博客
04-09 1473
<br />DNS (域名解析服务) 是将 IP 地址与 FQDN(fully qualified domain name，全称域名) 相互转换的一种 Internet 服务。通过DNS，人们可以无需记忆 IP 地址。运行 DNS 的计算机称作 域名服务器。DNS是网络服务的基础，感觉即简单又繁琐，有点琢磨不透的感觉。<br /><br />一、DNS域名解析简要过程<br />比如客户机clinet向本地域名服务器ns请求解析www.abc.com.cn的简要过程：<br />1、clinet向ns请求解
Leetcode 143 链表对折
changqing1234的专栏
11-07 3069
思路： 1. 通过快慢指针，一个步长为1， 一个步长为2， 找到链表中点。 2. 前/后 半段链表反转。 3. 与另一半链表归并插入。 class Solution: def reorderList(self, head): """ :type head: ListNode :rtype: void Do not return an...
leecode--链表对折
Tom098的博客
07-05 817
面试中问了一个链表对折的问题，写的完全不着边。后来百度了一下，自己根据原理重新写了一下。 package leecode; public class FoldLinkedList { public static void main(String[] args) { Node node1 = new Node(1); Node node2 = new Node(2); Node node3 = new Node(3); Node.
「Java 数据结构」：手撕单链表的增删改查及大厂面试题。_java手撕单链表
最新发布
2401_84182758的博客
05-06 392
将新的结点添加到链表的尾部，我们首先要遍历链表，找到链表的尾部，然后将最后一个结点的next指向新的结点，新结点的next指向NULL，这样就完成了链表的添加操作，这种每次添加到链表的尾部的操作称为尾插法。假设我们要删除中间这个结点，我们只需要将这个结点的上一个结点的next指向这个结点的下一个结点（也就是将第一个结点的next指向第三个结点）。我们可以定义一个计数的变量count，初始化为0，然后循环遍历链表，每遍历到一个结点，count就加一，这样就能求出单链表的有效个数。
常用的链表手撕代码整理
weixin_42145502的博客
08-10 257
具体参考大佬的：https://blog.csdn.net/qq_37466121/article/details/88204678 #include <iostream> #include <vector> using namespace std; struct listnode{ int val; listnode* next; //listnode(int x):val(x),next(NULL){} }; listnode * createnode(int
面试手撕代码全集（链表）
weixin_44739750的博客
09-16 292
链表
面试手撕代码整理
09-29
自己整理的在面试时可能出现的手撕代码题目，例如求一个数的平方根，反转链表，辗转相除法求最大公约数等，希望能提供一些帮助
校招面试手撕代码.zip
11-14
《校招面试手撕代码》是一份专门为大学毕业生准备的面试资源，主要涵盖了编程面试中的核心问题和解题策略。这份资料以"CodingInterviewChinese2-master"为项目名称，暗示了其是某个代码库的主分支，可能包含了多个子...
手撕代码_C语言手撕_C++_手撕代码c++_
10-01
在IT行业中，编程面试往往包含了“手撕代码”这一环节，即面试者需要现场编写代码来解决特定问题。本资源“手撕代码_C语言手撕_C++_手撕代码c++_”聚焦于C语言和C++的面试题，特别关注如何使用两个队列来实现堆栈的...
杭电笔试代码模板参考
01-21
手撕代码是指在没有现成框架或者库支持的情况下，从零开始编写核心算法，这对程序员的编程功底有较高要求。这不仅涉及编程语言的基本语法，还包括对算法的深入理解和灵活应用，例如动态规划、贪心算法、分治策略等。...
互联网面试手写代码常见题总结.docx
09-09
本文涵盖了互联网面试中常见的代码编写题目，总共 68 道题目，涵盖了链表、数组、树、图、排序算法、动态规划、递归、循环队列、堆、栈、队列、红黑树、B 树、遍历方式、最短路径算法、堆排序、LRU 算法、二分查找、...
js常见手撕代码
weixin_43468609的博客
08-12 630
实现一个简单的闭包 // 实现隔一秒输出一个数字，数字递增 // 1.利用匿名自执行函数创建闭包实现 for(var i = 0; i < 5; i++){ (function(arg){ setTimeout(function run(){ console.log(arg) }, arg*1000) })(i) } // 2.使用 let 实现 for(let i = 0; i < 5; i++){ setTimeout(()=&g
笔试面试常考数据结构-单链表常用操作编程实现
844604778
07-04 184
单链表是笔试以及面试手写代码中常考的数据结构之一。下面实现了单链表的常见操作：创建单链表、删除节点、打印单链表（包括正向打印以及逆向打印）、反转单链表、找出单链表的倒数第K个节点、合并两个有序单链表等操作。 代码（C++）： //笔试面试单链表常用操作编程实现 #include &lt;iostream&gt; #include &lt;stack&gt; #include &lt;c...
手撕算法系列——4. 判断单链表是否有环
Setsuna_Ogiso的博客
05-29 423
    这道题展开来说，就是给出一个单链表的头结点head：    1）求该链表中是否存在环路；    2）如果存在环路，求出环路的入口和环的长度。    根据单链表的性质，一个结点最多只能有一个后继，故单链表若存在环，则环一定在链表的末尾，且没有尾结点。如果一直沿着链表遍历下去，最后会在环内一直死循环。    根据以上性质，这道题的解法还是用“双指针”的思想，两个指针同时从头结点出发，但是一个指...
常见邮件发送失败原因分析以及解决方法
热门推荐
mal327的专栏
03-05 51万+
本文来自：http://www.maikongjian.com/style/info/shownews2.asp?id=439 一.发到 sina.com 的邮件会被退回  我发到 sina 的邮件会被退回，并提示"remote server said: 553 Spam Mail http://mail.sina.com.cn/FAQ.html";错误，怎么办？ 访问h
手撕代码-反转链表
wengmq的博客
03-16 487
反转链表 node * func(node*phead) { node* cur_next; node* cur_previous = NULL; node* current = phead; while(current != NULL) { cur_next = current->pnext; current->pnext = cur_previous; c...
算法面试题-----链表完整刷题总结
爱喝舒化奶的博客
03-05 1396
关于面试中你一定要会的链表算法题！！ 再次注意，涉及到删除操作的时候，一定要考虑空表，删除在表头，在表中等操作。 1、O（1）时间删除链表节点 题目：给定一个链表和一个节点指针，在O（1）时间删除该节点。 方法：狸猫换太子，用后一个节点数据覆盖要删除的节点，然后删除下一个节点。 解答：leetcode 237. Delete Node in a Linked List（删除链表中的特定节点） 2、...
嵌入式软开面试常见的手写代码
XBlog
10-23 1180
1、冒泡排序： void BubbleSort(int arr[], int len) { for (int i = 0; i < len-1; i++) { for (int j = 0; j < len - 1 - i; j++) { if (arr[j] > arr[j+1]) { Swap(&arr[j], &arr[j+1...
手撕list链表底层
11-16
手撕List链表底层涉及到一些计算机科学和数据结构的知识，包括链表、节点、内存管理等。下面是对手撕List链表底层的一些基本介绍： 1. 链表结构：链表是由一系列节点组成的数据结构，每个节点包含数据和指向下一个...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

~青萍之末~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值