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

一时失言乱红尘 2023-01-21 10:30 17阅读 0赞

### 目录 ###

*  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

## 解法一 ##

使用三个节点，分别指向待反转节点的上一个元素，自身，下一个元素。依次对链表中的节点进行反转。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcxNzUyMA_size_16_color_FFFFFF_t_70_pic_center]

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;
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcxNzUyMA_size_16_color_FFFFFF_t_70_pic_center]: /images/20221020/e877504dacaa4f61b7eec940de520ccc.png