剑指offer(一):关于链表的问题

Alan Frank

已于 2023-11-09 23:46:36 修改

阅读量26

点赞数

文章标签：链表数据结构

于 2023-10-28 22:28:20 首次发布

本文链接：https://blog.csdn.net/2201_75442971/article/details/134092175

版权

题目一:输入一个链表的头节点,从尾到头反过来打印每一个节点的值

题目二:在O(1)时间内删除链表节点,给定一个头节点和一个节点指针,定义一个函数在O(1)时间内删除该节点

剑指offer是一本非常好的面试编程题书,非常建议大家去读,下面也是我对题目的一些理解和我对作者解题方法的理解

题目一:输入一个链表的头节点,从尾到头反过来打印每一个节点的值

我们遍历链表,我们是从头到尾去遍历链表的,但是打印输出是按照从尾到头去打印输出,我们不难想到去实现一个栈,当遍历到一个节点的时候,我将这个节点去放到这个栈中,这样后放进栈的节点会在栈顶,我们就可以先打印了

此时我先出实现一个链表,并在链表中添加反向打印的操作

#include<iostream>
#include<stack>
using namespace std;
typedef int DataType;
struct ListNode {
	DataType val;
	ListNode* next;
};
void ListPrint(ListNode* phead)
{
	ListNode* cur = phead;
	while (cur->next != NULL)
	{
		cout << cur->val << "->";
		cur = cur->next;
	}
	cout << cur->val << endl;
}
void ListRprint(ListNode* phead)//反向打印输出
{
	stack<ListNode*>s1;
	ListNode* cur = phead;
	while (cur != NULL)
	{
		s1.push(cur);
		cur = cur->next;
	}
	while (!s1.empty())
	{
		cout << s1.top()->val << " ";
		s1.pop();
	}
}
void ListPushBack(ListNode** pphead, DataType val)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	newnode->val = val;
	newnode->next = NULL;

	ListNode* cur = *pphead;
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else {
		while (cur->next != NULL)
		{
			cur = cur->next;
		}
		cur->next = newnode;
	}
}
int main() {
	
	ListNode* plist = NULL;
	ListPushBack(&plist, 3);
	ListPushBack(&plist, 4);
	ListPushBack(&plist, 5);
	ListPushBack(&plist, 6);
	ListPushBack(&plist, 7);
	//反向打印输出
	ListRprint(plist);
	cout << endl;
	ListPrint(plist);
	return 0;
}

题目二:在O(1)时间内删除链表节点,给定一个头节点和一个节点指针,定义一个函数在O(1)时间内删除该节点

其实大家一开始学习链表的时候删除链表节点都是从头节点一次遍历到要删除的节点,这样做是可以的,就是顺序查找的时间复杂度是O(n),但是我们要将时间复杂度控制在O(1)的范围内,其实还有更快的方法,

方法1 O(n):我们要删除链表中的3节点,我们第一种就是,先去找到3节点,然后将2节点的next指向3节点的next就是4节点

方法二 O(1):同样我们要删除3节点,我们已知3节点,我们可以找到下一个节点4,把4节点的内容(包括4的val和next)拷贝给3节点,再将4节点删除,我们2节点可以找到3节点,又因为3节点的拷贝到了4节点的内容,可以找到5节点

void ListDeleteNode(ListNode** pphead,ListNode* toBeDelete)//为什么要传递二级指针
//因为我们可能删除的节点可能是头节点,我们可能要改变指向头节点指针的指向,改变指针的地址要传二级指针
{
	//保证pphead和toBeDelete存在
	if (!(*pphead) || !toBeDelete)
	{
		return;
	}
	//删除的节点不是尾节点
	if (toBeDelete->next != NULL)
	{
		toBeDelete->val = toBeDelete->next->val;
		toBeDelete->next = toBeDelete->next->next;
		
	}
	//如果要删除的是头节点,且只有一个节点
	if (*pphead == toBeDelete)
	{
		delete toBeDelete;
		toBeDelete = NULL;
		*pphead = NULL;
	}
	//要删除的节点是尾节点呢
	if(toBeDelete->next == NULL)
	{
		ListNode* cur = *pphead;
		while (cur->next != toBeDelete)
		{
			cur = cur->next;
		}
		cur->next = NULL;
		free(toBeDelete);
		toBeDelete = NULL;
	}
}
ListNode* ListFindNode(ListNode* phead,DataType x)
{
	ListNode* cur = phead;
	while (cur != NULL)
	{
		cur = cur->next;
		if (cur->val == x)
		{
			break;
		}
	}
	return cur;
	
}
int main() {
	
	ListNode* plist = NULL;
	ListPushBack(&plist, 3);
	ListPushBack(&plist, 4);
	ListPushBack(&plist, 5);
	ListPushBack(&plist, 6);
	ListPushBack(&plist, 7);
	ListNode* ListFindPos = ListFindNode(plist,3);
	ListDeleteNode(&plist,ListFindPos);
	//反向打印输出
	ListRprint(plist);
	cout << endl;
	ListPrint(plist);
	return 0;
}

题目三:删除链表中的重复的节点

在一个排序的链表中,如何删除重复的节点?在下图中重复链表被删除的情况

我们将上面链表中节点的值重复为4的节点进行了删除

我们先从头到尾遍历一边链表,我们当cur和下一个节点重复的时候,cur就是我们要找的第一个重复的节点,我们将它上一个节点记作preNode,我们要将preNode和下一个不重复的节点相连,这样就可以删除重复的节点了

就看上面的例子,我们cur先找到了第一个重复节点4,我们就记4上一个节点3为preNode节点,cur找到下一个不是重复节点的节点,让其和我们的preNode相连

void ListDeletemoreNode(ListNode **pphead)//因为我们可能会改变头节点的指向,可能重复节点就在头结点上
{
	if ((*pphead) == NULL||pphead == NULL)
	{
		return;
	}
	ListNode* preNode = NULL;
	ListNode* pNode = *pphead;
	while (pNode != NULL)
	{
		//先判断有没有重复节点
		ListNode* pNext = pNode->next;
		bool needDelete = false;
		if (pNext != NULL && pNext->val == pNode->val)//是否找到了重复节点
		{
			needDelete = true;
		}
		if (!needDelete)//没有找到重复节点就执行
		{
			preNode = pNode;
			pNode = pNode->next;
		}
		else {//找到了重复节点
			int value = pNode->val;
			ListNode* pToBeDel = pNode;
			while ( pToBeDel->val == value)
			{
				pNext = pToBeDel->next;
				delete pToBeDel;
				pToBeDel = NULL;
				pToBeDel = pNext;
			}
		}
		if (preNode == NULL)//说明重复节点出现在头部
		{
			*pphead = pNext;
		}
		else {
			preNode->next = pNext;
		}
		pNode = pNext;
	}
}
int main() {
	
	ListNode* plist = NULL;
	ListPushBack(&plist, 3);
	ListPushBack(&plist, 4);
	ListPushBack(&plist, 5);
	ListPushBack(&plist, 5);
	ListPushBack(&plist, 5);
	ListPushBack(&plist, 5);
	ListPushBack(&plist, 6);
	ListPushBack(&plist, 7);
	/*ListNode* ListFindPos = ListFindNode(plist,3);
	ListDeleteNode(&plist,ListFindPos);*/
	ListDeletemoreNode(&plist);
	//反向打印输出
	ListRprint(plist);
	cout << endl;
	ListPrint(plist);
	return 0;
}

题目四:链表中倒数第k个节点

题目描述:输入一个链表,输出该链表中倒数第k个节点,为了符合大多数人的习惯,本题从1开始计数,即链表的尾节点是倒数第一个节点,例如一个链表有6个节点,从头节点开始,他们的值依次是1,2,3,4,5,6,这个链表的倒数第三个节点是值为4的这个节点

题解:这个题最简单的方法就是快慢指针,我们要找到倒数k个节点,我们先设置一个快指针,让快指针先走k-1步到达上面图上的3的位置,然后让快指针和慢指针一起向前走,每回走一步,当快指针到达6的位置,slow恰好到达倒数第k个位置

ListNode* ListFindKele(ListNode *phead,int k)
{
	if (phead == NULL || k == 0)//我们要考虑到链表是空和当我们的k是0的时候,都要返回NULL
	{
		return NULL;
	}
	int fast = 0;
	int slow = 0;
	fast = k - 1;
	ListNode* cur = phead;
	for (int i = 0; i < k - 1; i++)
	{
		if (cur->next != NULL)//要考虑到链表的节点小于k的情况
			cur = cur->next;
		else
			return NULL;
	}
	ListNode* pNode = phead;
	while (cur->next != NULL)
	{
		phead = phead->next;
		cur = cur->next;
	}
	return phead;
}
int main() {
	
	ListNode* plist = NULL;
	ListPushBack(&plist,1);
	ListPushBack(&plist, 2);
	ListPushBack(&plist, 3);
	ListPushBack(&plist, 4);
	ListPushBack(&plist, 5);
	ListPushBack(&plist, 6);
	cout<<ListFindKele(plist,3);
	/*ListNode* ListFindPos = ListFindNode(plist,3);
	ListDeleteNode(&plist,ListFindPos);*/
	//ListDeletemoreNode(&plist);
	//反向打印输出
	//ListRprint(plist);
	cout << endl;
	ListPrint(plist);
	return 0;
}

剑指offer的作者还给我们对问题进行了变式:如果说我们要去找到链表的中间节点应该怎么办?奇数个数我们返回中间的,偶数个数我们返回任意中间两个节点的其中一个,这个时候我们也是用快慢指针,我们让快指针走两步,慢指针走一步,这样当快指着走到链表末尾的时候我们的慢指针正好到了中间的位置.我们用代码来实现这个过程

ListNode* ListFindMid(ListNode* phead)
{
	//判断链表是否为空
	if (phead == NULL)
	{
		return NULL;
	}
	int fast = 0;
	int slow = 0;
	ListNode* fastNode = phead;
	ListNode* slowNode = phead;
	while (fastNode->next != NULL && slowNode->next != NULL)
	{
		fastNode = fastNode->next;
		slowNode = slowNode->next;
		if (fastNode->next != NULL)
		{
			fastNode = fastNode->next;
		}
	}
	return slowNode;
}
int main() {
	
	ListNode* plist = NULL;
	ListPushBack(&plist,1);
	ListPushBack(&plist, 2);
	ListPushBack(&plist, 3);
	ListPushBack(&plist, 4);
	ListPushBack(&plist, 5);
	//ListFindKele(plist,3);
	ListNode* Mid = ListFindMid(plist);
	cout << Mid->val << endl;
	/*ListNode* ListFindPos = ListFindNode(plist,3);
	ListDeleteNode(&plist,ListFindPos);*/
	//ListDeletemoreNode(&plist);
	//反向打印输出
	//ListRprint(plist);
	//cout << endl;
	//ListPrint(plist);
	return 0;
}

题目五:链表中环的入口节点

如果一个链表中包含环,如何找出环的入口节点?什么是链表里面有环?

就是最后一个节点的next值指向前面一个节点,形成了一个环状的链表

那我们怎么去确定这个链表到底有没有形成环?我们可以用上面说的快慢指针,快的指针一次走两步,慢的指针一次走一步,如果说快的指针和慢的指针指向了同一个节点,那么链表当中一定存在环,如果快的指针最后指向空,那么这个链表没有环。这是第一点需要我们判断有没有环

假如说链表有环,我要找到链表的入口,用我们的快慢指针,快的指针先走链表环节点个数的步数,然后快慢指针一起走,每一次走一步,当慢指针走到环的入口节点的时候,快指针刚好再次回到环的入口,这样就找到入口了,所以在这之前我们要确定这个环状链表里面节点的个数

那怎么却确定环状链表中节点的个数呢?我们让快指针和慢指针在头结点上,快指针一次走两步,慢指针一次走一步,他们两个相遇的时候一定在环里面,我们记录下相遇的时候节点的位置,然后让慢指针来一边走一边来计数,当慢指针再次指向相遇时节点的位置的时候,我们停止计数,这样我们就找到了链表中节点的个数了

那我们用代码来实现

void Listmakeround(ListNode** pphead)
{
	ListNode* cur = *pphead;
	while (cur != NULL)
	{
		if (cur->val == 3)
		{
			break;
		}
		cur = cur->next;
	}
	ListNode* pNode = *pphead;
	while (pNode->next != NULL)
	{
		pNode = pNode->next;
	}
	pNode->next = cur;
}
ListNode* ListMeetingNode(ListNode* phead)
{
	//先确定链表中有没有环,同时找到相遇的节点
	if (phead == NULL)
	{
		return NULL;
	}
	ListNode* fastNode = phead;
	ListNode* slowNode = phead;
	while (fastNode->next != NULL)
	{
		fastNode = fastNode->next;//快指针一次走两步
		if (fastNode->next != NULL)
		{
			fastNode = fastNode->next;
		}
		slowNode = slowNode->next;
		if (fastNode == slowNode)//慢指针一次走一步
		{
			return slowNode;
		}
	}
	return NULL;
}
ListNode* ListFindextrance(ListNode* phead)
{
	ListNode* meetingNode = ListMeetingNode(phead);//确定相遇的点
	if (meetingNode == NULL)
	{
		return NULL;
	}
	//我们来确定链表中节点的个数
	ListNode* pNode = meetingNode->next;
	int count = 0;
	while (pNode != meetingNode)
	{
		pNode = pNode->next;
		count++;
	}
	count++;
	ListNode* fastNode = phead;
	ListNode* slowNode = phead;
	for (int i = 0; i < count; i++)
	{
		fastNode = fastNode->next;
	}
	while (fastNode != slowNode)
	{
		fastNode = fastNode->next;
		slowNode = slowNode->next;
	}
	return fastNode;
}
int main() {
	
	ListNode* plist = NULL;
	ListPushBack(&plist,1);
	ListPushBack(&plist, 2);
	ListPushBack(&plist, 3);
	ListPushBack(&plist, 4);
	ListPushBack(&plist, 5);
	ListPushBack(&plist, 6);
	Listmakeround(&plist);//制作一个环状链表

	ListNode* extrance =  ListFindextrance(plist);
	cout << extrance->val << endl;
	

	return 0;
}

我们先用Listmakeround函数创建了一个环链表,再用ListMeetingNode()找到相遇的点,这样我们就可以来确定环中节点的个数了,ListFindextrance()来找到环形链表的入口点

题目六:反转链表

题目:定义一个函数,输入一个链表的头节点,反转该链表并输出反转后链表的头节点

ListNode* ListReversed(ListNode** pphead)
{
	if (*pphead == NULL)
	{
		return NULL;
	}
	ListNode* ReversedHead = NULL;//保存反转之后的头节点
	ListNode* pNode = *pphead;
	ListNode* pPrev = NULL;//上一个pNode节点,也是反转一直pNode的下一个节点
	while (pNode != NULL)
	{
		ListNode* pNext = pNode->next;//pNode的下一个节点,也是反转之后pNode的上一个节点
		if (pNode->next == NULL)//找到尾节点,也是反转之后的头节点节点
		{
			ReversedHead = pNode;
		}
		pNode->next = pPrev;
		pPrev = pNode;
		pNode = pNext;
	}
	return ReversedHead;
}
int main() {

	ListNode* plist = NULL;
	ListPushBack(&plist, 1);
	ListPushBack(&plist, 2);
	ListPushBack(&plist, 3);
	ListPushBack(&plist, 4);
	ListPushBack(&plist, 5);
	ListPushBack(&plist, 6);
	//Listmakeround(&plist);//制作一个环状链表

	//ListNode* extrance =  ListFindextrance(plist);
	//cout << extrance->val << endl;

	ListNode* cur = ListReversed(&plist);
	cout << cur->val << endl;

	return 0;
}

Alan Frank

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
剑指offer(一):关于链表的问题

其实大家一开始学习链表的时候删除链表节点都是从头节点一次遍历到要删除的节点,这样做是可以的,就是顺序查找的时间复杂度是O(n),但是我们要将时间复杂度控制在O(1)的范围内,其实还有更快的方法,方法1 O(n):我们要删除链表中的3节点,我们第一种就是,先去找到3节点,然后将2节点的next指向3节点的next就是4节点。
复制链接

扫一扫