Leetcode：链表刷题（7道经典题目）

已于 2022-11-01 08:59:52 修改
阅读量1.6k 收藏 8
点赞数 2
分类专栏： # LeetCode 文章标签： 算法 c++ python
于 2022-03-22 19:25:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37085158/article/details/123668801
版权

Leetcode：链表刷题（7道经典题目）

本文带来的是以链表为主题的一些经典题目：

链表是一种通过指针串联在一起的线性结构，每一个节点是又两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向NULL（空指针）。链接的入口点称为列表的头结点也就是head。

双链表：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。

在这里插入图片描述

  • 单链表中的节点只能指向节点的下一个节点。
  • 双链表 既可以向前查询也可以向后查询。
  • 循环链表，链表首尾相连。循环链表可以用来解决约瑟夫环问题。

20200806194629603.png

数组是在内存中是连续分布的，但是链表在内存中可不是连续分布的。链表是通过指针域的指针链接在内存中各个节点。所以链表中的节点在内存中不是连续分布的，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。

数组在定义的时候，长度就是固定的，如果想改动数组的长度，就需要重新定义一个新的数组。链表的长度可以是不固定的，并且可以动态增删， 适合数据量不固定，频繁增删，较少查询的场景。

链表Python定义方式：

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

C++链表定义方式：

// 单链表
struct ListNode {
	int val;  // 节点上存储的元素
	ListNode* next; // 指向下一个节点的指针
	ListNode(int x) : val(x), next(NULL) {}; // 节点的构造函数
};

根据列表生成链表，并返回头节点：

def initList(data):
    if len(data) == 0:
        return
    else:
        head = ListNode(data[0])
        r = head  # 头节点
        p = head  # 指针
        for i in data[1:]:
            node = ListNode(i)
            p.next = node
            p = p.next
        return r

CPP：根据列表生成链表，这是用来在本地段测试链表有关题目效果的，方便调试。

// 根据列表生成链表，并返回头节点：
ListNode* initList(vector<int>& data) {
	if (data.size() == 0) {
		return nullptr;
	}
	ListNode* head = new ListNode(data[0]);
	ListNode* cur = head;
	for (int i = 1; i < data.size(); i++) {
		ListNode* node = new ListNode(data[i]);
		cur->next = node;
		cur = cur->next;
	}

	return head;
}

// 根据链表生成数组，并返回数组
vector<int> toVector(ListNode* head) {
	ListNode* cur = head;
	vector<int> num;
	if (head == nullptr) {
		return {};
	}
	while (true) {
		num.push_back(cur->val);
		if (cur->next == nullptr) break;
		cur = cur->next;
	}
	return num;
}

链表操作中，可以使用原链表来直接进行删除操作，也可以设置一个虚拟头结点在进行删除操作。

在C，C++中，不要忘了还要从内存中删除这两个移除的节点，如果使用java ，python的话就不用手动管理内存了。

203. 移除链表元素

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

由于链表的头节点 head 有可能需要被删除，因此创建哑节点 dummyHead，令 dummyHead.next=head.

class Solution:
    def removeElements(self, head: ListNode, val: int) -> ListNode:
        dummy_head = ListNode(next=head)
        cur = dummy_head
        while cur.next is not None:
            if cur.next.val == val:
                cur.next = cur.next.next
            else:
                cur = cur.next
        return dummy_head.next

C++代码如下：

class Solution {
public:
	// 设置一个虚拟头结点在进行移除节点操作
	ListNode* removeElements(ListNode* head, int val) {
		ListNode* dummyHead = new ListNode();
		dummyHead->next = head;
		ListNode* cur = dummyHead;
		while (cur->next != nullptr) {
			if (cur->next->val == val) {
				ListNode* tmp = cur->next;
				cur->next = cur->next->next;
				delete tmp;
			}
			else {
				cur = cur->next;
			}
		}
		head = dummyHead->next;
		delete dummyHead;
		return head;
	}

	// 直接使用原来的链表来进行移除节点操作
	ListNode* removeElements2(ListNode* head, int val) {
		// 删除头节点
		while (head != nullptr && head->val == val) {   // 这里不是 if
			ListNode* tmp = head;
			head = head->next;
			delete tmp;
		}

		ListNode* cur = head;
		while (cur != nullptr && cur->next != nullptr) {
			if (cur->next->val == val) {
				ListNode* tmp = cur->next;
				cur->next = cur->next->next;
				delete tmp;
			}
			else {
				cur = cur->next;
			}
		}
		return head;
	}
};

707. 设计链表

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。在链表类中实现这些功能：

  • get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
  • addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
  • addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
  • addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
  • deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

单链表：

struct LinkedNode
{
	int val;
	LinkedNode* next;
	LinkedNode() :val(0), next(nullptr) {}
	LinkedNode(int x) :val(x), next(nullptr) {}
	LinkedNode(int x, LinkedNode* next) :val(x), next(next) {}
};


class MyLinkedList {
public:
	MyLinkedList() {
		_dummyHead = new LinkedNode();
		_size = 0;
	}

	int get(int index) {
		if (index<0 || index >= _size) {
			return -1;
		}
		LinkedNode* cur = _dummyHead->next;
		while (index--) {
			cur = cur->next;
		}
		return cur->val;
	}

	void addAtHead(int val) {
		LinkedNode* node = new LinkedNode(val);
		node->next = _dummyHead->next;
		_dummyHead->next = node;
		_size++;
	}

	void addAtTail(int val) {
		LinkedNode* newNode = new LinkedNode(val);
		LinkedNode* cur = _dummyHead;
		while (cur->next != nullptr) {
			cur = cur->next;
		}
		cur->next = newNode;
		_size++;
	}

	void addAtIndex(int index, int val) {
		if (index > _size) return;
		LinkedNode* cur = _dummyHead;
		while (index--) {
			cur = cur->next;
		}
		LinkedNode* newNode = new LinkedNode(val);
		newNode->next = cur->next;
		cur->next = newNode;
		_size++;
	}

	void deleteAtIndex(int index) {
		if (index < 0 || index >= _size) {
			return;
		}
		LinkedNode* cur = _dummyHead;
		while (index--) {
			cur = cur->next;
		}
		LinkedNode* node = cur->next;
		cur->next = cur->next->next;
		delete node;
		_size--;
	}

private:
	LinkedNode* _dummyHead;
	int _size;
};

双链表比单链表快得多，测试用例花费的时间比单链表快了两倍。但是它更加复杂，它包含了 size，记录链表元素个数，和伪头伪尾。

struct LinkedNode
{
	int val;
	LinkedNode* next;
	LinkedNode* prev;
	LinkedNode() :val(0), next(nullptr), prev(nullptr) {}
	LinkedNode(int x) :val(x), next(nullptr), prev(nullptr) {}
	LinkedNode(int x, LinkedNode* next) :val(x), next(next), prev(nullptr) {}
	LinkedNode(int x, LinkedNode* next, LinkedNode* prev) :val(x), next(next), prev(prev) {}
};


class MyLinkedList {
public:
	MyLinkedList() {
		m_size = 0;
		head = new LinkedNode();
		tail = new LinkedNode();
		head->next = tail;
		tail->prev = head;
	}

	int get(int index) {
		if (index < 0 || index >= m_size) {
			return -1;
		}
		LinkedNode* cur = head;
		for (int i = 0; i < index; i++) {
			cur = cur->next;
		}
		return cur->next->val;
	}

	void addAtHead(int val) {
		LinkedNode* newNode = new LinkedNode(val, head->next, head);
		newNode->next->prev = newNode;
		newNode->prev->next = newNode;
		m_size++;
	}

	void addAtTail(int val) {
		LinkedNode* newNode = new LinkedNode(val, tail ,tail->prev);
		newNode->prev->next = newNode;
		newNode->next->prev = newNode;
		m_size++;
	}

	void addAtIndex(int index, int val) {
		if (index < 0 || index >m_size) {
			return;
		}
		LinkedNode* cur = head;
		for (int i = 0; i < index; i++) {
			cur = cur->next;
		}
		LinkedNode* newNode = new LinkedNode(val, cur->next, cur);
		newNode->prev->next = newNode;
		newNode->next->prev = newNode;
		m_size++;
	}

	void deleteAtIndex(int index) {
		if (index < 0 || index >= m_size) {
			return;
		}
		LinkedNode* cur = head;
		for (int i = 0; i < index; i++) {
			cur = cur->next;
		}
		LinkedNode* tmp = cur->next;
		cur->next = tmp->next;
		tmp->next->prev = cur;
		delete tmp;
		m_size--;
	}

private:
	int m_size;
	LinkedNode* head;
	LinkedNode* tail;
};

206. 反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

class Solution {
public:
	ListNode* reverseList1(ListNode* head) {
		ListNode* cur = head;
		ListNode* prev = nullptr;
		ListNode* tmp = nullptr;
		while (cur != nullptr) {
			tmp = cur->next;
			cur->next = prev;
			prev = cur;
			cur = tmp;
		}
		return prev;
	}
    
    //  递归
	ListNode* reverseList(ListNode* head) {
		return reverse(nullptr, head);
	}
	ListNode* reverse(ListNode* pre, ListNode* cur) {
		if (cur == nullptr) {
			return pre;
		}
		ListNode* tmp = cur->next;
		cur->next = pre;
		return reverse(cur, tmp);
	}
};

class Solution {
public:
    //  迭代方法：（双指针）
	ListNode* reverseList1(ListNode* head) {
		ListNode* cur = head;
		ListNode* prev = nullptr;
		ListNode* tmp = nullptr;
		while (cur != nullptr) {
			tmp = cur->next;
			cur->next = prev;
			prev = cur;
			cur = tmp;
		}
		return prev;
	}

	// 递归  从后往前翻转指针指向
	ListNode* reverseList2(ListNode* head) {
		if (head == nullptr) return nullptr;
		if (head->next == nullptr) return head;

		ListNode* last = reverseList2(head->next); // 递归调用，翻转第二个节点开始往后的链表
		head->next->next = head; // 翻转头节点与第二个节点的指向
		head->next = nullptr; // 此时的 head 节点为尾节点，next 需要指向 NULL
		return last;
	}

    
	// 递归  和双指针法是一样的逻辑
	ListNode* reverse(ListNode* pre, ListNode* cur) {
		if (cur == nullptr) return pre;
		ListNode* tmp = cur->next;
		cur->next = pre;
		return reverse(cur, tmp);
	}

	ListNode* reverseList(ListNode* head) {
		return reverse(nullptr, head);
	}
};

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

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

初始时，cur指向虚拟头结点，然后进行如下三步：

class Solution {
public:
	ListNode* swapPairs(ListNode* head) {
		ListNode* dummyHead = new ListNode(0, head);
		ListNode* prev = dummyHead;
		while (prev->next != nullptr && prev->next->next != nullptr) {
			ListNode* cur = prev->next;
			ListNode* tmp = cur->next;

			prev->next = tmp;
			cur->next = tmp->next;
			tmp->next = cur;
			
			prev = cur;
		}
		return dummyHead->next;
	}
};

19. 删除链表的倒数第 N 个结点

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。进阶：你能尝试使用一趟扫描实现吗？

双指针：快指针比慢指针先走 n 步。

class Solution {
public:
	// 双指针
	ListNode* removeNthFromEnd(ListNode* head, int n) {
		ListNode* dummyHead = new ListNode(0, head);
		ListNode* slow = dummyHead;
		ListNode* fast = dummyHead;

		for (int i = 0; i < n; i++) {
			fast = fast->next;
		}
		while (fast->next != nullptr) {  // 找到节点
			slow = slow->next;
			fast = fast->next;
		}  // 使slow指向前一个节点
    
		ListNode* tmp = slow->next;
		slow->next = slow->next->next;
		delete tmp;

		return dummyHead->next;
	}
};

面试题 02.07. 链表相交

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。题目数据 保证 整个链式结构中不存在环。注意，函数返回结果后，链表必须 保持其原始结构 。

双指针

class Solution {
public:
    // a+c+b(走对方的路)和b+c+a(走对方的路)，如果相交，两人走的是路长是一致的，会同时达到点。
	ListNode* getIntersectionNode(ListNode* headA, ListNode* headB) {
		ListNode* curA = headA;
		ListNode* curB = headB;

		while (curA != curB) {  // 要么相遇即节点相等，要么都为空
			curA = (curA != nullptr) ? curA->next : headB;
			curB = (curB != nullptr) ? curB->next : headA;
		}
		return curA;
	}
};

142. 环形链表 II

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。
说明：不允许修改给定的链表。

主要考察两知识点：1. 判断链表是否环 2. 如果有环，如何找到这个环的入口.

  • 判断链表是否有环:
    • 可以使用快慢指针法， 分别定义 fast 和 slow指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇 ，说明这个链表有环。
      • fast指针一定先进入环中，如果fast 指针和slow指针相遇的话，一定是在环中相遇
      • fast是走两步，slow是走一步，其实相对于slow来说，fast是一个节点一个节点的靠近slow的，所以fast一定可以和slow重合。
  • 如果有环，如何找到这个环的入口：
    • 假设从头结点到环形入口节点 的节点数为x。 环形入口节点到 fast指针与slow指针相遇节点 节点数为y。 从相遇节点 再到环形入口节点节点数为 z。 如图所示：
    • 相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针，（y+z）为 一圈内节点的个数A。
    • 从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。
class Solution:
    def detectCycle(self, head: ListNode) -> ListNode:
        fast, slow = head, head

        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
            if slow == fast:
                p = head
                q = slow
                while p != q:
                    p = p.next
                    q = q.next
                return p
        return None

PS

以上题解大多来自【代码随想录】，在此基础上做了一定总结，并附带一些自己的理解。

随缘更新，有错误请指出！

END

奋斗的西瓜瓜
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
编程题汇总_链表
RuanMeng的博客
02-28 330
文章目录题目一：链表的回文结构题目解析程序测试题目二：相交链表(输入两个链表，找出它们的第一个公共结点)题目解析程序测试题目三：环形链表(给定一个链表，判断链表中是否有环)题目解析程序测试题目四：环形链表(给定一个链表，返回链表开始入环的第一个节点)题目解析程序测试 题目一：链表的回文结构 链接：链表的回文结构 对于一个链表，请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法，判断其是...
链表经典 10题
mu_tong_的博客
10-12 2236
链表10 道经典例题
编程题整理--链表
qq_42704970的博客
05-05 933
leetcode（力扣）206，翻转链表，递归和迭代两种思路，逻辑有示意图表示，c++和java实现。
链表相关练习题以及题解
最新发布
2302_81342533的博客
05-01 946
学习完了链表结构，不妨多加练习熟系这种数据结构。所以本篇论文列举出了一些和链表相关的练习题，并描述解题思路，相信对能够令读者对链表这种结构的掌握更加得心应手。
10道经典链表面试题
xaiobit_hl的博客
05-18 3721
目录 1.删除链表中等于给定值val的所有节点 2.反转一个单链表 3.给定一个带有头结点head的非空单链表，返回链表的中间结点。如果有两个中间结点，则 返回第二个中间结点 4.输入一个链表，输出该链表中倒数第k个结点 5.将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所 有节点组成的 6. 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的 结点之前 7. 链表的回文结构 8. 输入两个链表，找出它们.........
代码随想录02：链表
DLNovice的博客
10-24 523
代码随想录02：链表
leetcode:leetcode刷题记录
03-29
1. **基础算法和数据结构**：项目可能涉及二分查找、动态规划、贪心算法、回溯法等经典算法，以及链表、树、堆、哈希表等数据结构的实现。 2. **PHP语法和特性**：学习如何在PHP中声明变量、控制流程、函数定义、...
leetcode:leetcode刷题
04-19
在编程世界里，LeetCode是一个备受推崇的在线平台，它提供了丰富的编程题目，旨在帮助开发者提升算法技能，掌握数据结构，以及提高解决实际问题的能力。对于C++程序员而言，LeetCode更是提升技术实力的重要工具。...
_leetcode：leetcode刷题之旅
02-23
在LeetCode中，题目通常分为不同的难度级别——简单、中等和困难，涵盖了许多经典算法，如排序、搜索、图论、动态规划等。Java解题者会利用其语言特性，如面向对象、集合框架、泛型、异常处理等，来实现这些算法。...
Leetcode:Leetcode刷题记录
03-09
在这个“Leetcode:Leetcode刷题记录”中，我们可以推测它可能包含了某位程序员在LeetCode上练习题目的代码、解题思路和学习笔记。 LeetCode 的题型涵盖了数组、链表、字符串、树、图、哈希表、排序、搜索等众多领域...
leetcode:LeetCode刷题记录
04-16
此压缩包"leetcode:LeetCode刷题记录"显然包含了一位名叫Wendi的开发者在LeetCode上练习时编写的C++代码。通过分析和学习这些代码，我们可以深入理解C++语言在解决实际问题时的应用，特别是对于算法和数据结构的运用...
链表常用考题
qq_51141456的博客
05-02 177
2.分别查询出两个链表的长度，La长度为9，Lb链表长度为6，然后将p1指针向后移动（9-6）个结点，p1所指结点为C, p1指针所指部分链表长度为6，p2此时所指链表长度也为6，相等；然后再让p1和p2一起向后移动，当p1移动到NULL时，p2正好在倒数第二个结点，大家可以自己对照表格比划一下；3.然后p1,p2开始向后一起移动，当p1==p2时，此时的地址即为汇聚结点；先让p1从头结点向后移动两个结点，p2不动，此时p1已经到了结点B，思路：假定链表La，Lb为两个汇聚的单链表；
算法之链表篇
代码不会敲的博客
10-18 496
相对于数组操作，链表更适合插入和删除操作，效率很高，时间复杂度为O(1)；而数组更适合查询操作；关于对应头结点的情况都要单独处理，而使用虚拟头结点，可以解决这个问题。
LeetCode和牛客网经典链表题目合集
m0_70811813的博客
11-17 490
移除链表元素、反转链表、链表的中点节点、链表中倒数最后k个节点、合并两个有序链表、分割链表、链表的回文结构、相交链表、环形链表、环形链表II、复制带随机指针的链表
链表——题目集合
Go的全部
10-25 154
package linkedList import ( "fmt" "testing" ) /* 链表问题 面试时链表解题的方法论 1.对于笔试，不用太在乎空间复杂度，一切为了时间复杂度 2.对于面试，时间复杂度依然放在第一位，但是一定要找到空间最省的方法(吸引面试官要你不要别人) 链表面试题常用的数据结构 1.使用容器 哈希表、数组等 2.快慢指针 快慢指针 1.输入链表头节点，奇数长度返回中点，偶数长度返回上中点 2.输入链表头节点，奇数长度返回中点，偶数长度返回下中点 3.输入链表头节点
【链表篇】速刷牛客TOP101 高效刷题指南
King Gigi的博客
08-21 229
牛客101刷题笔记链表篇
Leetcode链表题目集合
weixin_44137260的博客
04-29 216
160.Intersection of Two Linked Lists 注意，链表结点相同意味着他们的值相同，下一个结点也相同 方法1：暴力法 方法2： /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode...
【20220929】【每日一题】设计链表
HYAIWYH的博客
09-29 259
new一个新的节点newNode，判断当前指针的指向是否为空，不为空则current往后走。注意这里的cur应该从虚拟头节点开始，因为首先得判断是否为空链表，如果从头节点开始则默认不为空链表。
【典例】链表经典题目合集
浮光掠影
02-04 5225
爷把鱼缸搬出来了好吧~
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

奋斗的西瓜瓜

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

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

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

打赏作者

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

抵扣说明：

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

余额充值