链表类（Linked List）

最新推荐文章于 2024-07-15 22:08:02 发布

IT 细嚼慢咽

最新推荐文章于 2024-07-15 22:08:02 发布

阅读量1.9k

点赞数

分类专栏：力扣刷题文章标签：链表 c++

本文链接：https://blog.csdn.net/weixin_43436613/article/details/119803586

版权

力扣刷题专栏收录该内容

4 篇文章 0 订阅

订阅专栏

链表类（Linked List）

基础知识

链表如何实现，如何遍历链表。链表可以保证头部尾部插入删除操作都是O（1），查找任意元素位置O（N）

基础题目

题目：Leetcode 206. Reverse Linked List

题解

方法1：迭代

假设链表为1→2→3→∅，我们想要把它改成 ∅←1←2←3。

在遍历链表时，将当前节点的next指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存储其前一个节点。在更改引用之前，还需要存储后一个节点。最后返回新的头引用。

class Solution {
public:
	ListNode* reverseList(ListNode* head) {
		ListNode* pre = nullptr;
		ListNode* cur = head;
		while (cur != nullptr) {
			ListNode* next = cur->next;
			cur->next = pre;
			pre = cur;
			cur = next;
		}
		return pre;
	}
};

方法2：递归

链表：1→2→3→4→5→6→∅

其中1→[2→3→4→5→6→∅]括号部分看作已经反转好了，1看作head，[]整体看作next：

步骤1：head->next->next = head; 实现了1⬅[2→3→4→5→6→∅]

步骤2：head->next = nullptr; 实现了∅⬅1⬅[2→3→4→5→6→∅]

步骤3：return p;实现了返回新的头节点[2→3→4→5→6→∅]

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        // 链表为空 或 链表只有一个节点（递归终止）
		if (head == nullptr || head->next == nullptr) { 
			return head;
		}
		ListNode* p = reverseList(head->next);
		head->next->next = head;
		head->next = nullptr;
        return p;
    }
};

题目：Leetcode 876. Middle of the Linked List

给定一个头结点为 head 的非空单链表，返回链表的中间结点。

如果有两个中间结点，则返回第二个中间结点。

示例 1：

输入：[1,2,3,4,5]
输出：此列表中的结点 3 (序列化形式：[3,4,5])
返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。
注意，我们返回了一个 ListNode 类型的对象 ans，这样：
ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NULL.

示例 2：

输入：[1,2,3,4,5,6]
输出：此列表中的结点 4 (序列化形式：[4,5,6])
由于该列表有两个中间结点，值分别为 3 和 4，我们返回第二个结点。

题解

class Solution {
public:
	ListNode* middleNode(ListNode* head) {
		ListNode* p1 = head;
		ListNode* p2 = head;
		while (p1->next != nullptr && p2->next != nullptr) {
			p1 = p1->next;
			p2 = p2->next;
			if (p2->next != nullptr) {
				p2 = p2->next;
			}
		}
		return p1;
	}
};

注意：快慢指针和链表反转几乎是所有链表类问题的基础，尤其是反转链表，代码很短，建议直接背熟。

进阶题目

题目：Leetcode 160. Intersection of Two Linked Lists

给你两个单链表的头节点headA 和headB，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回null。

图示两个链表在节点c1开始相交：

题目数据保证整个链式结构中不存在环。

注意，函数返回结果后，链表必须保持其原始结构。

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。

示例 2：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

题解

步骤1：链表1从头节点开始，走到最后一个节点（不是结束），统计链表1的长度记为len1，同时记录链表1的最后一个节点记为end1。
步骤2：链表2从头节点开始，走到最后一个节点（不是结束），统计链表2的长度记为len2，同时记录链表2的最后一个节点记为end2。
步骤3：如果end1!=end2，说明两个链表不相交，返回null即可；如果end1==end2，说明两个链表相交，进入步骤4来找寻第一个相交节点。
步骤4：如果链表1比较长，链表1就先走len1-len2步；如果链表2比较长，链表2就先走len2-len1步。然后两个链表一起走，一起走的过程中，两个链表第一次走到一起的那个节点就是第一个相交的节点。

class Solution {
public:
	ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
		if (headA == nullptr || headB == nullptr) {
			return nullptr;
		}
		// 第一步：统计链表1的的长度len1，同时记录链表1的尾节点end1
		int len1 = 0;
		ListNode* end1 = nullptr;
		ListNode* cur1 = headA;
		while (cur1->next != nullptr) {
			cur1 = cur1->next;
			len1++;
		}
		end1 = cur1;

		// 第二步：统计链表2的的长度len2，同时记录链表2的尾节点end2
		int len2 = 0;
		ListNode* end2 = nullptr;
		ListNode* cur2 = headB;
		while (cur2->next != nullptr) {
			cur2 = cur2->next;
			len2++;
		}
		end2 = cur2;

		// 第三步：判断链表1和链表2的尾节点是否重合
		if (end1 != end2) {
			return nullptr;
		}

		// 第四步：链表1和链表2的尾节点重合，快指针先走|len1-len2|步
		//         然后快慢指针一起走，第一次相遇即是第一个相交节点
		ListNode* fast = nullptr;
		ListNode* slow = nullptr;
		int n = 0;
		if (len1 > len2) {
			n = len1 - len2;
			fast = headA;
			slow = headB;
			while (n > 0) {
				fast = fast->next;
				n--;
			}
		} else {
			n = len2 - len1;
			fast = headB;
			slow = headA;
			while (n > 0) {
				fast = fast->next;
				n--;
			}
		}
		while (fast != slow) {
			fast = fast->next;
			slow = slow->next;
		}
		return fast;
	}
};

题目：Leetcode 141. Linked List Cycle (Linked List Cycle II)

给定一个链表，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪next指针再次到达，则链表中存在环。为了表示给定链表中的环，我们使用整数pos来表示链表尾连接到链表中的位置（索引从 0 开始）。如果pos是 -1，则在该链表中没有环。注意：pos不作为参数进行传递，仅仅是为了标识链表的实际情况。

如果链表中存在环，则返回true。否则，返回false。

进阶：

你能用 O(1)（即，常量）内存解决此问题吗？

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

题解

步骤1：设置一个慢指针slow和一个快指针fast。在开始时，slow和fast都指向链表的头节点head。然后slow每次移动一步，fast每次移动两步，在链表中遍历起来。

步骤2：如果链表无环，那么fast指针在移动过程中一定先遇到终点，一旦fast到达终点，说明链表是没有环的，直接返回null，表示该链表无环，当然也没有第一个入环的节点。

步骤3：如果链表有环，fast指针和slow指针一定会在环中的某个位置相遇，当fast和slow相遇时，fast指针重新回到head的位置，slow指针不动。接下来，fast指针从每次移动两步改为每次移动一步，slow指针依然每次移动一步，然后继续遍历。

步骤4：快指针fast和慢指针slow一定会再次相遇，并且在第一个入环的节点处相遇。证明略。

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

题目：Leetcode 92. Reverse Linked List II

给你单链表的头指针head和两个整数left和right，其中left <= right。请你反转从位置left到位置right的链表节点，返回反转后的链表。

示例 1：

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

示例 2：

输入：head = [5], left = 1, right = 1
输出：[5]

题解

分两种情况：

情况1：从原链表的首位开始反转，则反转后的链表头为反转部分的右节点rightNode，且只需处理反转部分的头部，如下：

leftNode->next = rightNodeNext;

情况2：从原链表的非首位开始反转，则反转后的链表头仍未原链表的头节点head，且反转部分的两端都需要处理，如下：

leftNodePre->next = pre;
leftNode->next = rightNodeNext;

ListNode* reverseBetween(ListNode* head, int left, int right) {
	if (head == nullptr || left == right) { 
		return head;
	}

	// 从1位置开始反转
	if (left == 1) {
		ListNode* curNode = head;
		// 找到需要反转部分的右节点
		ListNode* rightNodeNext = nullptr; // 记录反转部分右点的下一个节点
		ListNode* rightNode = nullptr;
		while (right > 0) {
			rightNode = curNode;
			right--;
			curNode = curNode->next;
			rightNodeNext = curNode;
		}

		ListNode* leftNode = head; // 反转部分的左节点
		ListNode* pre = nullptr;
		ListNode* cur = leftNode;
		while (cur != rightNodeNext) {
			ListNode* next = cur->next;
			cur->next = pre;
			pre = cur;
			cur = next;
		}

		leftNode->next = rightNodeNext;
		return rightNode;

	} else { // 不从1位置开始反转
		// 找需要反转部分的左节点的前一个节点
		int count = left - 1;
		ListNode* curNode = head;
		ListNode* leftNodePre = nullptr; // 记录反转部分左节点的前一个节点
		while (count > 0) {
			leftNodePre = curNode;
			curNode = curNode->next;
			count--;
		}

		// 找到需要反转部分的左节点
		ListNode* leftNode = nullptr;
		curNode = head;
		int n = left;
		while (left > 0) {
			leftNode = curNode;
			left--;
			curNode = curNode->next;
		}
		curNode = head;
		// 找到需要反转部分的右节点
		ListNode* rightNodeNext = nullptr; // 记录反转部分右点的下一个节点
		ListNode* rightNode = nullptr;
		while (right > 0) {
			rightNode = curNode;
			right--;
			curNode = curNode->next;
			rightNodeNext = curNode;
		}

		// 反转
		ListNode* pre = nullptr;
		curNode = leftNode;
		while (curNode != rightNodeNext) {
			ListNode* next = curNode->next;
			curNode->next = pre;
			pre = curNode;
			curNode = next;
		}

		leftNodePre->next = pre;
		leftNode->next = rightNodeNext;

		return head;
	}
}

题目：Leetcode 328. Odd Even Linked List

给定一个单链表，把所有的奇数节点和偶数节点分别排在一起。请注意，这里的奇数节点和偶数节点指的是节点编号的奇偶性，而不是节点的值的奇偶性。

请尝试使用原地算法完成。你的算法的空间复杂度应为 O(1)，时间复杂度应为 O(nodes)，nodes 为节点总数。

示例 1:

输入: 1->2->3->4->5->NULL
输出: 1->3->5->2->4->NULL

示例 2:

输入: 2->1->3->5->6->4->7->NULL 
输出: 2->3->6->7->1->5->4->NULL

说明:

应当保持奇数节点和偶数节点的相对顺序。
链表的第一个节点视为奇数节点，第二个节点视为偶数节点，以此类推

题解

class Solution {
public:
	ListNode* oddEvenList(ListNode* head) {
		if (head == nullptr || head->next == nullptr) {
			return head;
		}

		ListNode* odd = head; // 奇数首个节点
		ListNode* even = head->next; // 偶数首个节点
		ListNode* dummyEnvenHead = new ListNode(-1); // 偶数链表的虚拟头节点
		dummyEnvenHead->next = even;
		while (odd->next != nullptr && even->next != nullptr) {
			// 找到下一个目标节点
			odd->next = odd->next->next;
			even->next = even->next->next;
			
			// 尾接下一个目标节点
			even = even->next;
			odd = odd->next;
		}
		odd->next = dummyEnvenHead->next; // 奇数尾节点->偶数头节点
		return head;
	}
};

IT 细嚼慢咽

关注

0
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
链表类（Linked List）

链表类（Linked List）基础知识链表如何实现，如何遍历链表。链表可以保证头部尾部插入删除操作都是O（1），查找任意元素位置O（N）基础题目题目：Leetcode 206. Reverse Linked List题解方法1：迭代假设链表为1→2→3→∅，我们想要把它改成 ∅←1←2←3。在遍历链表时，将当前节点的next指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存储其前一个节点。在更改引用之前，还需要存储后一个节点。最后返回新的头引用。class Soluti
复制链接

扫一扫

专栏目录