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 index^th 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 index^th 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 index^th 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

This solution uses the doubly linked list.

Quite similar to 146-LRU-Cache, with double-linked-node.

Create a class Node that has data fields int val that is the node’s value, Node prev that is the node’s previous node, and Node next that is the node’s next node.

In class MyLinkedList, there are three data fields, which are Node head that is the first node, Node tail that is the last node, and int size that is the number of nodes in the linked list.

For the constructor, initialize head and tail to null, and size to 0.

For get(index), if index >= size, then return -1. Otherwise, find the index-th node starting from head, and return the node’s value.

For addAtHead(val), create a new node with value val. If size == 0, set both head and tail to be the new node. Otherwise, update the nodes around head and assign the new node to head. Increase size by 1.

For addAtTail(val), create a new node with value val. If size == 0, set both head and tail to be the new node. Otherwise, update the nodes around tail and assign the new node to tail. Increase size by 1.

For addAtIndex(index, val), first check index. If index == 0, then call addAtHead(val). Else, if index == size, then call addAtTail(val). Else, create a new node with value val, find the index-th node starting from head, and insert the new node at position index, with the nodes around the position updated.

For deleteAtIndex(index, val), first check index. If index == 0, then delete the node at head with the nodes around head updated. Else, if index == size - 1, then delete the node at tail with the nodes around tail updated. Else, find the index-th node starting from head, and delete the node, with the nodes around the position updated.

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); */ 

# doubly linked node class ListNode: def __init__(self, value=0, prev=None, next=None): self.value = value self.prev = prev self.next = next class MyLinkedList: def __init__(self): self.head = ListNode(0) # Sentinel node as pseudo-head  self.tail = ListNode(0) # Sentinel node as pseudo-tail  self.head.next = self.tail self.tail.prev = self.head self.size = 0 def get(self, index: int) -> int: if index < 0 or index >= self.size: return -1 if index + 1 < self.size - index: # decide start from head or tail  curr = self.head for _ in range(index + 1): curr = curr.next else: curr = self.tail for _ in range(self.size - index): curr = curr.prev return curr.value def addAtHead(self, val: int) -> None: pred, succ = self.head, self.head.next self.size += 1 to_add = ListNode(val, pred, succ) pred.next = to_add succ.prev = to_add def addAtTail(self, val: int) -> None: succ, pred = self.tail, self.tail.prev self.size += 1 to_add = ListNode(val, pred, succ) pred.next = to_add succ.prev = to_add def addAtIndex(self, index: int, val: int) -> None: if index > self.size: return if index < 0: index = 0 if index < self.size - index: # decide start from head or tail  pred = self.head for _ in range(index): pred = pred.next succ = pred.next else: succ = self.tail for _ in range(self.size - index): succ = succ.prev pred = succ.prev self.size += 1 to_add = ListNode(val, pred, succ) pred.next = to_add succ.prev = to_add def deleteAtIndex(self, index: int) -> None: if index < 0 or index >= self.size: return if index < self.size - index: pred = self.head for _ in range(index): pred = pred.next succ = pred.next.next else: succ = self.tail for _ in range(self.size - index - 1): succ = succ.prev pred = succ.prev.prev self.size -= 1 pred.next = succ succ.prev = pred # 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)  #######################  # singly linked node 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) # insert in-between  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 # don't forget to cutoff  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)  

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); */ 

707 - Design Linked List

707. Design Linked List

Description

Solutions

All Problems

All Solutions

Welcome to Subscribe On Youtube

707. Design Linked List

Description

Solutions

All Problems

All Solutions