牛客题解 | 反转链表

题目## 题目

题目链接

解题思路

1. 使用三个指针：

   • prev：指向前一个节点
   • curr：指向当前节点
   • next：指向下一个节点

2. 反转步骤：

   • 保存当前节点的下一个节点(next = curr.next)
   • 反转当前节点的指针(curr.next = prev)
   • 移动prev和curr指针
     • prev = curr
     • curr = next

3. 特殊情况处理：

   • 空链表：直接返回null
   • 单节点链表：直接返回该节点

---

代码

class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        // 如果链表为空或只有一个节点，直接返回
        if (!pHead || !pHead->next) {
            return pHead;
        }
        
        ListNode* prev = nullptr;
        ListNode* curr = pHead;
        ListNode* next = nullptr;
        
        while (curr) {
            // 保存下一个节点
            next = curr->next;
            // 反转当前节点的指针
            curr->next = prev;
            // 移动prev和curr指针
            prev = curr;
            curr = next;
        }
        
        return prev;
    }
};

public class Solution {
    public ListNode ReverseList(ListNode head) {
        // 如果链表为空或只有一个节点，直接返回
        if (head == null || head.next == null) {
            return head;
        }
        
        ListNode prev = null;
        ListNode curr = head;
        ListNode next = null;
        
        while (curr != null) {
            // 保存下一个节点
            next = curr.next;
            // 反转当前节点的指针
            curr.next = prev;
            // 移动prev和curr指针
            prev = curr;
            curr = next;
        }
        
        return prev;
    }
}

class Solution:
    def ReverseList(self, head):
        # 如果链表为空或只有一个节点，直接返回
        if not head or not head.next:
            return head
            
        prev = None
        curr = head
        
        while curr:
            # 保存下一个节点
            next = curr.next
            # 反转当前节点的指针
            curr.next = prev
            # 移动prev和curr指针
            prev = curr
            curr = next
            
        return prev

算法及复杂度分析

• 算法：链表的基本操作

• 时间复杂度：$\mathcal{O}(n)$

  • 只需要遍历一次链表
  • $n$ 是链表的长度

• 空间复杂度：$\mathcal{O}(1)$

  • 只使用了三个指针变量
  • 不需要额外的存储空间

这个解法的优点是：

1. 实现简单直观
2. 空间复杂度为 $\mathcal{O}(1)$
3. 只需要一次遍历
4. 不需要额外的数据结构

题目链接

题目的主要信息：

• 给定单链表的一个头，删除该链表指定节点
• 该链表所有元素不同

举一反三：

学习完本题的思路你可以解决如下题目：

JZ76. 删除链表中重复的结点

JZ6. 从尾到头打印链表

方法：迭代遍历（推荐使用）

思路：

既然是整个链表元素都不相同，我们要删除给定的一个元素，那我们首先肯定要找到这个元素，然后考虑删除它。

删除一个链表节点，肯定是断掉它的前一个节点指向它的指针，然后指向它的后一个节点，即越过了需要删除的这个节点。

//断开连接
pre.next = cur.next;

具体做法：

• step 1：首先我们加入一个头部节点，方便于如果可能的话删除掉第一个元素。
• step 2：准备两个指针遍历链表，一个指针指向当前要遍历的元素，另一个指针指向该元素的前序节点，便于获取它的指针。
• step 3：遍历链表，找到目标节点，则断开连接，指向后一个。
• step 4：返回时去掉我们加入的头节点。

图示：

Java实现代码：

import java.util.*;
public class Solution {
    public ListNode deleteNode (ListNode head, int val) {
        //加入一个头节点
        ListNode res = new ListNode(0);
        res.next = head;
        //前序节点
        ListNode pre = res;
        //当前节点
        ListNode cur = head;
        //遍历链表
        while(cur != null){
            //找到目标节点
            if(cur.val == val){
                //断开连接
                pre.next = cur.next;
                break;
            }
            pre = cur;
            cur = cur.next;
        }
        //返回去掉头节点
        return res.next;
    }
}

C++实现代码：

class Solution {
public:
    ListNode* deleteNode(ListNode* head, int val) {
        //加入一个头节点
        ListNode* res = new ListNode(0);
        res->next = head;
        //前序节点
        ListNode* pre = res;
        //当前节点
        ListNode* cur = head;
        //遍历链表
        while(cur != NULL){
            //找到目标节点
            if(cur->val == val){
                //断开连接
                pre->next = cur->next;
                break;
            }
            pre = cur;
            cur = cur->next;
        }
        //返回去掉头节点
        return res->next;
    }
};

Python实现代码：

class Solution:
    def deleteNode(self , head: ListNode, val: int) -> ListNode:
        #加入一个头节点
        res = ListNode(0)
        res.next = head
        #前序节点
        pre = res
        #当前节点
        cur = head
        #遍历链表
        while cur is not None:
            #找到目标节点
            if cur.val == val:
                #断开连接
                pre.next = cur.next
                break
            pre = cur
            cur = cur.next
        #返回去掉头节点
        return res.next

复杂度分析：

• 时间复杂度：$O(n)$，其中$n$为链表长度，最坏遍历整个链表
• 空间复杂度：$O(1)$，常数级变量