LeetCode:链表专题

链表，与数组有异，宜插入删除，不宜搜索。
需知，链表有单链表和双向链表以及环形链表。
对节点的插入、删除、新增操作要熟记于心。
需掌握的解题方法有：虚拟头结点、双指针（快慢指针）

141 环形链表

思路：快慢指针

慢指针一次走一步，快指针一次走两步，如果是环形，结果必相交

160 相交链表

思路：模拟

做了好多次了，同样不展示代码

206. 反转链表

思路：把图画出来
重点 ：用next记录下一个要访问的节点，配合虚拟头结点很容易做出来

234 回文链表

• 解法一：既然链表做不来，就转到数组上做
• 解法二：快慢指针
• 解法三：递归，比较难，不要求掌握
• 解法四：利用栈和队列的性质解题

21 合并两个有序链表

• 迭代算法：基础中的基础
• 递归算法：链表也可以玩递归哦！

147 对链表进行插入排序

插入排序：插入排序的思想就是维护已排序队列

链表的插入与数组的插入有很大的不同，链表的插入只要O(1)的时间复杂度，而数组插入后元素要后移所以需要O(n)的时间复杂度。
重点：维护cur、lastInOrder,以及在排序链表中找到要插入的位置。

148 排序链表

归并排序：递归的思想，将链表分为好多个小链表，一级一级向上排序

解题步骤

1. 快慢指针找链表中点
2. 递归拆分
3. 返回合并的结果

以上三部递归进行

class Solution {
    public ListNode sortList(ListNode head) {
        return head == null ? null : mergeSort(head);
    }
    private ListNode mergeSort(ListNode head){ //递归拆分
        if(head.next == null) return head;
        //快慢指针找中点
        ListNode slow = head;
        ListNode fast = head.next;
        while(fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        ListNode tmp = slow.next;
        slow.next = null;//断链
        ListNode left = mergeSort(head);
        ListNode right = mergeSort(tmp);
        return merge(left,right);
    }
    private ListNode merge(ListNode left,ListNode right){
        ListNode dummyHead = new ListNode(0);
        ListNode cur = dummyHead;
        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 dummyHead.next;
    }
}

146 LRU 缓存

设计思想：通过一个Map映射和双向链表实现，队头为活跃的元素（新插入的、刚使用的），队尾为最近最久未使用的元素。

1. 当插入一个元素，就放在队头，并判断队列容量，进入步骤三。
2. 当取出一个元素，更新队头
3. 如果容量大于阈值，删除队尾元素。

设计到的知识点：LRU的原理、双向链表、虚拟头尾节点的使用、HashMap

class LRUCache {
    /*
        LRU:最近最少使用
        键值对
        要记最近插入时间 、更新时间、使用的时间
        通过维护一个双向链表实现
        链表头部为最近插入或者使用的元素
        链表尾部为最近最久未使用的元素，当链表的size大于capacity时则淘汰该元素
     */
    class LRULinkList{
        int k;
        int v;
        LRULinkList prev;
        LRULinkList next;
        LRULinkList(){};
        LRULinkList(int key,int value){
            this.k =key;
            this.v = value;
        }
    }
    private int capacity = 0;
    private HashMap<Integer,LRULinkList> map = null;
    LRULinkList dummyHead = null;
    LRULinkList dummyTail = null;
    public LRUCache(int capacity) {//构造函数
        this.capacity = capacity;
        dummyHead = new LRULinkList();
        dummyTail = new LRULinkList();       //虚拟头尾节点 
        dummyHead.next = dummyTail;
        dummyTail.prev = dummyHead;
        map = new HashMap<>();
    }
    
    public int get(int key) {
        //从map中找key，如果无返回-1；
        LRULinkList node = map.get(key);
        if(node != null){//如果有，执行moveToHead，
            moveToHead(node);
        }else{
            return -1;
        }
        return node.v;
    }
    
    public void put(int key, int value) {
        //先判断链表中是否有这个元素
        LRULinkList node = map.get(key);
        if(node == null){
            //如果链表中没有这个元素则创建一个元素
            LRULinkList newNode = new LRULinkList(key,value);
            addHead(newNode);
            map.put(key,newNode);
            if(map.size() > capacity){
                //如果容量超过了cap，移除队尾元素,移除map中的记录
                LRULinkList remove = removeTail();
                map.remove(remove.k);
            }
        }else{
            //如果有，更新链表中的元素
            node.v =  value;
            moveToHead(node);
            
        }
    }

    public void moveToHead(LRULinkList node){
        removeNode(node);
        addHead(node);
    }
    public void addHead(LRULinkList node){
        node.prev = dummyHead;
        node.next = dummyHead.next;
        dummyHead.next.prev = node;
        dummyHead.next = node;
    }

    public void removeNode(LRULinkList node){
        node.next.prev = node.prev;
        node.prev.next = node.next;
    }

    public LRULinkList removeTail(){
        LRULinkList remove =  dummyTail.prev;
        removeNode(remove);
        return remove;
    }
}

小结

经过一周的训练，发现解链表的题目时，要对指针特别敏感，啥时候回断链，以及一些为null的情况，心理都要清楚。还有就是逻辑思维能力，如果考虑不出来的题，不妨在纸上画一画，说不定就理清楚了，尤其是链表的题目。