[算法] leetcode单链表相关题目详解

Posted 2021-06-09 哦哦呵呵

目录

• 1. 203-移除链表元素
• • 解法
• 2. 206-反转链表
• • 解法一
  • 解法二
• 3. 876-链表的中间结点
• • 解法
• 4. 剑指 Offer 22. 链表中倒数第k个节点
• • 解法

1. 203-移除链表元素

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

示例 1：
输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]

示例 2：
输入：head = [], val = 1
输出：[]

示例 3：
输入：head = [7,7,7,7], val = 7
输出：[]
 
提示：
列表中的节点在范围 [0, 104] 内
1 <= Node.val <= 50
0 <= k <= 50

https://leetcode-cn.com/problems/remove-linked-list-elements/description/

解法

  该题中，最简单的解法为，定义一个哨兵节点，指向整个链表，将哨兵节点作为链表的开始节点，哨兵节点的next指针指向传入链表的第一个元素，可以简化问题。

// 定义一个哨兵节点，用于指向整个链表，最后返回哨兵节点的next指针
struct ListNode* removeElements(struct ListNode* head, int val) {
	if (NULL == head)
	{
		return NULL;
	}

	// 定义哨兵节点
	struct ListNode* pCur = (struct ListNode*)malloc(sizeof(struct ListNode));
	pCur->next = head;
	head = pCur;
	
	struct ListNode* pTmp = NULL;
	while (head->next != NULL)
	{
		// 查找待删除节点
		if (head->next->val == val)
		{
			pTmp = head->next;
			head->next = head->next->next;
		}
		else
			head = head->next;
	}

	return pCur->next;
}

2. 206-反转链表

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

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

示例 2：
输入：head = [1, 2]
输出：[2, 1]

示例 3：
输入：head = []
输出：[]

链接：https://leetcode-cn.com/problems/reverse-linked-list

解法一

  使用三个节点，分别指向待反转节点的上一个元素，自身，下一个元素。依次对链表中的节点进行反转。

struct ListNode* reverseList(struct ListNode* head) 
{
	if (NULL == head)
		return NULL;

	struct ListNode* pPre = NULL;
	struct ListNode* pCur = head;
	struct ListNode* pNext = NULL;

	while (pCur != NULL)
	{
		pNext = pCur->next;
		pCur->next = pPre;
		pPre = pCur;
		pCur = pNext;
	}

	return pPre;
}

解法二

  使用头插法反转链表，头插法先插入的元素在最后一位。大致原理为，新建一个节点用来存放逆序后的链表，从头取出原链表中的节点，依次放入新链表。

// 头插法反转链表
struct ListNode* reverseList(struct ListNode* head)
{
	if (NULL == head)
		return NULL;

	struct ListNode* pNewL = (struct ListNode*)malloc(sizeof(struct ListNode));
	pNewL->next = NULL;
	struct ListNode* pCur = head;	// 用来暂存head的下一个节点

	// 头插法插入节点
	while (NULL != head)
	{
		pCur = pCur->next;
		head->next = pNewL->next;
		pNewL->next = head;
		head = pCur;
	}

	return pNewL->next;
}

3. 876-链表的中间结点

给定一个头结点为 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，我们返回第二个结点。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/middle-of-the-linked-list

解法

  利用快慢指针进行中间节点的查找。
  两个节点初始位置都是链表头，快指针一次走两步，慢指针一次走一步，快指针到结尾，慢指针指向中间位置

struct ListNode* middleNode(struct ListNode* head) 
{
	if (head == NULL)
		return NULL;

	struct ListNode* fast = head;
	struct ListNode* slow = head;

	// 如果链表长度为偶数，那么fast走到最后一部，fast指向刚好为NULL，停止循环
	// 如果链表长度为奇数，那么fast走到最后一步，当前节点不为空，当时fast->next->next为空，会导致出错，所以要确保fast->next不为空
	while (fast != NULL && fast->next != NULL)
	{
		fast = fast->next->next;
		slow = slow->next;
	}

	return slow;
}

4. 剑指 Offer 22. 链表中倒数第k个节点

输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。

例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。

示例：
给定一个链表 : 1->2->3->4->5, 和 k = 2.
返回链表 4->5.

leetcode: https://leetcode-cn.com/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof/

解法

  同样利用快慢指针进行求解，因为求得是倒数第k个元素，所以可以让快指针先行移动k步，然后快慢指针一起移动，当快指针移动到末尾，则慢指针指向得位置为倒数第k个元素。

// 利用双指针，两个指针同时指向头，但第一个指针向前移动 k 个位置，之后两个指针一起移动，当一个指针到达末尾，则另外一个指针指向的位置就为所求节点位置
struct ListNode* getKthFromEnd(struct ListNode* head, int k) 
{
    if (NULL == head || k <= 0)
        return NULL;

    struct ListNode* first = head;
    struct ListNode* secon = head;

    // 先移动first指针k步
    while (--k > 0)
    {
        first = first->next;
        if (first == NULL)
            return NULL;
    }

    // 同时移动两指针，当first到达末尾，则secon为所求节点
    while (NULL != first->next)
    {
        first = first->next;
        secon = secon->next;
    }

    return secon;
}