leetcode刷题之链表（删除，交换，反转）

链表之删除元素

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

题目 难度：简单
在这道题里头结点（题目中也给出了定义：ListNode* head）的val是有正常数字的，不是摆设，所以我们可以设一个虚拟头结点放在原来头结点前面。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) 
    {
        ListNode* dummy_head=new ListNode(0);//设置虚拟头结点
        dummy_head->next=head;//设置虚拟头节点；放在head前面
        ListNode *cur=dummy_head;
        while(cur->next!=nullptr)
        {
            if(cur->next->val==val)
            {
                ListNode *node_delete=cur->next;
                ListNode *tmp=cur->next->next;
                //cur是要删除结点的上一个结点的指针，cur->next->next是要删除结点的下一个结点指针
                cur->next=tmp;
                delete node_delete;
            }
            else
            {
                cur=cur->next;
            }
        }
        head=dummy_head->next;//先保存新的头结点
        delete dummy_head;
        return head;
    }
};

昨晚在力扣上面提交代码不停出错，原因是最后三行我原本写的是：

delete dummy_head;
return dummy_head->next;

已经删去了虚拟头结点，怎么可以再返回虚拟头结点的next呢？

83. 删除排序链表中的重复元素给定一个已排序的链表的头 head ， 删除所有重复的元素，使每个元素只出现一次 。返回 已排序的链表 。

题目 难度：简单

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) 
    {
        if (head == nullptr)
	    {
		    return head;
	    }
	    
        ListNode* fast=head->next;
        ListNode* slow=head;

        while(fast!=nullptr)
        {
            if(fast->val==slow->val)
            {
                //ListNode *tmp=fast->next;
                ListNode* node_delete=fast;
                fast=fast->next;
                slow->next=fast;
                
                delete node_delete;
            }
            else
            {
                fast=fast->next;
                slow=slow->next;
            }
        }
  
        return head;
    }
};

在力扣提交了好几次都错误的原因：没有写下面这段话

if (head == nullptr)
{
	return head;
}

没有想到如果链表为空怎么办

19.删除链表的倒数第N个结点：给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

题目 难度：中等
这道题用到了双指针：fast和slow，fast从虚拟头结点开始跑N+1个，再让slow和fast一起跑，直到fast跑到NULL,这样slow就跑到了要删除的结点的前一个结点；

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) 
    {
        ListNode *dummy_head=new ListNode(0);
        dummy_head->next=head;
        ListNode* fast=dummy_head;
        ListNode* slow=dummy_head;
        for(int i=0;i<n+1;i++)
        {
            fast=fast->next;//fast先走n+1步

        }
        while(fast!=nullptr)
        {
            fast=fast->next;
            slow=slow->next;
        }
        ListNode* temp=slow->next->next;//这是要删除的结点的下一个结点的指针
        ListNode* node_delete=slow->next;
        slow->next=temp;
        
        head=dummy_head->next;
        delete dummy_head;
        delete node_delete;
        return head;
    }
};

链表之交换结点：

24. 两两交换链表中的节点：给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

题目 难度：中等

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) 
    {
        if(head==nullptr)
        {
            return head;
        }
        ListNode* dummy_head=new ListNode(0);
        dummy_head->next=head;
        ListNode *p=dummy_head;
        while(p->next != nullptr&&p->next->next!=nullptr)
        {
            ListNode* fast=p->next->next;
            ListNode* slow=p->next;
            ListNode *tmp=fast->next;

            p->next=fast;
            fast->next=slow;
            slow->next = tmp;

            p=p->next->next;
        }
        head=dummy_head->next;
        delete dummy_head;
        return head;
    }
};

在力扣提交了好几次都错误的原因：

while(p->next != nullptr&&p->next->next!=nullptr)

我写成了：

while(p->next != nullptr)

没有想到如果链表里的元素的个数是奇数怎么办

链表之反转：

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

题目

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) 
    {
        if(head==nullptr)
        {
            return head;
        }
        //ListNode *dummy_head=new ListNode(0,nullptr);
        //ListNode *pre=dummy_head;
        dummy_head->next=head;
        ListNode *pre=nullptr;
        ListNode *cur=head;
        while(cur!=nullptr)
        {
            ListNode* tmp=cur->next;//保存cur的下一个结点
            cur->next=pre;
            pre=cur;
            cur=tmp;//tmp=cur->next

        }
        
        return pre;
    }
};

在力扣提交了好几次都错误的原因：

ListNode *pre=nullptr;

而我把pre指针指向了一个虚拟头结点（0，nullptr），里面是有数值0的