链表面试题

链表面试题

1：单向链表,如何找到倒数第n个节点

解答：可以定义2个指针，一个指针指向链表头部，一个指针先移动到第n个节点。保持两个指针的距离为n，然后依次往后移动，当后一个节点为null时，前一个节点的位置则是倒数第n个节点。看foo1

2：判断链表是否有环

解答：使用快慢指针的方法，定义2个指针，然后开始一个大循环，在循环体中，让指针1每次向下移动一个节点，让指针2每次向下移动两个节点。然后比较两个指针指向的节点是否相同。如果相同，则判断出链表有环，如果不同，则继续下一次循环。此方法有点类似于正在一个环形跑道上，2个运动员跑步，跑的快的 始终会追上慢的。看foo2

3: 判断两个链表是否有公共节点

解答：

4: 链表的反转

解答：定义三个指针。

5: 示例代码

#include <iostream>
#include <stdlib.h>
using namespace std;

struct ListNode
{
	int value;
	struct ListNode *next;
	ListNode(int v = 0) : value(v), next(nullptr) {}
};

int printNode(ListNode *head)
{
	while (head)
	{
		cout << head->value << " ";
		head = head->next;
	}
	cout << endl;
	return 0;
}

//判断是否有环，如果有环，返回环内节点；如果没有环，则返回nullptr
ListNode *IsLoop(ListNode *head)
{
	//链表为空或者只有1个节点
	if (head == nullptr || head->next == nullptr)
		return nullptr;

	ListNode *slow = head;		 //慢指针
	ListNode *fast = head->next; //快指针

	while (fast != nullptr && slow != fast)
	{
		slow = slow->next;
		fast = fast->next;
		if (fast != nullptr)
		{
			fast = fast->next;
		}
	}
	return fast;
}

//计算环内长度
int LoopLenght(ListNode *head)
{
	ListNode *stop = head;
	head = head->next;
	int count = 1;
	while (head != stop)
	{
		count++;
		head = head->next;
	}
	return count;
}
//获得环的入口结点
ListNode *EntryLoop(ListNode *head, int length)
{
	if (head == nullptr || length == 0)
	{
		return nullptr;
	}

	ListNode *slow = head;
	ListNode *fast = head;
	for (int i = 0; i < length; i++)
	{
		fast = fast->next;
	}

	while (slow != fast)
	{
		slow = slow->next;
		fast = fast->next;
	}
	return fast;
}

//计算带环，链表长度
int List_length(ListNode *head, ListNode *end, int loop)
{
	int count = 0;
	while (head != end)
	{
		count++;
		head = head->next;
	}
	return count + loop;
}

ListNode *ListMeet(ListNode *head1, ListNode *head2, int len1, int len2)
{
	if (len1 < len2)
	{
		swap(head1, head2);
	}

	int k = abs(len1 - len2);
	while (k--)
	{
		head1 = head1->next;
	}
	while (head1 != head2) // nullptr时相等
	{
		head1 = head1->next;
		head2 = head2->next;
	}
	return head1;
}

bool TwoListMeet(ListNode *head1, ListNode *head2)
{
	ListNode *isloop1 = IsLoop(head1);
	ListNode *isloop2 = IsLoop(head2);

	//一个有环，一个无环，则必不存在交点
	if ((isloop1 == nullptr) ^ (isloop2 == nullptr))
	{
		return false;
	}

	//两个链表都没有环
	if ((isloop1 == nullptr) && (isloop2 == nullptr))
	{
		int len1 = List_length(head1, nullptr, 0); //计算不带环链表长度
		int len2 = List_length(head2, nullptr, 0);

		if (ListMeet(head1, head2, len1, len2) == nullptr) //可以保存meet节点
			return false;
		else
			return true;
	}

	//两个链表都有环时
	//环内长度
	int looplenght1 = LoopLenght(isloop1);
	int looplenght2 = LoopLenght(isloop2);

	//获得环的入口结点
	ListNode *entry1 = EntryLoop(head1, looplenght1);
	ListNode *entry2 = EntryLoop(head2, looplenght2);

	//环外相遇
	if (entry1 == entry2)
	{

		//寻找相遇结点
		int listlenght1 = List_length(head1, entry1, looplenght1); //计算带环链表长度
		int listlenght2 = List_length(head2, entry2, looplenght2);

		ListNode *meet = ListMeet(head1, head2, listlenght1, listlenght2); //计算相遇节点
		return true;
	}
	else
	{
		//判断是否在环内相遇
		ListNode *temp = entry1;
		temp = temp->next;
		while (temp != entry1 && temp != entry2)
		{
			temp = temp->next;
		}

		if (temp == entry2)
			return true;
		else
			return false;
	}

	return false;
}

ListNode *GetLastNnode(ListNode *head, int n)
{
	//定义2个指针
	ListNode *pfirst = head;
	ListNode *psecond = head;
	//检测链表是否位空
	if (nullptr == head || n <= 0)
		return nullptr;
	//移动pfirst N步
	do
	{
		// 指针为空，跳出
		if (nullptr == pfirst)
			break;
		pfirst = pfirst->next;
	} while (--n);
	// n太大，pfirst未移动到倒数第n个节点
	if (0 != n)
		return nullptr;
	//保持距离让标尺向右移动，直到右端指向末尾，左端即结果
	while (pfirst != nullptr)
	{
		pfirst = pfirst->next;
		psecond = psecond->next;
	}
	return psecond;
}

int foo1(void)
{
	//单向链表,如何找到倒数第n个节点
	ListNode *node1 = new ListNode(1);
	ListNode *node2 = new ListNode(2);
	ListNode *node3 = new ListNode(3);
	ListNode *node4 = new ListNode(4);
	ListNode *node5 = new ListNode(5);
	ListNode *node6 = new ListNode(6);
	ListNode *node7 = new ListNode(7);

	node1->next = node2;
	node2->next = node3;
	node3->next = node4;
	node4->next = node5;
	node5->next = node6;
	node6->next = node7;
	int last_num = 2;
	ListNode *node = GetLastNnode(node1, last_num);
	cout << "倒数第" << last_num << "个节点值是" << node->value << endl;

	return 0;
}

int foo2(void)
{
	//判断链表是否有环,使用快慢指针的方法
	ListNode *node1 = new ListNode(1);
	ListNode *node2 = new ListNode(2);
	ListNode *node3 = new ListNode(3);
	ListNode *node4 = new ListNode(4);
	ListNode *node5 = new ListNode(5);
	ListNode *node6 = new ListNode(6);
	ListNode *node7 = new ListNode(7);
	node1->next = node2;
	node2->next = node3;
	node3->next = node4;
	node4->next = node5;
	node5->next = node6;
	node6->next = node7;
	node7->next = node1;
	if (IsLoop(node1) != nullptr)
	{
		cout << "链表有环" << endl;
	}
	else
	{
		cout << "链表无环" << endl;
	}
	return 0;
}

int foo3(void)
{
	//判断两个链表是否有公共节点

	// 1：2个链表都无环，判断最后一个节点是否相等

	ListNode *node1 = new ListNode(1);
	ListNode *node2 = new ListNode(2);
	ListNode *node3 = new ListNode(3);
	ListNode *node4 = new ListNode(4);
	ListNode *node5 = new ListNode(5);
	ListNode *node6 = new ListNode(6);
	ListNode *node7 = new ListNode(7);

	node1->next = node2;
	node2->next = node3;
	node3->next = node4;
	node4->next = node1;
	node5->next = node6;
	node6->next = node4;
	node7->next = node6;

	bool flag = TwoListMeet(node5, node7);

	return 0;
}

ListNode *reverseList(ListNode *head)
{
	ListNode *pre = nullptr;
	ListNode *cur = head;
	ListNode *nxt = nullptr;

	if (nullptr == head)
	{
		return nullptr;
	}

	if (nullptr == head->next)
	{

		return head;
	}

	while (nullptr != cur)
	{
		nxt = cur->next;
		cur->next = pre;
		pre = cur;
		cur = nxt;
	}

	return pre;
}

int foo4(void)
{
	//链表反转
	//定义3个节点

	ListNode *node1 = new ListNode(1);
	ListNode *node2 = new ListNode(2);
	ListNode *node3 = new ListNode(3);
	ListNode *node4 = new ListNode(4);
	ListNode *node5 = new ListNode(5);
	ListNode *node6 = new ListNode(6);
	ListNode *node7 = new ListNode(7);

	node1->next = node2;
	node2->next = node3;
	node3->next = node4;
	node4->next = node5;
	node5->next = node6;
	node6->next = node7;

	printNode(node1);

	printNode(reverseList(node1));
	return 0;
}

int main()
{

	// foo1();
	foo4();

	return 0;
}