【Leetcode】链表

链表

160. 相交链表

206. 反转链表

234. 回文链表

141. 环形链表

142. 环形链表 II

21. 合并两个有序链表

2. 两数相加

19. 删除链表的倒数第 N 个结点

25. K 个一组翻转链表

138. 随机链表的复制

148. 排序链表

23. 合并 K 个升序链表

146. LRU 缓存

160. 相交链表

方法一：模拟

依次判断两节点是否相同即可

public class Solution {public ListNode getIntersectionNode(ListNode headA, ListNode headB) {ListNode nodeA = headA;ListNode nodeB = headB;int lenA = 0, lenB = 0;while(nodeA.next != null) {lenA++;nodeA = nodeA.next;}while(nodeB.next != null) {lenB++;nodeB = nodeB.next;}int diffLen = lenA>=lenB ? lenA-lenB : lenB-lenA;// 保证 A链表 比 B链表 长if(lenA < lenB) {ListNode temp = headA;headA = headB;headB = temp;}while(diffLen-- > 0) {headA = headA.next;}while(headA != null) {if(headA == headB) {return headA;}headA = headA.next;headB = headB.next;}return null;}
}

方法二：快慢指针，消除步长差

图解相交链表

1. 假设链表A为 ***** x #####，链表B为**** x #####，相交点为x，相交部分为x #####；则链表A中各部分的长度为a(*)+a(1)+a(#)，链表B中各部分的长度为b(*)+b(1)+b(#)，由上可知a(*)!=b(*)，但a(#)=b(#)
2. 使用pA指针先遍历A再遍历B，到相交点的长度为：a(*)+a(1)+a(#) + b(*)+b(1)
3. 使用pB指针先遍历B再遍历A，到相交点的长度为：b(*)+b(1)+b(#) + a(*)+a(1)
4. 那么a(*)+a(1)+a(#) + b(*)+b(1) 与b(*)+b(1)+b(#) + a(*)+a(1) 的关系是怎样的？
   1. 已知a(*)!=b(*)，但a(#)=b(#)
   2. 则，a(*)+a(1)+a(#) + b(*)+b(1) = a(*)+a(1)+b(#) + b(*)+b(1) = a(*)+a(1)+ b(#)+ b(*)+b(1) = b(*)+b(1)+b(#) + a(*)+a(1)

public class Solution {public ListNode getIntersectionNode(ListNode headA, ListNode headB) {if(headA == null || headB == null) {return null;}ListNode pA = headA, pB = headB;while(pA != pB) {// 当pA==null时，说明遍历到了A的末尾，从B开始遍历pA = pA==null ? headB : pA.next;// 当pB==null时，说明遍历到了B的末尾，从A开始遍历pB = pB==null ? headA : pB.next;}return pA;}
}

206. 反转链表

方法一：迭代

class Solution {public ListNode reverseList(ListNode head) {ListNode pre=null, cur=head, temp=null;while(cur != null){temp = cur.next;cur.next = pre;pre = cur;cur = temp;}return pre;}
}

方法二：递归

class Solution {public ListNode reverseList(ListNode head) {return reverse(null, head);}private ListNode reverse(ListNode pre, ListNode cur) {if(cur == null) {return pre;}ListNode temp = null;temp = cur.next;cur.next = pre;return reverse(cur, temp);}
}

234. 回文链表

方法一：快慢指针

/*** Definition for singly-linked list.* public class ListNode {*     int val;*     ListNode next;*     ListNode() {}*     ListNode(int val) { this.val = val; }*     ListNode(int val, ListNode next) { this.val = val; this.next = next; }* }*/
class Solution {public boolean isPalindrome(ListNode head) {if(head == null) {return true;}// 快慢指针，快指针移动到末尾时，慢指针所指位置是中间节点ListNode fast = head, slow = head;while(fast != null) {fast = fast.next;if(fast != null) {fast = fast.next;}slow = slow.next;}// 翻转后半段的链表ListNode node = reverse(slow);// 比较 经过反转后的后半段链表 和 前半段的链表while(node != null) {if(head.val != node.val) {return false;}head = head.next;node = node.next;}return true;}// 反转链表private ListNode reverse(ListNode cur) {ListNode pre = null, post = null;while(cur != null) {post = cur.next;cur.next = pre;pre = cur;cur = post;}return pre;}
}

141. 环形链表

方法一：快慢指针

利用快慢指针判断当前链表中是否含有换，如果两个指针相遇，则说明链表中有环

public class Solution {public boolean hasCycle(ListNode head) {ListNode fast = head, slow = head;// 排除只含有一个元素，且无环的情况，例如例三head=[1]if(head == null || head.next == null){return false;}// 快慢指针，快指针移两格，慢指针移一格，两指针相遇则说明存在环while(fast != null) {fast = fast.next;if(fast != null) {fast = fast.next;}slow = slow.next;// 放在移动后判断，因为一开始指针指向同一位置if(fast == slow) {return true;}}return false;}
}

142. 环形链表 II

方法一：快慢指针

1. 判断是否存在环（快慢指针在环中相遇）
2. 判断入环的位置，由上图，
   1. 快指针走过的位置为a+n*(b+c) + b，n为走过的环的圈数；慢指针走过的距离为a+b；
   2. 快指针每次移动两步，慢指针每次移动一步
   3. 则有：a+n*(b+c) + b = 2*(a+b)，化简：a = (n-1)*(b+c) + c
   4. 因此，一个指针从head开始走a步到入环点，另一个指针在环中走n-1圈+相遇点到入环点的距离；两者相等

public class Solution {public ListNode detectCycle(ListNode head) {ListNode fast = head, slow = head;while(fast!=null && fast.next!=null) {fast = fast.next.next;slow = slow.next;// 快慢指针相遇，存在环if(fast == slow) {// 寻找环中的第一个节点ListNode index1 = head;ListNode index2 = fast;while(index1 != index2) {index1 = index1.next;index2 = index2.next;}return index1;}}return null;}
}

21. 合并两个有序链表

方法一：迭代

1. 定义变量：temp用于记录已合并链表的最大元素，list1和list2指向两个未合并链表的头元素，head记录已合并的连链表头元素
2. 依次比较list1和list2所指向元素的值，将temp指向两者中的较小一个，并更新指针temp以及list1 / list2
3. 当list1 / list2遍历到结尾时，将另一链表的剩余元素插入即可

class Solution {public ListNode mergeTwoLists(ListNode list1, ListNode list2) {if(list1==null) return list2;if(list2==null) return list1;ListNode temp = null;if(list1.val < list2.val) {temp = list1;list1 = list1.next;} else {temp = list2;list2 = list2.next;}ListNode head = temp;// System.out.println(list1.val + "," + list2.val);// 指针变化条件：两指针所指位置均不为空while(!(list1==null || list2==null)) {if(list1.val < list2.val) {temp.next = list1;list1 = list1.next;} else {temp.next = list2;list2 = list2.next;}temp = temp.next;}// 其中一个指针所指位置为空，则将另一链表的剩余分布添加到当前链表中即可if(list1==null) {temp.next = list2;} else {temp.next = list1;}return head;}}

方法二：迭代（化简）

class Solution {public ListNode mergeTwoLists(ListNode list1, ListNode list2) {// 设置fakehead，返回值为fakehead.next，不用关心temp究竟指向list1还是list2ListNode fakehead = new ListNode(-1);ListNode temp = fakehead;// 指针变化条件：两指针所指位置均不为空while(!(list1==null || list2==null)) {if(list1.val < list2.val) {temp.next = list1;list1 = list1.next;} else {temp.next = list2;list2 = list2.next;}temp = temp.next;}// 其中一个指针所指位置为空，则将另一链表的剩余分布添加到当前链表中即可temp.next = list1==null ? list2 : list1;return fakehead.next;}}

2. 两数相加

方法一：模拟

1. 题目要求，将两个链表对应的元素相加sum，并将其个位sum%10存到一个新的ListNode中，同时应该注意进位carry=sum/10
2. 初始变量，使用head和tail记录新链表的首尾元素，插入第一个元素时更新首尾指针；之后，一直更新尾指针。
3. 最后，计算完成后，记得判断最后一次计算是否有进位，如有则将该数据存入链表

class Solution {public ListNode addTwoNumbers(ListNode l1, ListNode l2) {ListNode head = null, tail = null;// 进位int carry = 0;while(l1 != null || l2 != null) {int n1 = l1!=null ? l1.val : 0;int n2 = l2!=null ? l2.val : 0;int sum = n1 + n2 + carry;// 处理首尾节点if(head == null) {// 头节点，记录首元素head = tail = new ListNode(sum % 10);} else {// 剩余节点使用tail标记，并更新tail指针tail.next = new ListNode(sum % 10);tail = tail.next;}carry = sum / 10;if(l1 != null) l1 = l1.next;if(l2 != null) l2 = l2.next;}// 更新最后一个进位元素，如果最高位存在进位，则需要单另创建一个节点更新该值，如示例三if(carry > 0) {tail.next = new ListNode(carry);}return head;}
}

方法二：模拟

1. 与前述方法类似，只是用fakehead标记头节点，采用temp指针更新元素
2. 注意：while(l1!=null || l2!=null)与while(!(l1==null || l1==null))的区别

class Solution {public ListNode addTwoNumbers(ListNode l1, ListNode l2) {ListNode fakehead = new ListNode(-1);ListNode temp = fakehead;int add = 0;while(l1!=null || l2!=null) {int n1 = l1!=null ? l1.val : 0;int n2 = l2!=null ? l2.val : 0;int sum = n1 + n2 + add;temp.next = new ListNode(sum % 10);temp = temp.next;add = sum / 10;if(l1 != null) l1 = l1.next;if(l2 != null) l2 = l2.next;}if(add > 0) {temp.next = new ListNode(add);}return fakehead.next;}
}

19. 删除链表的倒数第 N 个结点

方法一：双指针

1. 创建fakehead，对于删除头结点的情况不用分类讨论
2. 注意right和left的遍历位置，left需要停到待删除位置的前一个位置，不然无法通过left.next = left.next.next修改指针指向

class Solution {public ListNode removeNthFromEnd(ListNode head, int n) {// 创建fakehead，对于删除头结点的情况不用分类讨论ListNode fakehead = new ListNode(-1);fakehead.next = head;ListNode left = fakehead, right = fakehead;for(int i=0; i<n; i++) {right = right.next;}while(right.next != null) {right = right.next;left = left.next;}left.next = left.next.next;return fakehead.next;}
}

24. 两两交换链表中的节点

24. 两两交换链表中的节点

方法一：模拟，双指针

使用firstNode和secondNode记录待交换的两个元素，cur为待交换元素的前一个元素，依次模拟指针的变化即可

class Solution {public ListNode swapPairs(ListNode head) {ListNode fakehead = new ListNode(-1);fakehead.next = head;ListNode cur = fakehead;ListNode firstNode = null, secondNode = null;while(cur.next!=null && cur.next.next!=null) {firstNode = cur.next;secondNode = cur.next.next;cur.next = secondNode;firstNode.next = secondNode.next;secondNode.next = firstNode;cur = firstNode;}return fakehead.next;}
}

25. K 个一组翻转链表

方法一：模拟

class Solution {public ListNode reverseKGroup(ListNode head, int k) {ListNode fakehead = new ListNode(-1);fakehead.next = head;ListNode pre = fakehead;while(head != null) {ListNode tail = pre;// 剩余元素不足k个，不进行翻转，将结果直接返回即可for(int i=0; i<k; i++) {tail = tail.next;if(tail == null) {return fakehead.next;}}// newhead 为新一组元素首节点ListNode newhead = tail.next;ListNode[] reverse = myReverse(head, tail);head = reverse[0];tail = reverse[1];pre.next = head;tail.next = newhead;pre = tail;head = pre.next;}return fakehead.next;}private ListNode[] myReverse(ListNode head, ListNode tail) {ListNode prev = tail.next;ListNode p = head;while(prev != tail) {ListNode newhead = p.next;p.next = prev;prev = p;p = newhead;}return new ListNode[]{tail, head};}
}

138. 随机链表的复制

方法一：迭代，哈希表

https://leetcode.cn/problems/copy-list-with-random-pointer/description/comments/2247988

class Solution {public Node copyRandomList(Node head) {Node fakehead = new Node(-1);Node p = head, q = fakehead;HashMap<Node, Node> map = new HashMap<>();// 第一次遍历，新建链表节点，并将p中的val值复制到新结点中while(p != null) {q.next = new Node(p.val);q = q.next;map.put(p, q);p = p.next;}// 第二次遍历，建立random的映射，从map中根据p.random取出节点，并作为q.randomp = head;q = fakehead.next;while(p != null) {if(p.random != null) {q.random = map.get(p.random);}p = p.next;q = q.next;}return fakehead.next;       }
}

148. 排序链表

方法一：遍历+替换

遍历一遍链表中的元素值，并记录在ArrayList中；之后利用Collections.sort(list)对当前ArrayList中的数字排序；最后，遍历数组元素，将元素值进行替换

注意，使用该思路实现并不符合题意！！！

class Solution {public ListNode sortList(ListNode head) {ListNode fakehead = new ListNode(-1);fakehead.next = head;List<Integer> list = new ArrayList<>();while(head != null) {list.add(head.val);head = head.next;}Collections.sort(list);head = fakehead.next;for(int temp : list) {head.val = temp;head = head.next;}return fakehead.next;}
}

23. 合并 K 个升序链表

方法一：两两合并

依次将前一链表合并到后后一链表中，并将后一链表的头节点记录下来；重复上述过程，即可完成链表的合并；最后，返回值因为ListNode[]中的最后一个元素，即为最后一个链表的头节点。

链表两两合并，可参考上述21. 合并两个有序链表

class Solution {// 合并K个链表public ListNode mergeKLists(ListNode[] lists) {int len = lists.length;if(len == 0) return null;if(len == 1) return lists[0];for(int i=0; i<len-1; i++) {// 合并两链表，将前一链表的结果合并到后一链表中lists[i+1] = mergeList(lists[i], lists[i+1]);}// 最后合并后的结果为最后一个链表的头节点return lists[len-1];}// 合并两个链表private ListNode mergeList(ListNode list1, ListNode list2) {ListNode fakehead = new ListNode(-1);ListNode temp = fakehead;while(list1!=null && list2!=null) {if(list1.val < list2.val) {temp.next = list1;list1 = list1.next;} else {temp.next = list2;list2 = list2.next;}temp = temp.next;}temp.next = list1==null ? list2 : list1;return fakehead.next;}
}

方法二：分治法

将一个ListNode[]数组一分为二，合并前半部分和右半部分；依次递归执行

mid = (left + right) >> 1为(left+right)/2，对于left和right较大的情况，可防止数据溢出。也可写为left+(right-left)/2

class Solution {// 合并K个链表public ListNode mergeKLists(ListNode[] lists) {int len = lists.length;if(len == 0) return null;if(len == 1) return lists[0];return merge(lists, 0, len-1);}private ListNode merge(ListNode[] lists, int left, int right) {if(left == right) return lists[left];if(left > right) return null;int mid = (left + right) >> 1;// 分治法 合并return mergeList(merge(lists, left, mid), merge(lists, mid+1, right));}// 合并两个链表【和前述方法中的两两合并相同】private ListNode mergeList(ListNode list1, ListNode list2) {ListNode fakehead = new ListNode(-1);ListNode temp = fakehead;while(list1!=null && list2!=null) {if(list1.val < list2.val) {temp.next = list1;list1 = list1.next;} else {temp.next = list2;list2 = list2.next;}temp = temp.next;}temp.next = list1==null ? list2 : list1;return fakehead.next;}
}

方法三：优先队列

【待补充】

146. LRU 缓存

方法一：双向链表 + 哈希表

1. 定义四个函数addToHaed, removeNode, moveToHead, removeTail用于处理双端队列中节点移动情况（指针变化情况）
2. 设置fakehead以及faketail来初始化双向链表
3. 使用HashMap(cache)记录当前链表中存在的元素

class LRUCache {class DLinkedNode {int key;int value;DLinkedNode prev;DLinkedNode next;public DLinkedNode() {};public DLinkedNode(int _key, int _value) {key = _key;value = _value;}}private Map<Integer, DLinkedNode> cache = new HashMap<>();private int size;private int capacity;private DLinkedNode fakehead, faketail;public LRUCache(int capacity) {this.size = 0;this.capacity = capacity;fakehead = new DLinkedNode();faketail = new DLinkedNode();fakehead.next = faketail;faketail.next = fakehead;}public int get(int key) {DLinkedNode node = cache.get(key);if(node == null) {return -1;}// 访问该元素，将该元素移动到双端列表头节点，表示最近访问moveToHead(node);return node.value;}public void put(int key, int value) {DLinkedNode node = cache.get(key);if(node == null) {DLinkedNode newNode = new DLinkedNode(key, value);cache.put(key, newNode);addToHaed(newNode);size++;// 当前元素值超过了设置容量，将双端列表的最后一个元素（最久为访问）删除if(size > capacity) {DLinkedNode tail = removeTail();cache.remove(tail.key);size--;}} else {// 访问了当前元素，将该元素移动到双端列表首位，表示最近访问node.value = value;moveToHead(node);}}// 头插法private void addToHaed(DLinkedNode node) {node.prev = fakehead;node.next = fakehead.next;fakehead.next.prev = node;fakehead.next = node;}// 移除节点，只需要将节点的前后两个指针分别指向前后元素即可private void removeNode(DLinkedNode node) {node.prev.next = node.next;node.next.prev = node.prev;}// 将节点移动到头元素，删除-插入private void moveToHead(DLinkedNode node) {removeNode(node);addToHaed(node);}// 移除节点private DLinkedNode removeTail() {DLinkedNode res = faketail.prev;removeNode(res);return res;}}/*** Your LRUCache object will be instantiated and called as such:* LRUCache obj = new LRUCache(capacity);* int param_1 = obj.get(key);* obj.put(key,value);*/