Question

707. Design Linked List

中文文档

Description

Design your implementation of the linked list. You can choose to use a singly or doubly linked list.
A node in a singly linked list should have two attributes: val and next. val is the value of the current node, and next is a pointer/reference to the next node.
If you want to use the doubly linked list, you will need one more attribute prev to indicate the previous node in the linked list. Assume all nodes in the linked list are 0-indexed.

Implement the MyLinkedList class:

• MyLinkedList() Initializes the MyLinkedList object.
• int get(int index) Get the value of the indexth node in the linked list. If the index is invalid, return -1.
• void addAtHead(int val) Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list.
• void addAtTail(int val) Append a node of value val as the last element of the linked list.
• void addAtIndex(int index, int val) Add a node of value val before the indexth node in the linked list. If index equals the length of the linked list, the node will be appended to the end of the linked list. If index is greater than the length, the node will not be inserted.
• void deleteAtIndex(int index) Delete the indexth node in the linked list, if the index is valid.

 

Example 1:

Input
["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
[[], [1], [3], [1, 2], [1], [1], [1]]
Output
[null, null, null, null, 2, null, 3]

Explanation
MyLinkedList myLinkedList = new MyLinkedList();
myLinkedList.addAtHead(1);
myLinkedList.addAtTail(3);
myLinkedList.addAtIndex(1, 2);  // linked list becomes 1->2->3
myLinkedList.get(1);        // return 2
myLinkedList.deleteAtIndex(1);  // now the linked list is 1->3
myLinkedList.get(1);        // return 3

 

Constraints:

• 0 <= index, val <= 1000
• Please do not use the built-in LinkedList library.
• At most 2000 calls will be made to get, addAtHead, addAtTail, addAtIndex and deleteAtIndex.

Solutions

Solution 1

class MyLinkedList:
  def __init__(self):
    self.dummy = ListNode()
    self.cnt = 0

  def get(self, index: int) -> int:
    if index < 0 or index >= self.cnt:
      return -1
    cur = self.dummy.next
    for _ in range(index):
      cur = cur.next
    return cur.val

  def addAtHead(self, val: int) -> None:
    self.addAtIndex(0, val)

  def addAtTail(self, val: int) -> None:
    self.addAtIndex(self.cnt, val)

  def addAtIndex(self, index: int, val: int) -> None:
    if index > self.cnt:
      return
    pre = self.dummy
    for _ in range(index):
      pre = pre.next
    pre.next = ListNode(val, pre.next)
    self.cnt += 1

  def deleteAtIndex(self, index: int) -> None:
    if index >= self.cnt:
      return
    pre = self.dummy
    for _ in range(index):
      pre = pre.next
    t = pre.next
    pre.next = t.next
    t.next = None
    self.cnt -= 1


# Your MyLinkedList object will be instantiated and called as such:
# obj = MyLinkedList()
# param_1 = obj.get(index)
# obj.addAtHead(val)
# obj.addAtTail(val)
# obj.addAtIndex(index,val)
# obj.deleteAtIndex(index)

class MyLinkedList {
  private ListNode dummy = new ListNode();
  private int cnt;

  public MyLinkedList() {
  }

  public int get(int index) {
    if (index < 0 || index >= cnt) {
      return -1;
    }
    var cur = dummy.next;
    while (index-- > 0) {
      cur = cur.next;
    }
    return cur.val;
  }

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

  public void addAtTail(int val) {
    addAtIndex(cnt, val);
  }

  public void addAtIndex(int index, int val) {
    if (index > cnt) {
      return;
    }
    var pre = dummy;
    while (index-- > 0) {
      pre = pre.next;
    }
    pre.next = new ListNode(val, pre.next);
    ++cnt;
  }

  public void deleteAtIndex(int index) {
    if (index < 0 || index >= cnt) {
      return;
    }
    var pre = dummy;
    while (index-- > 0) {
      pre = pre.next;
    }
    var t = pre.next;
    pre.next = t.next;
    t.next = null;
    --cnt;
  }
}

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList obj = new MyLinkedList();
 * int param_1 = obj.get(index);
 * obj.addAtHead(val);
 * obj.addAtTail(val);
 * obj.addAtIndex(index,val);
 * obj.deleteAtIndex(index);
 */

class MyLinkedList {
private:
  ListNode* dummy = new ListNode();
  int cnt = 0;

public:
  MyLinkedList() {
  }

  int get(int index) {
    if (index < 0 || index >= cnt) {
      return -1;
    }
    auto cur = dummy->next;
    while (index--) {
      cur = cur->next;
    }
    return cur->val;
  }

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

  void addAtTail(int val) {
    addAtIndex(cnt, val);
  }

  void addAtIndex(int index, int val) {
    if (index > cnt) {
      return;
    }
    auto pre = dummy;
    while (index-- > 0) {
      pre = pre->next;
    }
    pre->next = new ListNode(val, pre->next);
    ++cnt;
  }

  void deleteAtIndex(int index) {
    if (index >= cnt) {
      return;
    }
    auto pre = dummy;
    while (index-- > 0) {
      pre = pre->next;
    }
    auto t = pre->next;
    pre->next = t->next;
    t->next = nullptr;
    --cnt;
  }
};

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList* obj = new MyLinkedList();
 * int param_1 = obj->get(index);
 * obj->addAtHead(val);
 * obj->addAtTail(val);
 * obj->addAtIndex(index,val);
 * obj->deleteAtIndex(index);
 */

type MyLinkedList struct {
  dummy *ListNode
  cnt   int
}

func Constructor() MyLinkedList {
  return MyLinkedList{&ListNode{}, 0}
}

func (this *MyLinkedList) Get(index int) int {
  if index < 0 || index >= this.cnt {
    return -1
  }
  cur := this.dummy.Next
  for ; index > 0; index-- {
    cur = cur.Next
  }
  return cur.Val
}

func (this *MyLinkedList) AddAtHead(val int) {
  this.AddAtIndex(0, val)
}

func (this *MyLinkedList) AddAtTail(val int) {
  this.AddAtIndex(this.cnt, val)
}

func (this *MyLinkedList) AddAtIndex(index int, val int) {
  if index > this.cnt {
    return
  }
  pre := this.dummy
  for ; index > 0; index-- {
    pre = pre.Next
  }
  pre.Next = &ListNode{val, pre.Next}
  this.cnt++
}

func (this *MyLinkedList) DeleteAtIndex(index int) {
  if index < 0 || index >= this.cnt {
    return
  }
  pre := this.dummy
  for ; index > 0; index-- {
    pre = pre.Next
  }
  t := pre.Next
  pre.Next = t.Next
  t.Next = nil
  this.cnt--
}

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * obj := Constructor();
 * param_1 := obj.Get(index);
 * obj.AddAtHead(val);
 * obj.AddAtTail(val);
 * obj.AddAtIndex(index,val);
 * obj.DeleteAtIndex(index);
 */

class LinkNode {
  public val: number;
  public next: LinkNode;

  constructor(val: number, next: LinkNode = null) {
    this.val = val;
    this.next = next;
  }
}

class MyLinkedList {
  public head: LinkNode;

  constructor() {
    this.head = null;
  }

  get(index: number): number {
    if (this.head == null) {
      return -1;
    }
    let cur = this.head;
    let idxCur = 0;
    while (idxCur < index) {
      if (cur.next == null) {
        return -1;
      }
      cur = cur.next;
      idxCur++;
    }
    return cur.val;
  }

  addAtHead(val: number): void {
    this.head = new LinkNode(val, this.head);
  }

  addAtTail(val: number): void {
    const newNode = new LinkNode(val);
    if (this.head == null) {
      this.head = newNode;
      return;
    }
    let cur = this.head;
    while (cur.next != null) {
      cur = cur.next;
    }
    cur.next = newNode;
  }

  addAtIndex(index: number, val: number): void {
    if (index <= 0) {
      return this.addAtHead(val);
    }
    const dummy = new LinkNode(0, this.head);
    let cur = dummy;
    let idxCur = 0;
    while (idxCur < index) {
      if (cur.next == null) {
        return;
      }
      cur = cur.next;
      idxCur++;
    }
    cur.next = new LinkNode(val, cur.next || null);
  }

  deleteAtIndex(index: number): void {
    if (index == 0) {
      this.head = (this.head || {}).next;
      return;
    }
    const dummy = new LinkNode(0, this.head);
    let cur = dummy;
    let idxCur = 0;
    while (idxCur < index) {
      if (cur.next == null) {
        return;
      }
      cur = cur.next;
      idxCur++;
    }
    cur.next = (cur.next || {}).next;
  }
}

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * var obj = new MyLinkedList()
 * var param_1 = obj.get(index)
 * obj.addAtHead(val)
 * obj.addAtTail(val)
 * obj.addAtIndex(index,val)
 * obj.deleteAtIndex(index)
 */

#[derive(Default)]
struct MyLinkedList {
  head: Option<Box<ListNode>>,
}

/**
 * `&self` means the method takes an immutable reference.
 * If you need a mutable reference, change it to `&mut self` instead.
 */
impl MyLinkedList {
  fn new() -> Self {
    Default::default()
  }

  fn get(&self, mut index: i32) -> i32 {
    if self.head.is_none() {
      return -1;
    }
    let mut cur = self.head.as_ref().unwrap();
    while index > 0 {
      match cur.next {
        None => {
          return -1;
        }
        Some(ref next) => {
          cur = next;
          index -= 1;
        }
      }
    }
    cur.val
  }

  fn add_at_head(&mut self, val: i32) {
    self.head = Some(
      Box::new(ListNode {
        val,
        next: self.head.take(),
      })
    );
  }

  fn add_at_tail(&mut self, val: i32) {
    let new_node = Some(Box::new(ListNode { val, next: None }));
    if self.head.is_none() {
      self.head = new_node;
      return;
    }
    let mut cur = self.head.as_mut().unwrap();
    while let Some(ref mut next) = cur.next {
      cur = next;
    }
    cur.next = new_node;
  }

  fn add_at_index(&mut self, mut index: i32, val: i32) {
    let mut dummy = Box::new(ListNode {
      val: 0,
      next: self.head.take(),
    });
    let mut cur = &mut dummy;
    while index > 0 {
      if cur.next.is_none() {
        return;
      }
      cur = cur.next.as_mut().unwrap();
      index -= 1;
    }
    cur.next = Some(
      Box::new(ListNode {
        val,
        next: cur.next.take(),
      })
    );
    self.head = dummy.next;
  }

  fn delete_at_index(&mut self, mut index: i32) {
    let mut dummy = Box::new(ListNode {
      val: 0,
      next: self.head.take(),
    });
    let mut cur = &mut dummy;
    while index > 0 {
      if let Some(ref mut next) = cur.next {
        cur = next;
      }
      index -= 1;
    }
    cur.next = cur.next.take().and_then(|n| n.next);
    self.head = dummy.next;
  }
}/**
 * Your MyLinkedList object will be instantiated and called as such:
 * let obj = MyLinkedList::new();
 * let ret_1: i32 = obj.get(index);
 * obj.add_at_head(val);
 * obj.add_at_tail(val);
 * obj.add_at_index(index, val);
 * obj.delete_at_index(index);
 */

Solution 2

class MyLinkedList:
  def __init__(self):
    self.e = [0] * 1010
    self.ne = [0] * 1010
    self.idx = 0
    self.head = -1
    self.cnt = 0

  def get(self, index: int) -> int:
    if index < 0 or index >= self.cnt:
      return -1
    i = self.head
    for _ in range(index):
      i = self.ne[i]
    return self.e[i]

  def addAtHead(self, val: int) -> None:
    self.e[self.idx] = val
    self.ne[self.idx] = self.head
    self.head = self.idx
    self.idx += 1
    self.cnt += 1

  def addAtTail(self, val: int) -> None:
    self.addAtIndex(self.cnt, val)

  def addAtIndex(self, index: int, val: int) -> None:
    if index > self.cnt:
      return
    if index <= 0:
      self.addAtHead(val)
      return
    i = self.head
    for _ in range(index - 1):
      i = self.ne[i]
    self.e[self.idx] = val
    self.ne[self.idx] = self.ne[i]
    self.ne[i] = self.idx
    self.idx += 1
    self.cnt += 1

  def deleteAtIndex(self, index: int) -> None:
    if index < 0 or index >= self.cnt:
      return -1
    self.cnt -= 1
    if index == 0:
      self.head = self.ne[self.head]
      return
    i = self.head
    for _ in range(index - 1):
      i = self.ne[i]
    self.ne[i] = self.ne[self.ne[i]]


# Your MyLinkedList object will be instantiated and called as such:
# obj = MyLinkedList()
# param_1 = obj.get(index)
# obj.addAtHead(val)
# obj.addAtTail(val)
# obj.addAtIndex(index,val)
# obj.deleteAtIndex(index)

class MyLinkedList {
  private int[] e = new int[1010];
  private int[] ne = new int[1010];
  private int head = -1;
  private int idx;
  private int cnt;

  public MyLinkedList() {
  }

  public int get(int index) {
    if (index < 0 || index >= cnt) {
      return -1;
    }
    int i = head;
    while (index-- > 0) {
      i = ne[i];
    }
    return e[i];
  }

  public void addAtHead(int val) {
    e[idx] = val;
    ne[idx] = head;
    head = idx++;
    ++cnt;
  }

  public void addAtTail(int val) {
    addAtIndex(cnt, val);
  }

  public void addAtIndex(int index, int val) {
    if (index > cnt) {
      return;
    }
    if (index <= 0) {
      addAtHead(val);
      return;
    }
    int i = head;
    while (--index > 0) {
      i = ne[i];
    }
    e[idx] = val;
    ne[idx] = ne[i];
    ne[i] = idx++;
    ++cnt;
  }

  public void deleteAtIndex(int index) {
    if (index < 0 || index >= cnt) {
      return;
    }
    --cnt;
    if (index == 0) {
      head = ne[head];
      return;
    }
    int i = head;
    while (--index > 0) {
      i = ne[i];
    }
    ne[i] = ne[ne[i]];
  }
}

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList obj = new MyLinkedList();
 * int param_1 = obj.get(index);
 * obj.addAtHead(val);
 * obj.addAtTail(val);
 * obj.addAtIndex(index,val);
 * obj.deleteAtIndex(index);
 */

class MyLinkedList {
private:
  int e[1010], ne[1010];
  int head = -1, idx = 0, cnt = 0;

public:
  MyLinkedList() {
  }

  int get(int index) {
    if (index < 0 || index >= cnt) {
      return -1;
    }
    int i = head;
    while (index--) {
      i = ne[i];
    }
    return e[i];
  }

  void addAtHead(int val) {
    e[idx] = val;
    ne[idx] = head;
    head = idx++;
    ++cnt;
  }

  void addAtTail(int val) {
    addAtIndex(cnt, val);
  }

  void addAtIndex(int index, int val) {
    if (index > cnt) {
      return;
    }
    if (index <= 0) {
      addAtHead(val);
      return;
    }
    int i = head;
    while (--index) {
      i = ne[i];
    }
    e[idx] = val;
    ne[idx] = ne[i];
    ne[i] = idx++;
    ++cnt;
  }

  void deleteAtIndex(int index) {
    if (index < 0 || index >= cnt) {
      return;
    }
    --cnt;
    if (index == 0) {
      head = ne[head];
      return;
    }
    int i = head;
    while (--index) {
      i = ne[i];
    }
    ne[i] = ne[ne[i]];
  }
};

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList* obj = new MyLinkedList();
 * int param_1 = obj->get(index);
 * obj->addAtHead(val);
 * obj->addAtTail(val);
 * obj->addAtIndex(index,val);
 * obj->deleteAtIndex(index);
 */

type MyLinkedList struct {
  e  []int
  ne   []int
  idx  int
  head int
  cnt  int
}

func Constructor() MyLinkedList {
  e := make([]int, 1010)
  ne := make([]int, 1010)
  return MyLinkedList{e, ne, 0, -1, 0}
}

func (this *MyLinkedList) Get(index int) int {
  if index < 0 || index >= this.cnt {
    return -1
  }
  i := this.head
  for ; index > 0; index-- {
    i = this.ne[i]
  }
  return this.e[i]
}

func (this *MyLinkedList) AddAtHead(val int) {
  this.e[this.idx] = val
  this.ne[this.idx] = this.head
  this.head = this.idx
  this.idx++
  this.cnt++
}

func (this *MyLinkedList) AddAtTail(val int) {
  this.AddAtIndex(this.cnt, val)
}

func (this *MyLinkedList) AddAtIndex(index int, val int) {
  if index > this.cnt {
    return
  }
  if index <= 0 {
    this.AddAtHead(val)
    return
  }
  i := this.head
  for ; index > 1; index-- {
    i = this.ne[i]
  }
  this.e[this.idx] = val
  this.ne[this.idx] = this.ne[i]
  this.ne[i] = this.idx
  this.idx++
  this.cnt++
}

func (this *MyLinkedList) DeleteAtIndex(index int) {
  if index < 0 || index >= this.cnt {
    return
  }
  this.cnt--
  if index == 0 {
    this.head = this.ne[this.head]
    return
  }
  i := this.head
  for ; index > 1; index-- {
    i = this.ne[i]
  }
  this.ne[i] = this.ne[this.ne[i]]
}

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * obj := Constructor();
 * param_1 := obj.Get(index);
 * obj.AddAtHead(val);
 * obj.AddAtTail(val);
 * obj.AddAtIndex(index,val);
 * obj.DeleteAtIndex(index);
 */

class MyLinkedList {
  e: Array<number>;
  ne: Array<number>;
  idx: number;
  head: number;
  cnt: number;

  constructor() {
    this.e = new Array(1010).fill(0);
    this.ne = new Array(1010).fill(0);
    this.head = -1;
    this.idx = 0;
    this.cnt = 0;
  }

  get(index: number): number {
    if (index < 0 || index >= this.cnt) {
      return -1;
    }
    let i = this.head;
    while (index--) {
      i = this.ne[i];
    }
    return this.e[i];
  }

  addAtHead(val: number): void {
    this.e[this.idx] = val;
    this.ne[this.idx] = this.head;
    this.head = this.idx++;
    this.cnt++;
  }

  addAtTail(val: number): void {
    this.addAtIndex(this.cnt, val);
  }

  addAtIndex(index: number, val: number): void {
    if (index > this.cnt) {
      return;
    }
    if (index <= 0) {
      this.addAtHead(val);
      return;
    }
    let i = this.head;
    while (--index) {
      i = this.ne[i];
    }
    this.e[this.idx] = val;
    this.ne[this.idx] = this.ne[i];
    this.ne[i] = this.idx++;
    this.cnt++;
  }

  deleteAtIndex(index: number): void {
    if (index < 0 || index >= this.cnt) {
      return;
    }
    this.cnt--;
    if (index == 0) {
      this.head = this.ne[this.head];
      return;
    }
    let i = this.head;
    while (--index) {
      i = this.ne[i];
    }
    this.ne[i] = this.ne[this.ne[i]];
  }
}

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * var obj = new MyLinkedList()
 * var param_1 = obj.get(index)
 * obj.addAtHead(val)
 * obj.addAtTail(val)
 * obj.addAtIndex(index,val)
 * obj.deleteAtIndex(index)
 */