206. 反转链表

题目链接

思路： 将原链表的结点，从头到尾一个个地拿下来头插到一个新链表中，这个新链表起始时为一个空链表。

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

203. 移除链表元素

题目链接

1. 考虑常见情况

prev：记录待排查结点的前一个结点位置（previous）。
cur：记录当前正在排查的结点位置（current）。
next：记录待排查结点的后一个结点（next）。

2. 考虑特殊情况

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
    struct ListNode* prev = NULL;//记录待排查结点的前一个结点位置
	struct ListNode* cur = head;//记录当前正在排查的结点位置
	while (cur != NULL)//当cur为空时，循环停止
	{
		if (cur->val == val)//当前排查的结点是待移除的结点
		{
			struct ListNode* next = cur->next;//记录待排查结点的后一个结点位置
			if (cur == head)//待移除的结点是链表的第一个结点
			{
				head = next;//头指针指向next
				cur = next;//将next指针赋值给cur指针
			}
			else//待移除的结点不是链表的第一个结点
			{
				prev->next = next;//prev指针指向的结点指向next
				cur = next;//将next指针赋值给cur指针
			}
		}
		else//当前排查的结点不是待移除的结点
		{
			prev = cur;//指针后移
			cur = cur->next;//指针后移
		}
	}
	return head;//返回新的头指针
    }
};

876. 链表的中间结点

题目链接

思路 ： 快慢指针，快指针走两步，慢指针走一步，快指针走到头慢指针到中间

fast：记录当前遍历到的最后一个结点。（快指针）
slow：记录已经遍历过的结点的中间结点。（慢指针）

class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        ListNode* faster = head;
        ListNode* lower = head;
        while(faster && faster->next)
        {
            faster = faster->next->next;
            lower = lower->next;
        }

        return lower;
    }
};

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

题目链接

思路： 快慢指针

因为从最后一个结点开始，再往后走一步便是NULL；从倒数第二个结点开始，再往后走两步便是NULL；从倒数第k个结点开始，再往后走k步便是NULL。所以我们可以先让快指针（fast）先走k步，然后慢指针（slow）再和快指针一起往后走，这样，当快指针走到NULL时，慢指针指向的结点就是倒数第k个结点。

题目中 n 是一定小于结点的sz ， 所以为了 简化如果是删除头节点的操作，我们加入虚拟头指针

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        if(head->next == nullptr)
            return nullptr;
        ListNode* prehead=new ListNode(-1,head); //虚拟头节点
        struct ListNode* faster = prehead;
        struct ListNode* slower = prehead;
        while(n--)//快指针先走n步
        {
                faster = faster->next;
        }

        while(faster->next)//遍历first指针到链表的结尾
        {
            faster = faster->next;
            slower = slower->next;
        }
        slower->next = slower->next->next;
        return prehead->next;
        
    }
};