hello 大家好我是django，今天给大家带来的算法有 《链表中倒数第k个节点》，《复制带随机指针的链表》，《交换链表中的节点》，《两两交换链表中的节点》，《合并K个升序链表》
剑指 Offer 22. 链表中倒数第k个节点
- 要求
输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。
例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为4 的节点。
示例：
给定一个链表: 1->2->3->4->5, 和 k = 2.
返回链表 4->5.
- 思路
递归到循环链表bottom = head(i) + 1当bottom === k时目标找到
- 实现
/**
* @param {ListNode} head
* @param {number} k
* @return {ListNode}
*/
// 递归方法
var getKthFromEnd = function(head, k) {
let target;
function getBottom(node) {
if(!node) return 0;
const bottom = getBottom(node.next) + 1;
if(bottom === k) {
// 找到倒数第K相
target = node;
};
return bottom;
}
getBottom(head)
return target;
};
// 双指针 （快慢指针）
var getKthFromEnd = function(head, k) {
let slow = fast = head;
while(fast && k > 0) {
fast = fast.next;
k --;
}
while(fast) {
[fast, slow] = [fast.next, slow.next];
}
return slow;
};
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 作为传入参数。
- 思路
采用 hash + 回溯递归的方式进行求解，我们利用回溯的方式，让每个节点的拷贝操作相互独立。对于当前节点，我们首先要进行拷贝，然后我们进行「当前节点的后继节点」和「当前节点的随机指针指向的节点」拷贝，拷贝完成后将创建的新节点的指针返回，即可完成当前节点的两指针的赋值
- 实现
/**
* @param {Node} head
* @return {Node}
*/
var copyRandomList = function(head) {
function deepCopy(node, cacheNode = new Map()) {
if(!node) return null;
if(!cacheNode.has(node)) {
cacheNode.set(node, {val: node.val});
const newNode = cacheNode.get(node);
newNode.next = deepCopy(node.next, cacheNode)
newNode.random = deepCopy(node.random, cacheNode)
}
return cacheNode.get(node);
}
return deepCopy(head)
};
1721. 交换链表中的节点
- 要求
给你链表的头节点 head 和一个整数 k 。
交换 链表正数第 k 个节点和倒数第 k 个节点的值后，返回链表的头节点（链表 从 1 开始索引）。
示例 1：
输入：head = [1,2,3,4,5], k = 2
输出：[1,4,3,2,5]
示例 2：
输入：head = [7,9,6,6,7,8,3,0,9,5], k = 5
输出：[7,9,6,6,8,7,3,0,9,5
示例 3：
输入：head = [1], k = 1
输出：[1]
- 实现
/**
* @param {ListNode} head
* @param {number} k
* @return {ListNode}
*/
var swapNodes = function(head, k) {
let beforeNode;
let afterNode;
let beforeIndex = 0;
let curr = head;
const fakeHead = {val:0,next:head}
let endNode;
while(curr) {
if(!curr.next) {
endNode = curr;
curr.next = {val:0,next: null}
break;
}
curr = curr.next;
}
function findNode(node) {
if(!node) return 0;
if(beforeIndex === k - 1) {
beforeNode = node;
}
beforeIndex ++;
const afterIndex = findNode(node.next) + 1;
if(afterIndex === k + 1 ) {
afterNode = node;
}
return afterIndex;
}
endNode.next = null
findNode(fakeHead);
swap(beforeNode, afterNode)
swap(beforeNode.next, afterNode.next)
return fakeHead.next
};
function swap(node1, node2) {
const temp = node1.next
node1.next = node2.next;
node2.next = temp;
}
24. 两两交换链表中的节点
- 要求
给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
示例1：
输入：head = [1,2,3,4]
输出：[2,1,4,3]
示例 2：
输入：head = []
输出：[]
- 思路
Node(n).next = Node(n-1).next, Node(n-1).next = Node(n)
- 实现
/**
* @param {ListNode} head
* @return {ListNode}
*/
var swapPairs = function(head) {
if(!head || !head.next) return head
const temp = head.next;
head.next = swapPairs(temp.next)
temp.next = head;
return temp;
};
23. 合并K个升序链表（归并排序）
- 要求
给你一个链表数组，每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表中，返回合并后的链表。
示例 1：
输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
1->4->5,
1->3->4,
2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6
示例 2：
输入：lists = []
输出：[]
示例 3：
输入：lists = [[]]
输出：[]
提示：
k == lists.length
0 <= k <= 10^4
0 <= lists[i].length <= 500
-10^4 <= lists[i][j] <= 10^4
lists[i] 按 升序 排列
lists[i].length 的总和不超过 10^4
- 思路
本体应该结合合并两个列表的做法（类似于数组归并排序），并在此基础上进行顺序的依次合并
- 实现
/**
* @param {ListNode[]} lists
* @return {ListNode}
*/
var mergeKLists = function(lists) {
if(!lists.length) return null;
let head = lists[0];
for(let i = 1; i < lists.length; i++) {
head = merge_list(head, lists[i])
}
return head;
};
// 合并两个有序链表
// 类似于数组归并排序
function merge_list(list1, list2) {
const fakeHead = { val: null, next: null };
let tail = fakeHead;
while (list1 && list2) {
// 把小的链表放入新的链表中
if (list1.val > list2.val) {
tail.next = list2;
list2 = list2.next;
} else {
tail.next = list1;
list1 = list1.next;
}
tail = tail.next;
}
// 循环完成后list1还有节点时将剩余节点全部放入
while (list1) {
tail.next = list1;
list1 = list1.next;
tail = tail.next;
}
// 循环完成后list2还有节点时将剩余节点全部放入
while (list2) {
tail.next = list2;
list2 = list2.next;
tail = tail.next;
}
return fakeHead.next;
}
