题目描述

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。

在链表类中实现这些功能：

  • get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回 -1。
  • addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
  • addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
  • addAtIndex(index, val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果 index 小于 0，则在头部插入节点。
  • deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

示例：

1
2
3
4
5
6
7
MyLinkedList linkedList = new MyLinkedList();
linkedList.addAtHead(1);
linkedList.addAtTail(3);
linkedList.addAtIndex(1,2);   //链表变为1-> 2-> 3
linkedList.get(1);            //返回2
linkedList.deleteAtIndex(1);  //现在链表是1-> 3
linkedList.get(1);            //返回3

提示：

  • 所有 val 值都在 [1, 1000] 之内。
  • 操作次数将在 [1, 1000] 之内。
  • 请不要使用内置的 LinkedList 库。

来源：力扣（LeetCode）

题解

双向链表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
class MyLinkedList {
    private int size;

    private ListNode first;

    private ListNode last;

    public MyLinkedList() {
        this.size = 0;
        // 哨兵, 可以省去头尾为空的判断
        this.first = new ListNode(0);
        this.last = new ListNode(0);
        this.first.next = this.last;
        this.last.prev = this.first;
    }

    public int get(int index) {
        if (index < 0 || index >= size) return -1;
        return this.getListNodeByIndex(index).val;
    }

    public void addAtHead(int val) {
        this.addAtIndex(0, val);
    }

    public void addAtTail(int val) {
        this.addAtIndex(this.size, val);
    }

    public void addAtIndex(int index, int val) {
        if (index > this.size) return;
        if (index < 0) index = 0;
        ListNode next = this.getListNodeByIndex(index);
        ListNode prev = next.prev;
        ListNode current = new ListNode(val);
        // 因为哨兵的存在, 不需要判断 prev 以及 next 为空的情况
        prev.next = current;
        current.prev = prev;
        current.next = next;
        next.prev = current;
        this.size++;
    }

    public void deleteAtIndex(int index) {
        // 不要忘记判断 index 为负数的情况
        if (index < 0 || index >= this.size) return;
        ListNode current = this.getListNodeByIndex(index);
        ListNode prev = current.prev;
        ListNode next = current.next;
        prev.next = next;
        next.prev = prev;
        this.size--;
    }

    private ListNode getListNodeByIndex(int index) {
        ListNode temp;
        // 判断 index 靠近链表的头部还是尾部
        if (index < (size >> 1)) {
            // 从头部开始查找
            temp = this.first;
            for (int i = 0; i <= index; i++) {
                temp = temp.next;
            }
        } else {
            // 从尾部开始查找
            temp = this.last;
            for (int i = 0; i <= size - (index + 1); i++) {
                temp = temp.prev;
            }
        }
        return temp;
    }

    class ListNode {
        private int val;
        private ListNode prev;
        private ListNode next;

        public ListNode(int val) {
            this.val = val;
        }
    }
}
  • 时间复杂度：初始化消耗 *O(1)*，get 消耗 *O(index)*，addAtHead 消耗 *O(1)*，addAtTail 消耗 *O(1)*，addAtIndex 消耗 *O(index)*。
  • 空间复杂度：所有函数单次调用的空间复杂度均为 *O(1)*，总体空间复杂度为 *O(n)*，其中 n 为 addAtHead，addAtTail 和 addAtIndex 调用次数之和。

submissions-2022092301

参考资料

__END__