前言：

         “删除链表的倒数第 N 个结点”的题目是力扣题库上的第19题。我是使用Python3编写的解法，性能算不上好，在此仅仅只是阐述一下解法编程思想。仅供参考~

（PS：文末附录附带了本题C语言的代码，思路大概是差不多的~）

        解法上可能会跟别人相同，所以要是看不懂下面的阐述的话可以去力扣对应的题目上查看其他人的解题思路~

问题描述：

        题目的要求是：给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

LeetCode官方给的示例如下：

示例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

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

解题思路：

         这道题要求的只是删除倒数第n个结点，没有说只能删除倒数第n个的结点，或者说不能单纯的修改结点值。而题目给出的链表结构是单链表，只有指向下一个结点的“指针”。

Python的链表定义：
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next


C中的链表定义：
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

所以，删除结点时有两种方式：

1. 可以删除对应的倒数第n个结点；
2. 将当前结点的值等于下一个结点的值，再将当前结点的next等于下一个结点的next（除倒数第一个结点外）。

而要使用一趟扫描找到倒数第n个结点，所以这里选择递归的方式找结点。先递归找到链表的尾部结点，再从尾部算起，找倒数第n个结点，并删除。

 相关代码：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        '''
            递归调用函数，返回删除后的链表
            index:表示当前节点为倒数第index个结点
                n:链表的倒数第 n 个结点
             head:链表的某个结点

            返回值：
            下层结点及下层的index
        '''
        def getAns(head,n,index):
            # 当前结点是否为空
            if head is not None:
                # 当前结点是否为最后一个结点
                # 不是则继续递归遍历
                if head.next is not None:
                    # 递归调用
                    node,index=getAns(head.next,n,index)
                    # 将当前结点的下一个结点指向返回的node
                    # 当下一个结点为倒数第n个时，当前结点会指向下下一个结点，完成删除结点的操作
                    head.next=node
                else:
                    node=head
                # 当前的index
                index+=1
                #当前结点是否为倒数第n个
                if n==index:
                    # 当前结点是否为倒数第一个
                    if n==1:
                        # 是倒数一个，返回None与index
                        return None,index
                    else:
                        # 不是倒数第一个，返回下一层结点与当前index
                        return node,index
                else:
                    # 当前结点不是最后一个，返回当前结点及当前index
                    return head,index 
        ans=ListNode()
        ans,index=getAns(head,n,0)
        return ans

运行结果：

 附录：

C语言代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
int countNum(struct ListNode* node,int n){
    int count=0;// 表示当前结点为倒数第count个
    if(node->next==NULL){  //是否为最后一个结点
        count=1;
    }else{
        // 如果不是最后一个结点，则递归调用countNum
        count=countNum(node->next,n)+1;
    }
    if(n==count && n>1){
        // 当前结点为倒数第n个结点，且不是倒数第一个结点
        // 将当前结点的值等于下一个结点的值，当前结点的next指向下一个结点的next
        node->val=node->next->val;
        node->next=node->next->next;
    }else if(n==1 && count==2){
        // 要删除的是倒数第一个结点，且当前结点为倒数第二个结点，将当前结点的next等于NULL
        node->next=NULL;
    }
    // 返回当前结点的count
    return count;
}

struct ListNode* removeNthFromEnd(struct ListNode* head, int n){
    // 如果当前链表长度为1，且要删除倒数第一个结点，则返回NULL，否则递归调用countNum()
    if (head->next==NULL && n==1){
        return NULL;
    }else{
        countNum(head,n);
    }
    return head;
}

运行结果：

 

标签：index,结点,head,next,链表,倒数第,LeetCode
来源： https://blog.csdn.net/weixin_44284498/article/details/123591533