1.题目描述

707. 设计链表

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：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 个节点。

示例：

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

2.解题思路与代码

2.1 解题思路

手写双向链表，自定义一个 ListNode 类定义链表中的节点。ListNode 中定义了节点的值 val，由于是双向链表因此还需要定义该节点的前一个节点 prev 和后续节点 next。

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

  ListNode(int val) {
    this.val = val;
  }
}

定义好节点类后，便开始完成我们的链表类 MyLinkedList，因为需要插入头和尾节点，因此在 MyLinkedList 类中定义当前链表的头 head 和尾 tail，并且使用 size 统计当前链表的节点个数。为了便于插入和删除操作，我们在初始化链表时定义虚拟头节点和虚拟尾节点，并连接两个节点。

public MyLinkedList() {
  head = new ListNode(-1);
  tail = new ListNode(-1);

  head.next = tail;
  tail.prev = head;
}

get(int index) 方法我们从 head 的 next 节点开始依次遍历链表，直到遍历到 index 个时，返回节点值即可。在遍历之前我们需要判断 index 是否小于 size，如果小于 size 直接返回，不再遍历。

public int get(int index) {
  if (index >= size) {
    return -1;
  }
  ListNode curr = head.next;
  for (int i = 0; i < index; i++) {
    curr = curr.next;
  }
  return curr.val;
}

addAtHead(int val) 方法直接在 head 和 head.next 之间添加值为 val 的新节点即可；同理 addAtTail(int val) 直接在 tail 和 tail.prev 之间添加值为 val 的新节点即可。

public void addAtHead(int val) {
  ListNode listNode = new ListNode(val);
  ListNode next = head.next;
  head.next = listNode;
  listNode.next = next;

  next.prev = listNode;
  listNode.prev = head;
  size++;
}

public void addAtTail(int val) {
  ListNode prev = tail.prev;
  ListNode listNode = new ListNode(val);
  prev.next = listNode;
  listNode.next = tail;
  tail.prev = listNode;
  listNode.prev = prev;
  size++;
}

addAtIndex(int index, int val) 方法需要在指定的位置出添加值为 val 的新节点，如果 index 大于 size，即超过链表范围，则不添加直接返回。index 如果小于 size，我们就从头节点 head 开始往后遍历 index 个，由于 head 是虚拟头节点，因此此时需要将新节点插入到 curr 和 curr.next 之间。

public void addAtIndex(int index, int val) {
  if (index > size) {
    return;
  }
  ListNode curr = head;
  for (int i = 0; i < index; i++) {
    curr = curr.next;
  }
  ListNode next = curr.next;
  ListNode listNode = new ListNode(val);
  curr.next = listNode;
  listNode.next = next;
  next.prev = listNode;
  listNode.prev = curr;
  size++;
}

deleteAtIndex(int index) 方法需要删除 index 位置的节点，同理如果 index 大于等于 size 超过链表范围，则直接返回不删除。如果小于 size，首先还是从 head 开始往后遍历 index 次，由于 head 是虚拟头节点，此时我们只需要删除 curr.next 这一个节点。

public void deleteAtIndex(int index) {
  if (index >= size) {
    return;
  }
  ListNode curr = head;
  for (int i = 0; i < index; i++) {
    curr = curr.next;
  }
  ListNode next = curr.next.next;
  curr.next = next;
  next.prev = curr;
  size--;
}

2.2 代码

class MyLinkedList {

    MyLinkedList.ListNode head;
    MyLinkedList.ListNode tail;
    int size = 0;

    public MyLinkedList() {
        head = new MyLinkedList.ListNode(-1);
        tail = new MyLinkedList.ListNode(-1);

        head.next = tail;
        tail.prev = head;
    }

    public int get(int index) {
        if (index >= size) {
            return -1;
        }
        MyLinkedList.ListNode curr = head.next;
        for (int i = 0; i < index; i++) {
            curr = curr.next;
        }
        return curr.val;
    }

    public void addAtHead(int val) {
        MyLinkedList.ListNode listNode = new MyLinkedList.ListNode(val);
        MyLinkedList.ListNode next = head.next;
        head.next = listNode;
        listNode.next = next;

        next.prev = listNode;
        listNode.prev = head;
        size++;
    }

    public void addAtTail(int val) {
        MyLinkedList.ListNode prev = tail.prev;
        MyLinkedList.ListNode listNode = new MyLinkedList.ListNode(val);
        prev.next = listNode;
        listNode.next = tail;
        tail.prev = listNode;
        listNode.prev = prev;
        size++;
    }

    public void addAtIndex(int index, int val) {
        if (index > size) {
            return;
        }
        MyLinkedList.ListNode curr = head;
        for (int i = 0; i < index; i++) {
            curr = curr.next;
        }
        MyLinkedList.ListNode next = curr.next;
        MyLinkedList.ListNode listNode = new MyLinkedList.ListNode(val);
        curr.next = listNode;
        listNode.next = next;
        next.prev = listNode;
        listNode.prev = curr;
        size++;
    }

    public void deleteAtIndex(int index) {
        if (index >= size) {
            return;
        }
        MyLinkedList.ListNode curr = head;
        for (int i = 0; i < index; i++) {
            curr = curr.next;
        }
        MyLinkedList.ListNode next = curr.next.next;
        curr.next = next;
        next.prev = curr;
        size--;
    }

    static class ListNode {
        int val;
        MyLinkedList.ListNode prev;
        MyLinkedList.ListNode next;

        ListNode(int val) {
            this.val = val;
        }
    }
}

2.3 测试结果

通过测试

3.总结

手写一个双向链表
在增加和删除时需要注意链表大小和 index 的关系

LeetCode 每日一题——707. 设计链表