面试算法 牛客题目 链表中倒数最后k个结点

1.题目： 链表中倒数最后k个结点
描述
输入一个长度为 n 的链表，设链表中的元素的值为 ai ，返回该链表中倒数第k个节点。
如果该链表长度小于k，请返回一个长度为 0 的链表。

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

 

---

 2.算法

1.暴力算法

2.双指针算法

---

3.算法思想

1.暴力算法：  求出节点个数，遍历到 k  节点   打印数据，假如没有 k个节点就 返回 NULL 

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

思路：

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

具体做法：

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

---

代码：

/*************************************************
作者：She001
时间:2022/9/26
题目： 链表中倒数最后k个结点
描述
输入一个长度为 n 的链表，设链表中的元素的值为 ai ，返回该链表中倒数第k个节点。
如果该链表长度小于k，请返回一个长度为 0 的链表。



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

示例1
输入：
{1,2,3,4,5},2

返回值：
{4,5}

说明：
返回倒数第2个节点4，系统会打印后面所有的节点来比较。 

示例2
输入：
{2},8

返回值：
{}



***************************************************/
//算法：
//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);
	if(n>a)
	{
		return NULL;
	}
	else
	{
		node* pp=head;
		for(int i=1;i<=a-n;i++)
		{
			pp=pp->next;
		}
		return pp;
	}
} 

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

我们无法逆序遍历链表，就很难得到链表的倒数第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;i++)
	{
		if(fast!=NULL)//判断它这个链表 是否结束 
		{
			fast=fast->next;//下一个节点	
		}
		else//假如这个过程没做完，就到尾部了，那么我们 可以判定这个链表的节点个数没有 n  个 
		{
			return NULL;	
		}	
	}
	//快慢指针同步 ，快指针先到底  慢指针指向倒数第 k个 。
	while(fast!=NULL)
	{
		fast = fast->next;
		slow = slow->next;	
	} 
	return slow;
	 
		
} 




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);
	if(kk==NULL)
	{
		cout<<"链表个数不足"<<endl; 
	}
	else
	{
		print(kk);
	}
	
	node* kk1=fangfa_1(a1,8);
	if(kk1==NULL)
	{
		cout<<"链表个数不足"<<endl; 
	}
	else
	{
		print(kk);
	}
	
	
	node* kkk=fangfa_1(a1,2);
	if(kkk==NULL)
	{
		cout<<"链表个数不足"<<endl; 
	}
	else
	{
		print(kk);
	}
	
	node* kkk1=fangfa_1(a1,8);
	if(kkk1==NULL)
	{
		cout<<"链表个数不足"<<endl; 
	}
	else
	{
		print(kk);
	}
	
	

	


	return 	0;
}