Leetcode算法题-链表

2. 两数相加

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

力扣

public ListNode removeNthFromEnd(ListNode head, int n) {
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    int length  = 0;
    ListNode first = head;
    while (first != null) {
        length++;
        first = first.next;
    }
    length -= n;
    first = dummy;
    while (length > 0) {
        length--;
        first = first.next;
    }
    first.next = first.next.next;
    return dummy.next;
}

23. 合并K个升序链表

力扣

public ListNode mergeKLists(ListNode[] lists) {
        if (lists == null || lists.length == 0) return null;
        ListNode res = new ListNode(0), curr = res;
        PriorityQueue<ListNode> queue = new PriorityQueue<>(new Comparator<ListNode>() {
            @Override
            public int compare(ListNode o1, ListNode o2) {
                return o1.val - o2.val;
            }
        });
        
        for (ListNode list : lists) {
            if (list == null) continue;
            queue.offer(list);
        }
        while (!queue.isEmpty()) {
            ListNode nextNode = queue.poll();
            curr.next = nextNode;
            curr = curr.next;
            if (nextNode.next != null) {
                queue.offer(nextNode.next);
            }
        }
        return res.next;
    }

25. K个一组翻转链表

力扣

public ListNode reverseKGroup(ListNode head, int k) {
        ListNode hair = new ListNode(0);
        hair.next = head;
        ListNode prev = hair;
        while (head != null) {
            ListNode tail = prev;
            //移动tail
            for (int i = 0; i < k; i++) {
                tail = tail.next;
                if (tail == null) return hair.next;
            }
            ListNode next = tail.next;
            ListNode[] reverse = reverse(head,tail);
            head = reverse[0];
            tail = reverse[1];
            prev.next = head;
            tail.next = next;
            prev = tail;
            head = next;
        }
        return hair.next;
    }
    
    public ListNode[] reverse(ListNode head, ListNode tail) {
        ListNode prev = tail.next;
        ListNode p = head;
        while (prev != tail) {
            ListNode next = p.next;
            p.next = prev;
            prev = p;
            p = next;
        }
        return new ListNode[]{tail,head};
    }

61. 旋转链表

力扣

解法:首先遍历链表获取链表的长度n，然后通过n - k % n 就能知道，数组分割的位置
然后获取到该节点，以该节点为界分为两个链表，然后反转链表。
public ListNode rotateRight(ListNode head, int k) {
        if (head == null) return head;
        //统计链表长度
        int size = 1;
        ListNode cur = head, tail = head, prev = null;
        while (tail.next != null) {
            tail = tail.next;
            size++;
        }
        //确定分割位置,若分割为起始位置就不用动
        if (k % size == 0) return head;
        k = size - (k % size);
        while (k > 0) {
            prev = cur;
            cur = cur.next;
            k--;
        }
        tail.next = head;
        prev.next = null;
        return cur;
    }

142. 环形链表II

力扣

public ListNode detectCycle(ListNode head) {
        ListNode slow = head, fast = head, result = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (slow == fast) {
                while (slow != result) {
                    result = result.next;
                    slow = slow.next;
                }
                return result;
            }
        }
        System.out.println("no cycle");
        return null;
}

146. LRU缓存机制

力扣

解法:使用哈希表+双向链表，哈希表用来根据key以O(1)的时间复杂度来定位双向链表中的node节点，get或者更新的元素，移动或加入到双向链表头部。如果超过容量则用尾部移除。
public 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<Integer, DLinkedNode>();
    private int size;
    private int capacity;
    private DLinkedNode head, tail;

    public LRUCache(int capacity) {
        this.size = 0;
        this.capacity = capacity;
        // 使用伪头部和伪尾部节点
        head = new DLinkedNode();
        tail = new DLinkedNode();
        head.next = tail;
        tail.prev = head;
    }

    public int get(int key) {
        DLinkedNode node = cache.get(key);
        if (node == null) {
            return -1;
        }
        // 如果 key 存在，先通过哈希表定位，再移到头部
        moveToHead(node);
        return node.value;
    }

    public void put(int key, int value) {
        DLinkedNode node = cache.get(key);
        if (node == null) {
            // 如果 key 不存在，创建一个新的节点
            DLinkedNode newNode = new DLinkedNode(key, value);
            // 添加进哈希表
            cache.put(key, newNode);
            // 添加至双向链表的头部
            addToHead(newNode);
            ++size;
            if (size > capacity) {
                // 如果超出容量，删除双向链表的尾部节点
                DLinkedNode tail = removeTail();
                // 删除哈希表中对应的项
                cache.remove(tail.key);
                --size;
            }
        }
        else {
            // 如果 key 存在，先通过哈希表定位，再修改 value，并移到头部
            node.value = value;
            moveToHead(node);
        }
    }

    private void addToHead(DLinkedNode node) {
        node.prev = head;
        node.next = head.next;
        head.next.prev = node;
        head.next = node;
    }

    private void removeNode(DLinkedNode node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    private void moveToHead(DLinkedNode node) {
        removeNode(node);
        addToHead(node);
    }

    private DLinkedNode removeTail() {
        DLinkedNode res = tail.prev;
        removeNode(res);
        return res;
    }
}

206. 反转链表

力扣

public ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode curr = head;
        while (curr != null) {
            ListNode temp = curr.next;
            curr.next = prev;
            prev = curr;
            curr = temp;
        }
        return prev;
    }

面试题 02.02. 返回倒数第 k 个节点

力扣

public int kthToLast(ListNode head, int k) {
        ListNode fast = head;
        ListNode slow = head;
        while (k != 0) {
            fast = fast.next;
            k--;
        }
        while (fast != null) {
            fast = fast.next;
            slow = slow.next;
        }
        return slow.val;
    }

面试题 02.03. 删除中间节点

力扣

public void deleteNode(ListNode node) {
        node.val=node.next.val;
        node.next=node.next.next;
    }

面试题 02.04. 分割链表

力扣

public ListNode partition(ListNode head, int x) {
        if (head == null) return head;
        ListNode hair = new ListNode(0), prev = new ListNode(0);
        ListNode left = hair,right = prev;
        while (head != null) {
            if (head.val < x) {
                left.next = head;
                left = head;
            } else {
                right.next = head;
                right = head;
            }
            head = head.next;
        }
        left.next = prev.next;
        right.next = null;
        return hair.next;
    }

面试题 02.05. 链表求和

力扣

public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode p1 = l1, p2 = l2, result = new ListNode(0), cur = result;
        int carry = 0;
        while (p1 != null || p2 != null || carry > 0) {
            int sum = carry;
            sum += p1 == null ? 0 : p1.val;
            sum += p2 == null ? 0 : p2.val;
            carry = sum / 10;
            if (p1 != null) p1 = p1.next;
            if (p2 != null) p2 = p2.next;
            cur.next = new ListNode(sum % 10);
            cur = cur.next;
        }
        return result.next;
    }

面试题 02.06. 回文链表

力扣

public boolean isPalindrome(ListNode head) {
        ListNode prev = new ListNode(0);
        prev.next = head;
        ListNode slow = prev, fast = prev;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        ListNode reverseHead = reverse(slow.next);
        while (reverseHead != null) {
            if (reverseHead.val != head.val) return false;
            reverseHead = reverseHead.next;
            head = head.next;
        }
        return true;
    }
    
    public ListNode reverse(ListNode head) {
        ListNode prev = null;
        while (head != null) {
            ListNode temp = head.next;
            head.next = prev;
            prev = head;
            head = temp;
        }
        return prev;
    }

面试题 02.07. 链表相交

力扣

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode p1 = headA, p2 = headB;
        while (p1 != p2) {
            p1 = p1 != null ? p1.next : headB;
            p2 = p2 != null ? p2.next : headA;
        }
        return p1;
    }

面试题 02.08. 环路检测

力扣

public ListNode detectCycle(ListNode head) {
        ListNode slow = head, fast = head, result = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (slow == fast) {
                while (slow != result) {
                    slow = slow.next;
                    result = result.next;
                }
                return result;
            }
        }
        return null;
    }

剑指offer 18. 删除链表的节点

力扣

双指针
public ListNode deleteNode(ListNode head, int val) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode curr = head;
        ListNode prev = dummy;
        while (curr != null) {
            if (curr.val == val) {
                prev.next = curr.next;
                break;
            }
            prev = curr;
            curr = curr.next;
        }
        return dummy.next;
}

剑指offer 52. 两个链表的第一个公共节点

力扣

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode node1 = headA;
        ListNode node2 = headB;
        while (node1 != node2) {
            node1 = node1 != null ? node1.next : headB;
            node2 = node2 != null ? node2.next : headA;
        }
        return node1;
    }