删除链表中的结点

题目一：

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

进阶：你能尝试使用一趟扫描实现吗？

示例 1：

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

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

输入：head = [1,2], n = 1 输出：[1]

解法一：
利用一个队列来解决，将要删除结点之前的元素和之后的元素全部入队列，然后再出队列即可。

代码如下：

struct ListNode* removeNthFromEnd(struct ListNode* head, int n) 
{
	if (head == NULL||head->next==NULL)return NULL;
	queue<int> que;
	struct ListNode* p = head;
	int count = 0;
	while (p)
	{
		count++;//计算链表中的结点个数
		p = p->next;
	}
	p = head;
	while (p)
	{
		if (que.size() == count - n)//que.size()是要删除结点的之前的所有结点个数
		{
			p = p->next;
            if(p==NULL)//p==NULL说明是要删除最后一个结点
            {
                break;//直接返回最后一个结点不用入栈
            }
		}
		que.push(p->val);
		p = p->next;
	}
	p = head->next;
    struct ListNode* q=p;
	while (!que.empty())
	{
		p->val = que.front(); que.pop();
		p = p->next;
	}
	return q;
}

题目二：

给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。

示例 1:

输入: 1->1->2 输出: 1->2
示例 2:

输入: 1->1->2->3->3 输出: 1->2->3

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list

思路：利用双指针解决，起初两个指针都指向头，让一个指针先跑，判断前指针的值等于不等于后指针，如果不等于两个指针同时往前跑，如果等于的话就让前指针单独往前跑。
代码如下：

struct ListNode* deleteDuplicates(struct ListNode* head)
{
	if (head == NULL || head->next == NULL)
	{
		return head;
	}
	struct ListNode* p = head;
	struct ListNode* q = p;
	while (head != NULL)
	{
		if (p->val == head->val)
		{
			head = head->next;
		}
		else
		{
			p->next = head;
			p = p->next;
			head = head->next;
		}
	}
	if (p != NULL)
	{
		p->next = NULL;
	}
	return q;
}

题目三：

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

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

代码：

class Solution {
public:
    ListNode* getKthFromEnd(ListNode* head, int k) {
        int count=0;
        ListNode* p=head;
        while(p)
        {
            count+=1;
            p=p->next;
        }
        int n=count-k;
        p=head;
        while(n>0)
        {
            n--;
            p=p->next;
        }
        return p;
    }
};

题目四：

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/shan-chu-lian-biao-de-jie-dian-lcof

给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。

返回删除后的链表的头节点。

注意：此题对比原题有改动

示例 1:

输入: head = [4,5,1,9], val = 5 输出: [4,1,9] 解释: 给定你链表中值为 5
的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.
示例 2:

输入: head = [4,5,1,9], val = 1 输出: [4,5,9] 解释: 给定你链表中值为 1
的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.

思路：利用双指针进行

代码如下：

struct ListNode* deleteNode(struct ListNode* head, int val){
    if(head==NULL) return head;
    if(head->val==val)
    {
        head=head->next;
        return head;
    }
    struct ListNode* p=head;
    struct ListNode*tmp=p;
    struct ListNode* q=head->next;
    while(q)
    {
        if(q->val==val)
        {
            q=q->next;
            p->next=q;
            break;
        }
        else
        {
            p=p->next;
            q=q->next;
        }
    }
    return tmp;
}