链表中倒数第k个节点
问题描述： 输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。
例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。（by leetcode 剑指 Offer 22）
示例：
给定一个链表: 1->2->3->4->5, 和 k = 2.
返回链表 4->5.
思路： 先从头到尾循环链表，获取链表的长度n。在从头往后找（n-k）项，就是要找的倒数第K个节点。
/**
* Definition for singly-linked list.
* function ListNode(val) {
* this.val = val;
* this.next = null;
* }
*/
/**
* @param {ListNode} head
* @param {number} k
* @return {ListNode}
*/
var getKthFromEnd = function(head, k) {
if(head==null||head.next==null) return head;
let p=head;
let n=0;
while(p){
n++;
p=p.next;
}
k=n-(k%n||n);
p=head;
while(k){
k--;
p=p.next;
}
return p;
}
交换链表中的节点
问题描述： 给你链表的头节点 head 和一个整数 k 。
交换 链表正数第 k 个节点和倒数第 k 个节点的值后，返回链表的头节点（链表 从 1 开始索引）。(by leetcode 1721)
示例 1：
输入：head = [1,2,3,4,5], k = 2
输出：[1,4,3,2,5]
思路： 从头到尾遍历一遍链表，算出链表的长度n,从头找到第K个节点，从头找到（n-k）第倒数K个节点,交换两个节点的值。
/**
* Definition for singly-linked list.
* function ListNode(val, next) {
* this.val = (val===undefined ? 0 : val)
* this.next = (next===undefined ? null : next)
* }
*/
/**
* @param {ListNode} head
* @param {number} k
* @return {ListNode}
*/
var swapNodes = function(head, k) {
if(head==null||head.next==null)return head;
let p=head;
let n=0;
while(p){
p=p.next;
n++
}
p=head;
let k1=(k%n||n)-1;
while(k1){
k1--;
p=p.next
}
k=n-(k%n||n);
let q=head;
while(k){
k--;
q=q.next;
}
let s=q.val;
q.val=p.val;
p.val=s;
return head
};
（方法二）
var swapNodes = function(head, k) {
if(head==null||head.next==null)return head;
let p=head;
let q=head;
let flag=head;
let n=1;
while(flag){
if(n<k){
p=p.next;
}
if(n>k){
q=q.next
}
n++;
flag=flag.next
}
let val=p.val;
p.val=q.val;
q.val=val;
return head
};
两两交换链表中的节点
问题描述： 给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。（by leetcode 24）
示例 1：
输入：head = [1,2,3,4]
输出：[2,1,4,3]
思路： 需要用到一个临时指针，然后从头到尾找链表，交换每一组（相邻的两个）位置，用临时指针串联起来。
/**
* Definition for singly-linked list.
* function ListNode(val, next) {
* this.val = (val===undefined ? 0 : val)
* this.next = (next===undefined ? null : next)
* }
*/
/**
* @param {ListNode} head
* @return {ListNode}
*/
var swapPairs = function(head) {
if(head==null||head.next==null)return head;
let vir=new ListNode(0);
vir.next=head;
let temp=vir;
while(temp.next!==null&&temp.next.next!==null){
let p=temp.next;
let q=temp.next.next;
temp.next=q;
p.next=q.next;
q.next=p;
temp=temp.next.next
}
return vir.next;
};
合并K个升序链表
问题描述： 给你一个链表数组，每个链表都已经按升序排列。
请你将所有链表合并到一个升序链表中，返回合并后的链表。（by leetcode 23）
示例 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
思路： 用分治的思想，量量合并，再合并合并之后的，直到没有需要合并的项。
/**
* Definition for singly-linked list.
* function ListNode(val, next) {
* this.val = (val===undefined ? 0 : val)
* this.next = (next===undefined ? null : next)
* }
*/
/**
* @param {ListNode[]} lists
* @return {ListNode}
*/
var mergeKLists = function(list) {
function merge(list,l,r){
if(l>r)return null;
if(l==r)return list[l]
let mid=Math.floor((l+r)/2)
return mergeTwoLists(merge(list,l,mid),merge(list,mid+1,r))
}
function mergeTwoLists(list1,list2){
if(list1==null||list2==null){
return list1||list2
}
let temp=new ListNode(0);
let head=temp;
while(list1&&list2){
if(list1.val<=list2.val){
temp.next=list1;
list1=list1.next
}
else{
temp.next=list2;
list2=list2.next
}
temp=temp.next;
}
temp.next=list1?list1:list2
return head.next;
}
return merge(list,0,list.length-1);
};
复制带随机指针的链表
问题描述： 给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。
构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。(by leetcode 138)
例如，如果原链表中有 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]]
思路： 先从头到尾遍历一遍链表，在每个节点后面插入一个跟前一个节点一样的节点。再从头到尾遍历一遍链表，给每一个复制的节点添加random属性（注意：是复制节点random的下一个节点）。拆分链表，每隔一个节点取下来，练成新的链表，返回
/**
* // Definition for a Node.
* function Node(val, next, random) {
* this.val = val;
* this.next = next;
* this.random = random;
* };
*/
/**
* @param {Node} head
* @return {Node}
*/
var copyRandomList = function(head) {
if (head === null) {
return head;
}
let p=head;
while(p){
const nodeNew = new Node(p.val, p.next, null);
p.next = nodeNew;
p=nodeNew.next;
}
p=head;
while(p){
const nodeNew = p.next;
nodeNew.random = (p.random !== null) ? p.random.next : null;
p=nodeNew.next;
}
p=head;
let headNew=head.next
while(p){
let node=p.next;
p.next=node.next;
node.next = (node.next !== null) ? node.next.next : null;
p=p.next;
}
return headNew;
};
