牛客网刷题之链表（二）
链表
- NB8 牛牛队列成环（判断是否有环）
- NB9 牛群分隔（重新排序）
- NB10 牛群旋转（链表旋转）
- NB11 牛群的合并（合并多个单链表）
- NB12 牛群的身高排序（单链表排序）
- NB13 牛的品种排序IV（0/1排序）
- NB14 牛群编号的回文顺序（是否回文）
- NB15 牛群编号的回文顺序II（回文2）
NB8 牛牛队列成环（判断是否有环）
描述：
农场里有一群牛，它们被组织成一个链表形式的队列。每头牛都有一个编号（每只牛编号唯一），编号范围是[-105, 105]。每头牛都有一个指针，指向它后面的一头牛。但是，有一些顽皮的牛可能会指向它们前面的某一头牛，从而形成一个环。
现在，给你一个链表的头节点 head，判断这个牛队列中是否有环。
问题分析：首先说一下这道题和链表中是否有环的区别：1. 其中链表有环，是最后结点的next指向前面的某个结点，构成一个环状；2.而这道题最后一个节点的next指向空，是没有环状结构的，但是前面结点中的值有的是重复的（每只牛编号唯一），这些重复的值可以构成“环状”，可以说是将值模拟成环状。
解题思路：链表中是否有环，通常用快慢指针来解决，慢指针走一步，快指针走两步，当有环时，快慢指针必相遇，为什么必相遇？ 假设链表带环，两个指针最后都会进入环，快指针先进环，慢指针后进环。当慢指针刚进环时，可能就和快指针相遇了，最差情况下两个指针之间的距离刚好就是环的长度。此时，两个指针每移动一次，之间的距离就缩小一步，不会出现每次刚好是套圈的情况，因此：在满指针走到一圈之前，快指针肯定是可以追上慢指针的，即相遇。而且相遇之前这个环最多被遍历两边。 所以上面这道题就可以用快慢指针来解决，遍历重复数据最多将遍历两遍。
代码如下：
bool hasCycle(ListNode* head)
{
// write code here
ListNode* slow = head, * fast = head->next;
while (fast != nullptr && fast->next != nullptr)
{
if (slow->val == fast->val)
return true;
slow = slow->next;
fast = fast->next->next;
}
return false;
}
NB9 牛群分隔（重新排序）
描述：
农场里有一群牛，每头牛都有一个编号，编号由一个整数表示，整数范围是[0, 100]，同时也表示牛的体重级别。牛群中的牛用单链表表示。
现在，农场主想要调整牛群的顺序，使体重较大的牛在一边，体重较小的牛在一边。给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有小于 x 的节点都出现在大于或等于 x 的节点之前。
你应当保留两个分区中每个节点的初始相对位置。
问题分析：要将单链表按照大小重新排序，使大的在一边，小的在一边，所以定义两个头结点，遍历单链表，一个头结点连接大的结点，另一个头结点连接小的结点，然后再进行合并，给nullptr的给nullptr即可。
代码如下：
ListNode* cow_partition(ListNode* head, int x)
{
// write code here
ListNode* headsmall = new ListNode(-1);
ListNode* headgreat = new ListNode(-1);
ListNode* cur = head, * cur1 = headsmall, * cur2 = headgreat;
while (cur)
{
if (cur->val < x) //小的插入到headsmall
{
cur1->next = cur;
cur1 = cur1->next;
}
else //大的插入到headgreat
{
cur2->next = cur;
cur2 = cur2->next;
}
cur = cur->next;
}
//将两个链表合并
cur1->next = headgreat->next;
cur2->next = nullptr;
head = headsmall->next;
//删除
delete headsmall;
delete headgreat;
return head;
}
NB10 牛群旋转（链表旋转）
描述：
农场里有一群牛，每头牛都有一个编号，编号由一个整数表示，整数范围是[-100, 100]。牛群中的牛用单链表表示。
现在，农场主想要调整牛群的顺序。给你一个链表的头节点 head ，将链表每头牛向右移动 k 个位置。
问题分析：将链表向右移动 k 个位置，头结点就变成原来链表的倒数第k个结点，所以可以用快慢指针，找出倒数第k个位置的结点，然后将链表重新连接起来。倒数第k个位置结点的前一个结点的next需要修改为空，所以直接找倒数第k+1个结点。
代码如下：
ListNode* rotateLeft(ListNode* head, int k)
{
//k可能比链表的长度大，所以先将k取余
ListNode* cur = head;
int length = 0;
while (cur)
{
++length;
cur = cur->next;
}
k %= length;
//快慢指针寻找第k+1个结点的位置
ListNode* fast = head, * slow = head;
while (k--)
{
fast = fast->next;
}
while (fast->next)
{
fast = fast->next;
slow = slow->next;
}
//将链表重新进行连接
fast->next = head;
head = slow->next;
slow->next = nullptr;
return head;
}
NB11 牛群的合并（合并多个单链表）
描述：
农场主人有多个牛群，每个牛群中的牛都按照编号升序排列。现在农场主人想把所有牛群合并成一个大牛群，同时要求合并后的大牛群中的牛依然按照编号升序排列。请你编写一个程序，实现这个功能。
问题分析：这道题是合并多个有序链表，是在合并两个有序链表的基础上进行循环，用一个变量 head 指向合并的链表，第 i 次循环把第 i 个链表和 head 合并，答案保存到 head 中。
代码如下：
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2)
{
if (!l1 || !l2)
return l1 ? l1 : l2;
ListNode* head = new ListNode(-1);
ListNode* cur = head, * p1 = l1, * p2 = l1;
while (l1 && l2)
{
if (p1->val < p2->val)
{
cur->next = p1;
p1 = p1->next;
}
else
{
cur->next = p2;
p2 = p2->next;
}
cur = cur->next;
}
//至少有一个链表为空，cur->next连接不为空的链表
cur->next = (p1 ? p1 : p2);
cur = head->next;
delete head;
return cur;
}
ListNode* mergeKLists(vector<ListNode*>& lists)
{
// write code here
ListNode* head = nullptr;
for (int i = 0; i < lists.size(); ++i)
head = mergeTwoLists(head, lists[i]);
return head;
}
NB12 牛群的身高排序（单链表排序）
描述：
农场主人记录了一群牛的身高，并将它们按照链表的形式存储。链表的头结点为 head，请你将这些身高数据按升序排列，并返回排序后的链表。
问题分析：这道题本意就是对单链表进行排序，第一种方法就是新建一个结点，进行插入，遍历，比较，排序，时间复杂度为O(n^2)；第二种方法是归并排序 ，归并排序说简单些就是将一堆n个数分成n个块，然后将n个块弄成大点的n/2个块，直到合成一个块。那么如何归并呢？会合并两个有序单链表吧，也会寻找单链表的中间结点吧，在这两个算法基础上就可以对单链表进行排序。
归并排序代码如下：
//快慢指针寻找中间结点
ListNode* split(ListNode* head)
{
ListNode* slow = head, * fast = head->next;
while (fast != nullptr && fast->next != nullptr)
{
slow = slow->next;
fast = fast->next->next;
}
ListNode* mid = slow->next;
slow->next = nullptr; //断尾
return mid;
}
//合并两个有序链表
ListNode* mergeTwoLists(ListNode* head1, ListNode* head2)
{
ListNode head(0), * p = &head;
while (head1 != nullptr && head2 != nullptr)
{
if (head1->val < head2->val)
{
p->next = head1;
head1 = head1->next;
}
else
{
p->next = head2;
head2 = head2->next;
}
p = p->next;
}
//至少有一个链表为空，cur->next连接不为空的链表
p->next = (head1 ? head1 : head2);
return head.next;
}
ListNode* sortList(ListNode* head)
{
// write code here
if (head == nullptr || head->next == nullptr)
return head;
ListNode* head1 = head;
ListNode* head2 = split(head);
head1 = sortList(head1);
head2 = sortList(head2);
return mergeTwoLists(head1, head2);
}
插入代码如下：
ListNode* sortList(ListNode* head)
{
// write code here
if (head == nullptr || head->next == nullptr)
return head;
ListNode newhead(-1);
newhead.next = head;
ListNode* cur = head->next; //用来遍历head链表
ListNode* p1 = &newhead; //用来进行插入
newhead.next->next = nullptr; //末尾结点指针置空
while (cur)
{
while (p1->next && cur->val > p1->next->val)
{
p1 = p1->next;
}
ListNode* p2 = p1->next;
p1->next = cur;
ListNode* next = cur->next;
cur->next = p2;
cur = next;
//插入完一个结点后，p1重新赋值
p1 = &newhead;
}
return newhead.next;
}
NB13 牛的品种排序IV（0/1排序）
描述：
在一个牧场中，有n头牛，牛的品种分为黑牛和白牛，用0和1分别表示。现在需要对牛群进行排序，使得相同品种的牛相邻，并按照黑牛和白牛的顺序排列。这些牛是按照链表的形式存储的。
请你在不使用库内置的sort函数的情况下解决这个问题。
题目分析：这道题常规操作就是定义两个头结点，一个头插0结点，另一个头插1节点，然后将两个链表连接起来；也可以定义一个头结点，记录第一个0结点插入的位置，在头结点后面插0结点，在第一个0结点后插1结点，两种思路大致一样。
ListNode* sortCowsIV(ListNode* head)
{
// write code here
ListNode newhead(-1);
newhead.next = nullptr;
ListNode* end = &newhead; //记录第一个0结点插入的位置
int i = 1;
ListNode* cur = head;
while (cur)
{
ListNode* next = cur->next;
if (cur->val == 0)
{
cur->next = newhead.next;
newhead.next = cur;
if (i) //记录第一次0的位置
{
end = cur;
--i;
}
}
else
{
cur->next = end->next;
end->next = cur;
}
}
return newhead.next;
}
NB14 牛群编号的回文顺序（是否回文）
描述：
农场里有一些牛，每头牛都有一个编号（0-9）。这些牛按照一定的顺序站立，我们可以把这个顺序看作是一个单链表，牛的编号就是链表的节点。现在农场主想知道，这些牛的编号顺序是否是回文的。如果是，返回 true ；否则，返回 false 。
题目分析：可以将链表中的数据保存到一个vector数组中，然后判断这个数组是否回文。
bool isPalindrome(ListNode* head)
{
// write code here
vector<int> v;
while (head)
{
v.push_back(head->val);
head = head->next;
}
for (int i = 0, j = v.size() - 1; i < j; ++i, --j)
{
if (v[i] != v[j])
{
return false;
}
}
return true;
}
NB15 牛群编号的回文顺序II（回文2）
描述：
农场里有一些牛，每头牛都有一个编号（0-9）。这些牛按照一定的顺序站立，我们可以把这个顺序看作是一个单链表，牛的编号就是链表的节点。现在农场主想知道，这些牛的编号顺序是否是回文的。如果是，则返回空链表；如果不是，返回最大的连续回文子链表的头节点（保证唯一）。
问题分析：判断一个单链表是否是回文链表，如果是，则返回空；如果不是，则返回链表的最大回文子链表。这里投机取巧一下，将链表输入到一个数组中，再找这个数组中最大的回文子序列。
bool isPalindrome(ListNode* head)
{
// write code here
vector<int> v;
while (head)
{
v.push_back(head->val);
head = head->next;
}
for (int i = 0, j = v.size() - 1; i < j; ++i, --j)
{
if (v[i] != v[j])
{
return false;
}
}
return true;
}
ListNode* maxPalindrome(ListNode* head)
{
// write code here
if (isPalindrome(head)) //如果是回文，返回nullptr
return nullptr;
vector<ListNode*> v; //将链表搞到一个数组里，在这个数组中找最大子链长
int max = 0;
int p1 = 0, p2 = 0;
int start = 0, end = 0;
while (head)
{
v.push_back(head);
head = head->next;
}
for (int i = 0; i < v.size(); ++i)
{
p1 = i;
p2 = i + 1;
while ((p1 >= 0 && p2 + 1 < v.size()) && (v[p1]->val == v[p2]->val || v[p1]->val == v[p2 + 1]->val)) //回文的个数可能是奇数，所以不但要比较相邻两个数，还要比较相隔一个数的两个数
{
if (v[p1]->val == v[p2 + 1]->val && p2 - p1 == 2) //回文的个数是奇数，++p2
++p2;
--p1;
++p2;
}
if (p2 - p1 > max) //将最大的子序列进行标记
{
start = p1;
end = p2;
max = p2 - p1;
}
}
v[end]->next = nullptr;
return v[start];
}
以上为牛客网面试高频TOP202中链表题。