Leetcode
- Leetcode -138.复制带随机指针的链表
- Leetcode -2130.链表最大孪生和
Leetcode -138.复制带随机指针的链表
题目：给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。
构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。
例如，如果原链表中有 X 和 Y 两个节点，其中 X.random-- > Y 。那么在复制链表中对应的两个节点 x 和 y ，同样有 x.random-- > y 。
返回复制链表的头节点。
用一个由 n 个节点组成的链表来表示输入 / 输出中的链表。每个节点用一个 [val, random_index] 表示：
val：一个表示 Node.val 的整数。
random_index：随机指针指向的节点索引（范围从 0 到 n - 1）；如果不指向任何节点，则为 null 。
你的代码 只 接受原链表的头节点 head 作为传入参数。
示例 1：
输入：head = [[7, null], [13, 0], [11, 4], [10, 2], [1, 0]]
输出： [[7, null], [13, 0], [11, 4], [10, 2], [1, 0]]
示例 2：
输入：head = [[1, 1], [2, 1]]
输出： [[1, 1], [2, 1]]
示例 3：
输入：head = [[3, null], [3, 0], [3, null]]
输出： [[3, null], [3, 0], [3, null]]
提示：
0 <= n <= 1000
- 10^4 <= Node.val <= 10^4
Node.random 为 null 或指向链表中的节点。
思路：思路是在原链表上动，将拷贝节点插入原节点后面，插入原链表节点的原因是，当前拷贝节点的 random 就是原节点的 random 的 next，方便复制拷贝节点的 random ；最后将原链表和拷贝节点分离，恢复原链表；
拷贝节点插入原节点后面：
复制random节点：
struct Node* copyRandomList(struct Node* head)
{
struct Node* cur = head;
//拷贝节点插入原节点后面
while (cur)
{
struct Node* copy = (struct Node*)malloc(sizeof(struct Node));
struct Node* next = cur->next;
copy->val = cur->val;
cur->next = copy;
copy->next = next;
cur = next;
}
//将拷贝节点插入原节点后面之后，当前拷贝节点的 random 就是原节点的 random 的 next
//复制random节点
cur = head;
while (cur)
{
struct Node* copy = cur->next;
if (cur->random == NULL)
{
copy->random = NULL;
}
else
{
copy->random = cur->random->next;
}
cur = copy->next;
}
//将复制链表和原链表分开
cur = head;
struct Node* copyhead = NULL, * copytail = NULL;
while (cur)
{
struct Node* copy = cur->next, * next = copy->next;
if (copyhead == NULL)
{
copyhead = copytail = copy;
}
else
{
copytail->next = copy;
copytail = copytail->next;
}
//恢复原链表
cur->next = next;
cur = next;
}
return copyhead;
}
Leetcode -2130.链表最大孪生和
题目：在一个大小为 n 且 n 为 偶数 的链表中，对于 0 <= i <= (n / 2) - 1 的 i ，第 i 个节点（下标从 0 开始）的孪生节点为第 (n - 1 - i) 个节点 。
比方说，n = 4 那么节点 0 是节点 3 的孪生节点，节点 1 是节点 2 的孪生节点。这是长度为 n = 4 的链表中所有的孪生节点。
孪生和 定义为一个节点和它孪生节点两者值之和。
给你一个长度为偶数的链表的头节点 head ，请你返回链表的 最大孪生和 。
示例 1：
输入：head = [5, 4, 2, 1]
输出：6
解释：
节点 0 和节点 1 分别是节点 3 和 2 的孪生节点。孪生和都为 6 。
链表中没有其他孪生节点。
所以，链表的最大孪生和是 6 。
示例 2：
输入：head = [4, 2, 2, 3]
输出：7
解释：
链表中的孪生节点为：
- 节点 0 是节点 3 的孪生节点，孪生和为 4 + 3 = 7 。
- 节点 1 是节点 2 的孪生节点，孪生和为 2 + 2 = 4 。
所以，最大孪生和为 max(7, 4) = 7 。
示例 3：
输入：head = [1, 100000]
输出：100001
解释：
链表中只有一对孪生节点，孪生和为 1 + 100000 = 100001 。
提示：
链表的节点数目是 [2, 10^5] 中的 偶数 。
1 <= Node.val <= 10^5
思路：思路是将链表中的值放入一个数组中，然后遍历数组，每次将数组中下标为 i 和 n - 1 - i 的元素加起来为，假设它们的和为 max ，每次进行判断取较大的 max 作为返回的最大孪生和；
int pairSum(struct ListNode* head)
{
//将链表中的值放入数组中
int arr[100000] = { 0 };
struct ListNode* cur = head;
int i = 0, n = 0, max = 0;
while (cur)
{
arr[n++] = cur->val;
cur = cur->next;
}
//遍历数组，每次将数组中下标为 i 和 n - 1 - i 的元素加起来为max，取较大的max
for (i = 0; i <= n / 2; i++)
{
max = arr[i] + arr[n - 1 - i] > max ? arr[i] + arr[n - 1 - i] : max;
}
return max;
}
