package top100.top链表;import top100.ListNode;
import top100.Node;import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.HashMap;public class TOP {//160. 相交链表//hashmap方法太low了//判断链表是否相交//双指针遍历两个相交链表,如果有相遇点，路径节点数一定相同public ListNode getIntersectionNode(ListNode headA, ListNode headB) {if (headA == null || headB == null) {return null;}ListNode cur1 = headA, cur2 = headB;while (cur1 != cur2) { //如果相交，则一定会有cur1 = cur2，如果不相交，cur1 = cur2 = nullcur1 = cur1 == null ? headB : cur1.next;cur2 = cur2 == null ? headA : cur2.next;}return cur1;}//206. 反转链表public ListNode reverseList(ListNode head) {if (head == null) return null;ListNode pre = null, cur = head;while (cur != null) {ListNode next = cur.next;cur.next = pre;pre = cur;cur = next;}return pre;}//234. 回文链表//方法很多，反转链表，或者取出数据再判断public boolean isPalindrome(ListNode head) {if (head == null) {return true;}ArrayList<Integer> list = new ArrayList<>();while (head != null) {list.add(head.val);head = head.next;}for (int i = 0; i < list.size() / 2; i++) {int a = list.get(i);int b = list.get(list.size() - 1 - i);if (a != b) {return false;}}return true;}//反转链表的前一半再同时便利两部分public boolean isPalindrome(ListNode head) {if(head == null || head.next == null) return false;ListNode pre = null;ListNode slow = head, fast = head;//遍历的时候同时反转，很妙while(fast != null && fast.next != null){// 快指针每次前进两步fast = fast.next.next;// 每次循环将局部链表反转ListNode tmp = slow.next;slow.next = pre;pre = slow;slow = tmp;}// 1.偶数链表循环结束后，fast == null，// pre指向前半部分第一个回文数，slow指向后半部分第一个回文数// 2. 奇数链表循环结束后，fast !=null, fast.next == null// pre指向前半部分第一个回文数，slow指向后半部分第一个链表。// 要将slow向前推进一步if(fast != null) slow = slow.next;// 此时pre指向前半部分第一个回文数，slow指向后半部分第一个回文数while (pre != null || slow != null){if(pre.val != slow.val) return false;pre = pre.next;slow = slow.next;}return true;}//141. 环形链表//链表是否有环：快慢指针，如果有环，肯定会相遇public boolean hasCycle(ListNode head) {if (head == null) {return false;}ListNode slow = head, fast = head;while (fast != null && fast.next != null) {slow = slow.next;fast = fast.next.next;if (slow == fast) {return true;}}return false;}//142. 环形链表 II//链表的环：hashmap 或者 双指针public ListNode detectCycle(ListNode head) {if (head == null) {return null;}ListNode slow = head, fast = head;while (fast != null && fast.next != null) {slow = slow.next;fast = fast.next.next;if (slow == fast) { //遇到环，快指针重新走fast = head;while (fast != slow) {slow = slow.next;fast = fast.next;}return slow;}}return null;}//21. 合并两个有序链表public ListNode mergeTwoLists(ListNode list1, ListNode list2) {if (list1 == null) {return list2;}if (list2 == null) {return list1;}ListNode temp = new ListNode(-1);ListNode cur = temp;while (list1 != null && list2 != null) {if (list1.val < list2.val) {cur.next = list1;list1 = list1.next;} else {cur.next = list2;list2 = list2.next;}cur = cur.next;}if (list1 != null) {cur.next = list1;}if (list2 != null) {cur.next = list2;}return temp.next;}//2. 两数相加public ListNode addTwoNumbers(ListNode l1, ListNode l2) {int carry = 0;ListNode fake = new ListNode(-1);ListNode pre = fake;while(l1 != null || l2 != null || carry != 0) {int num1 = l1 == null ? 0 : l1.val;int num2 = l2 == null ? 0 : l2.val;ListNode cur = new ListNode((num1 + num2 + carry) % 10);pre.next = cur;pre = cur;carry = (num1 + num2 + carry) / 10;l1 = l1 == null ? null : l1.next;l2 = l2 == null ? null : l2.next;}pre.next = null;return fake.next;}//19. 删除链表的倒数第 N 个结点public ListNode removeNthFromEnd(ListNode head, int n) {ListNode dummy = new ListNode(-1);dummy.next = head;//双指针ListNode slow = head;ListNode fast = head;//fast先移动n个，再同时移动fast和slow,使fast在最后一个结点，则slow就是倒数第n个for (int i = 0; i < n; i++) {fast = fast.next;}ListNode pre = dummy;while (fast != null) {pre = slow;slow = slow.next;fast = fast.next;}pre.next = slow.next;return dummy.next;}//24. 两两交换链表中的节点//用了k个一组反转链表的方法public ListNode swapPairs(ListNode head) {if (head == null) return null;if (head.next == null) return head;ListNode dummy = head.next;ListNode next = dummy.next;//翻转dummy.next = head;head.next = swapPairs(next);return dummy;}//25. K 个一组翻转链表public ListNode reverseKGroup(ListNode head, int k) {if (head == null) return null;//计算结点是否有k个ListNode cur = head;for (int i = 0; i < k; i++) {if (cur == null) {return head;}cur = cur.next;}//翻转k个节点ListNode pre = null;cur = head;int count = 1;while (count <= k) {ListNode next = cur.next;cur.next = pre;pre = cur;cur = next;count++;}//拼接head.next = reverseKGroup(cur, k);return pre;}//138. 随机链表的复制public Node copyRandomList(Node head) {if (head == null) {return null;}//HashMap记录两个链表的对应情况HashMap<Node, Node> map = new HashMap<>();Node cur = head;while (cur != null) {map.put(cur, new Node(cur.val));cur = cur.next;}cur = head;while (cur != null) {map.get(cur).next = map.get(cur.next);map.get(cur).random = map.get(cur.random);cur = cur.next;}return map.get(head);}//148. 排序链表//链表的归并排序public ListNode sortList(ListNode head) {if (head == null || head.next == null) return head;//链表分割为两部分：快慢双指针//如果链表是偶数， 则需要找到中间节点的第一个//如果是找到链表中间节点的第二个，则可以去掉fast.next.next条件ListNode slow = head, fast = head;while (fast.next != null && fast.next.next != null) {fast = fast.next.next;slow = slow.next;}ListNode temp = slow.next;//slow就是中间节点的第一个slow.next = null; //断开链表//递归排序两个链表ListNode left = sortList(head);ListNode right = sortList(temp);//合并排序后的链表ListNode dummy = new ListNode(-1);ListNode cur = dummy;while (left != null && right != null) {if (left.val < right.val) {cur.next = left;left = left.next;} else {cur.next = right;right = right.next;}cur = cur.next;}//剩余部分添加到后面cur.next = left != null ? left : right;return dummy.next;}//23. 合并 K 个升序链表//归并排序链表数组，最终实现两两合并链表public ListNode mergeKLists(ListNode[] lists) {if (lists.length == 0) return null;return mergeKLists(lists, 0, lists.length - 1);}private ListNode mergeKLists(ListNode[] lists, int left, int right) {//只有一个链表时，有序，返回该列表的头节点if (left == right) return lists[left];//递归int mid = left + (right - left) / 2;ListNode node1 = mergeKLists(lists, left, mid);ListNode node2 = mergeKLists(lists, mid + 1, right);//合并ListNode dummy = new ListNode(-1);ListNode cur = dummy;while (node1 != null && node2 != null) {if (node1.val < node2.val) {cur.next = node1;node1 = node1.next;} else {cur.next = node2;node2 = node2.next;}cur = cur.next;}cur.next = node1 == null ? node2 : node1;return dummy.next;}//146. LRU 缓存class LRUCache {//需要一个hashmap记录数据//需要对key值按照使用的顺序排序：双向链表，队列等int capacity;HashMap<Integer, Integer> map;ArrayDeque<Integer> deque; //最近使用的数据放在队首public LRUCache(int capacity) {this.capacity = capacity;this.map = new HashMap<>();this.deque = new ArrayDeque<>();}public int get(int key) {if (map.containsKey(key)) {//最近使用了数据，放到队首deque.remove(key);deque.offerFirst(key);return map.get(key);} else {return -1;}}public void put(int key, int value) {if (map.containsKey(key)) {map.put(key, value);deque.remove(key);} else {if (map.size() == capacity) {//新加入数据导致超出容量，删除队尾的数据map.remove(deque.pollLast());}map.put(key, value);}//新加入的数据或者更新的数据都放在队首deque.offerFirst(key);}}
}