LeetCode：第19题 删除链表的倒数第N个节点 C语言实现

问题说明： 给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。 示例： 给定一个链表: 1->2->3->4->5, 和 n = 2. 当删除了倒数第二个节点后，链表变为 1->2->3->5. 说明： 给定的 n 保证是有效的。   进阶： 你能尝试使用一趟扫描实现吗？ 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解法1：安安 //为了方便处理极端情况，自己创建了带头结点的链表进行处理，可以正确处理样例中的多种情况 //但是，发现leetcode上面的链表是不带头结点的，气死人了   解法2：leetcode直接提交 安安 据自己理解，该题leetcode应该处理的是不带头结点的 按照不同情况进行处理     解法3：leetcode直接提交  官方题解创建了一个哑结点，挂在了第一个结点的前面，那不就是带头结点的情况嘛   解法4(进阶)：快慢指针

思路：安安 两次遍历，第一次遍历找到链表的长度，第二次进行定位找到所需结点的前一个结点，进行删除 思路：进阶（一次遍历） (leetcode)我们可以使用两个指针而不是一个指针。第一个指针从列表的开头向前移动 n+1n+1 步，而第二个指针将从列表的开头出发。现在，这两个指针被 nn 个结点分开。我们通过同时移动两个指针向前来保持这个恒定的间隔，直到第一个指针到达最后一个结点。此时第二个指针将指向从最后一个结点数起的第 nn 个结点。我们重新链接第二个指针所引用的结点的 next 指针指向该结点的下下个结点。

/*
019.删除链表的倒数第N个结点
anan
2020.1.18
*/ 

//这个是自己写的带头结点的

#include<stdio.h>
#include<malloc.h>
 
struct ListNode {
	int val;
	struct ListNode *next;
};


struct ListNode* createLinkList(int a[], int length);
void dispLinkList(struct ListNode *head);

void dispLinkList(struct ListNode *head){
	struct ListNode *p = head->next;
	while(p){
		printf("%d ", p->val);
		p = p->next;
	}
	printf("\n");
}

struct ListNode* createLinkList(int a[], int length){   //带头节点 
	struct ListNode *s;
    struct ListNode *h=NULL;   //头节点 
    struct ListNode *r;  //指向新链表的最后一个节点
	
	h =  (struct ListNode *)malloc(sizeof(struct ListNode));
	h->next = NULL;
	r = h;
	
	for(int i = 0; i < length; i++){
        s = (struct ListNode *)malloc(sizeof(struct ListNode));
        s->val = a[i];
        //printf("s->val:", s->val);
        s->next = NULL;

		r->next = s;
		r = s;		
 	}
	
	return h;
}

//为了方便处理极端情况，自己创建了带头结点的链表进行处理，可以正确处理样例中的多种情况
//但是，发现leetcode上面的链表是不带头结点的，气死人了

struct ListNode* removeNthFromEnd(struct ListNode* head, int n){
	struct ListNode *p;
	int link_length = 0;
	struct ListNode *pre;
	
	p = head->next;  //确定链表长度
	while(p){     
		link_length++;
		p = p->next;
	}
	//printf("链表长度为：%d\n", link_length);
	
	pre = head;
	p = pre->next;
	for(int i = 1; i < link_length-n+1; i++){
		pre = p;
		p = p->next;
		//printf("%d, %d\n", i, p->val);
	}

	pre->next = p->next;
	free(p);
	return head;
}




int main(){

	int a[] = {1,2,3,4,5};
	int length_a = 5;
	int n = 4;

//	int a[] = {1};
//	int length_a = 1;
//	int n = 1;

//	int a[] = {1,2};
//	int length_a = 2;
//	int n = 1;

//	int a[] = {1,2};
//	int length_a = 2;
//	int n = 2;
		
	struct ListNode* l1;
	struct ListNode* l2;
	
	l1 = createLinkList(a, length_a);
	printf("链表a为：");
	dispLinkList(l1);
	
	l2 = removeNthFromEnd(l1, n);
	printf("去掉了倒数第%d个节点的链表b为：", n);	
	dispLinkList(l2);
}

//这个是leetcode进行提交的  不创建哑结点


/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* removeNthFromEnd(struct ListNode* head, int n){
	struct ListNode *p = head;
	int link_length = 0;
	struct ListNode *pre = head;
	
	while(p){    //确定链表长度 
		link_length++;
		p = p->next;
	}
	//printf("链表长度为：%d\n", link_length);
	
	
	p = pre;
	for(int i = 1; i < link_length-n+1; i++){
		pre = p;
		p = p->next;
		//printf("%d, %d\n", i, p->val);
	}
	if(p == pre){ //有两种情况
        if(p->next){   //说明删除了第一个节点，后面还有其他节点
            head = p->next;
            return head;
        }else{      //说明这个链表只有一个节点，删除完就没有了
            return NULL;
        }		
	}else{
		pre->next = p->next;
		free(p);		
		return head;   		
	}
}

//这个是直接在leetcode上提交的  创建了哑结点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* removeNthFromEnd(struct ListNode* head, int n){
    struct ListNode *dummy = (struct ListNode *)malloc(sizeof(struct ListNode));
    dummy->next = head; //设置一个哑结点指向链表的第一个结点(该题不带头结点)

	struct ListNode *p;   //进行链表遍历
	int link_length = 0;
	struct ListNode *pre;
	
    //确定链表长度 
    p = head;
	while(p){   
		link_length++;
		p = p->next;
	}
	//printf("链表长度为：%d\n", link_length);
	
    //定位所需结点，进行删除
	pre = dummy;
	p = pre->next;
	for(int i = 1; i < link_length-n+1; i++){
		pre = p;
		p = p->next;
		//printf("%d, %d\n", i, p->val);
	}

	pre->next = p->next;
	free(p);
	//return head;
    return dummy->next;
}

//快慢指针

/ *
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* removeNthFromEnd(struct ListNode* head, int n){
    struct ListNode *dummy = (struct ListNode *)malloc(sizeof(struct ListNode));
    dummy->next = head; //设置一个哑结点指向链表的第一个结点(该题不带头结点)

	struct ListNode *p = dummy;   //进行链表遍历
	struct ListNode *q = dummy;

	for(int i = 0; i < n; i++){
		p = p->next;
	}

    while(p->next){
        p = p->next;
        q = q->next;
    }

	q->next = q->next->next;

    return dummy->next;
}