面试算法 牛客题目 删除链表的倒数第n个节点

1.题目：  删除链表的倒数第n个节点
描述
输描述
给定一个链表，删除链表的倒数第 n 个节点并返回链表的头指针
例如，
给出的链表为: 1→2→3→4→5,n=2.
删除了链表的倒数第 n 个节点之后,链表变为1→2→3→5.

数据范围： 链表长度  10000≤n≤1000，链表中任意节点的值满足  0≤val≤100
要求：空间复杂度 O(1)O(1)，时间复杂度 O(n)O(n)
备注：
题目保证 nn 一定是有效的

要求：空间复杂度 O(n)O(n)，时间复杂度 O(n)O(n)
进阶：空间复杂度 O(1)O(1)，时间复杂度 O(n)O(n)

---

 2.算法：

1.暴力算法

2.双指针算法

• 时间复杂度：O(n)O(n)O(n)，其中nnn为链表长度，最坏情况遍历整个链表1次
• 空间复杂度：O(1)O(1)O(1)，常数级指针，无额外辅助空间使用

        

---

3.算法思想：

暴力算法：

1.找到要删除的节点的前一个节点！！

2.删除它，

3.返回头节点

双指针算法：

知识点：双指针

双指针指的是在遍历对象的过程中，不是普通的使用单个指针进行访问，而是使用两个指针（特殊情况甚至可以多个），两个指针或是同方向访问两个链表、或是同方向访问一个链表（快慢指针）、或是相反方向扫描（对撞指针），从而达到我们需要的目的。

思路： 我们无法逆序遍历链表，就很难得到链表的倒数第nnn个元素，那我们可以试试反过来考虑，如果当前我们处于倒数第nnn的位置上，即距离链表尾的距离是nnn，那我们假设双指针指向这两个位置，二者同步向前移动，当前面个指针到了链表头的时候，两个指针之间的距离还是nnn。虽然我们没有办法让指针逆向移动，但是我们刚刚这个思路却可以正向实施。

具体做法：

• step 1：给链表添加一个表头，处理删掉第一个元素时比较方便。
• step 2：准备一个快指针，在链表上先走nnn步。
• step 3：准备慢指针指向原始链表头，代表当前元素，前序节点指向添加的表头，这样两个指针之间相距就是一直都是nnn。
• step 4：快慢指针同步移动，当快指针到达链表尾部的时候，慢指针正好到了倒数nnn个元素的位置。
• step 5：最后将该节点前序节点的指针指向该节点后一个节点，删掉这个节点。

---

4.代码：

/*************************************************
作者：She001
时间:2022/9/26
题目：  删除链表的倒数第n个节点
描述
输描述
给定一个链表，删除链表的倒数第 n 个节点并返回链表的头指针
例如，
给出的链表为: 1→2→3→4→5,n=2.
删除了链表的倒数第 n 个节点之后,链表变为1→2→3→5.

数据范围： 链表长度  10000≤n≤1000，链表中任意节点的值满足  0≤val≤100
要求：空间复杂度 O(1)O(1)，时间复杂度 O(n)O(n)
备注：
题目保证 nn 一定是有效的



要求：空间复杂度 O(n)O(n)，时间复杂度 O(n)O(n)
进阶：空间复杂度 O(1)O(1)，时间复杂度 O(n)O(n)

示例1
输入：
{1,2},2    

返回值：
{2}



***************************************************/
//算法：
//1.暴力算法 
// 2.双指针算法 

#include<bits/stdc++.h>
using namespace std;
typedef struct node
{
	int i;
	node *next;	
}; 


void print(node * head)//打印链表 
{
	node* pp= head;//复制头节点 
	while(pp!=NULL)//判断这个节点是否为空  链表是否结束 
	{
		cout<<pp->i<<"  ";
		pp=pp->next;//指向下一个 
	}
	cout<<endl;
	
}

int lianbiao_num(node * head)//函数的作用 返回链表的个数
{
	int i=0;
	node* pp=head;
	while(pp!=NULL)
	{
		i++;
		pp=pp->next;	
	}
	//cout<<"链表中节点的个数: "<<i<<endl;
	return i;	
} 

//暴力算法 
node * fangfa_1(node * head,const int n)
{
	int a=lianbiao_num(head);
		node* pp=head;
		for(int i=1;i<=a-n-1;i++)//找到那个节点的前一个节点 
		{
			pp=pp->next;
		}
		node* kk=pp->next;
		pp->next=kk->next;
		delete kk;	
		return head;
} 

//双指针算法
/*
算法思想：
知识点：双指针
双指针指的是在遍历对象的过程中，不是普通的使用单个指针进行访问，而是使用两个指针（特殊情况甚至可以多个）
两个指针或是同方向访问两个链表、或是同方向访问一个链表（快慢指针）、或是相反方向扫描（对撞指针），从而达到我们需要的目的。
思路：

我们无法逆序遍历链表，就很难得到链表的倒数第k个元素，
那我们可以试试反过来考虑，如果当前我们处于倒数第kkk的位置上，
即距离链表尾的距离是k，那我们假设双指针指向这两个位置，
二者同步向前移动，当前面个指针到了链表头的时候，
两个指针之间的距离还是k。虽然我们没有办法让指针逆向移动，
但是我们刚刚这个思路却可以正向实施。

具体做法：

step 1：准备一个快指针，从链表头开始，在链表上先走kkk步。
step 2：准备慢指针指向原始链表头，代表当前元素，则慢指针与快指针之间的距离一直都是kkk。
step 3：快慢指针同步移动，当快指针到达链表尾部的时候，慢指针正好到了倒数kkk个元素的位置。 

*/
node * fangfa_2(node * head,const int n)
{
	node * fast = head;//快指针 
	node * slow = head;//慢指针
	//快指针先行 n 步 
	for(int i = 0;i<n-1;i++)//找到那个节点的前一个节点 
	{
		fast=fast->next;//下一个节点	
	}
	//快慢指针同步 ，快指针先到底  慢指针指向倒数第 k个 。
	while(fast!=NULL)
	{
		fast = fast->next;
		slow = slow->next;	
	} 
	//结束之后 slow 节点  是要删除节点的前一个节点
	
	node * kk = slow->next;
	slow->next=kk->next;
	delete kk; 
	return head;
} 




int main()
{
	
	
	//建立  第一个 单链表  
	node *a1=new node;
	node *a2=new node;
	node *a3=new node;
	node *a4=new node;
	node *a5=new node;
	node *a6=new node;
	node *a7=new node;
	
	a1->i=1;//链表节点的复制 
	a2->i=2;
	a3->i=3;
	a4->i=4;
	a5->i=5;
	a6->i=6;
	a7->i=7;
	
	
	a1->next=a2;//链表的连接 
	a2->next=a3;
	a3->next=a4;
	a4->next=a5;
	a5->next=a6;
	a6->next=a7;
	a7->next=NULL;
	
	
	//node* kk=fangfa_1(a1,2);
	//print(kk);
	
	node* kkk=fangfa_1(a1,2);
	print(kkk);
	

	


	return 	0;
}