《力扣题库（C）：第19题 （删除链表的倒数第 N 个结点）》

第十九题：删除链表的倒数第 N 个结点

• 给你一个链表，删除链表的倒数第 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]

提示：

• 链表中结点的数目为 sz
• 1 <= sz <= 30
• 0 <= Node.val <= 100
• 1 <= n <= sz

解题：

/**
 * @file 19.cpp
 * @author HarkerYX
 * @brief  删除链表的倒数第 N 个结点
 * @version 0.1
 * @date 2021-04-30
 * 
 * @copyright Copyright (c) 2021
 * 
 */

/*
第十九题：删除链表的倒数第 N 个结点
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
进阶：你能尝试使用一趟扫描实现吗？


解题思路:

首先把 倒数第几个大于链表个数排除

利用两个指针的间隔为N一个快一个慢，然后同时往前移动，当快的最先到达末尾时候，没有达到的慢的就是倒数第N+1个 然后删除慢的后面的一个就行

注意的是当是链表头的时候，如果只有一个节点删除了，返回NULL， 否则返回原始头就行
*/


#include <stdio.h>
#include <stdlib.h>
#include <windows.h>


struct ListNode{

    int val;
    struct ListNode *next;
};

void printList(struct ListNode* p,char *str)
{
    printf("%s : ",str);
    if(p == NULL)
        return;

    while(p!=NULL)
    {
        printf("%d ",p->val);
        p = p->next;
    }

    printf("\n");
}

struct ListNode* createList(int num[],int count)
{
    struct ListNode *head = NULL;
    struct ListNode *q = NULL;

    for(int i =0 ; i< count; i++){

        struct ListNode *node = (struct ListNode *)malloc(sizeof(struct ListNode)*1);
        node->val = num[i];

        if(head == NULL){
            head = node;
            q = head;
            q->next = NULL;
        }
        else{
            q->next = node;
            q = node;
            q->next = NULL;
        }
    }

    return head;
}

/**
 * @brief 
 * 
 * @param head 
 * @param n 
 * @return struct ListNode* 
 */
struct ListNode* removeNthFromEnd(struct ListNode* head, int n){

    struct ListNode *slow = head;
    struct ListNode *fast = head;
    int space = 0;

    //0相当于没删除 直接返回就行
    if(n<=0)
        return head;

    while(fast !=NULL && fast->next != NULL)
    {
        if(space !=n){ // 先让两个指针间隔为N
            fast=fast->next;
            space++;
        }else{
            fast=fast->next;
            slow=slow->next;
        }
    }

    //slow就是倒数第N个
    //当删除的是头时候
    if(slow == head)
    {
        if(head->next!=NULL)
            return head->next;
        else
            return NULL;  // 只有一个节点删除了就是空链表了
    }    

    //不是头情况 删除慢的后一个
    slow->next = slow->next->next;

    return head;
}


int main(void)
{
    // int num[] = {1, 2, 3, 4, 5, 6};
    // int lastNum = 4;
/*
原始链表 : 1 2 3 4 5 6 
删除后的链表 : 1 2 4 5 6 
*/

    // int num[] = {1};
    // int lastNum = 1;

/*
原始链表 : 1 
删除后的链表 : 
*/

    int num[] = {1, 2, 3, 4, 5, 6};
    int lastNum = 6;

    if(lastNum >sizeof(num) / sizeof(int))
        return -1;

    struct ListNode * newll = NULL;
    struct ListNode * orgll = createList(num,sizeof(num) / sizeof(int));
    printList(orgll,"原始链表");

    newll = removeNthFromEnd(orgll, lastNum);
    printList(newll,"删除后的链表");

    return 0;
}

原始链表 : 1 2 3 4 5 6 
删除后的链表 : 2 3 4 5 6