304 North Cardinal St.
Dorchester Center, MA 02124

# Design Linked List LeetCode Solution

## Problem – Design Linked List

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
[[], [1], [3], [1, 2], [1], [1], [1]]
Output
[null, null, null, null, 2, null, 3]

Explanation
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`.

### Design Linked List LeetCode Solution in Python

``````class Node(object):

def __init__(self, val):
self.val = val
self.next = None

def __init__(self):
"""
Initialize your data structure here.
"""
self.size = 0

def get(self, index):
"""
Get the value of the index-th node in the linked list. If the index is invalid, return -1.
:type index: int
:rtype: int
"""
if index < 0 or index >= self.size:
return -1

if self.head is None:
return -1

for i in range(index):
curr = curr.next
return curr.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.
:type val: int
:rtype: void
"""
node = Node(val)

self.size += 1

"""
Append a node of value val to the last element of the linked list.
:type val: int
:rtype: void
"""
if curr is None:
else:
while curr.next is not None:
curr = curr.next
curr.next = Node(val)

self.size += 1

def addAtIndex(self, index, val):
"""
Add a node of value val before the index-th node in the linked list.
If index equals to the length of linked list, the node will be appended to the end of linked list.
If index is greater than the length, the node will not be inserted.
:type index: int
:type val: int
:rtype: void
"""
if index < 0 or index > self.size:
return

if index == 0:
else:
for i in range(index - 1):
curr = curr.next
node = Node(val)
node.next = curr.next
curr.next = node

self.size += 1

def deleteAtIndex(self, index):
"""
Delete the index-th node in the linked list, if the index is valid.
:type index: int
:rtype: void
"""
if index < 0 or index >= self.size:
return

if index == 0:
else:
for i in range(index - 1):
curr = curr.next
curr.next = curr.next.next

self.size -= 1
``````

### Design Linked List LeetCode Solution in C++

``````class Node {
public:
int val;
Node* next;
Node(int val) {
this->val=val;
next=NULL;
}
};

public:
/** Initialize your data structure here. */
int size=0;

}

/** Get the value of the index-th node in the linked list. If the index is invalid, return -1. */
int get(int index) {
if(index>=size) return -1;
for(int i=0;i<index;i++) temp=temp->next;
return temp->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. */
size++;
}

/** Append a node of value val to the last element of the linked list. */
void addAtTail(int val) {
while(temp->next!=NULL) temp=temp->next;
temp->next=new Node(val);
size++;
}

/** Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted. */
void addAtIndex(int index, int val) {
if(index>size) return;
for(int i=0;i<index;i++) temp=temp->next;
Node* temp1=temp->next;
temp->next=new Node(val);
temp->next->next=temp1;
size++;
}

/** Delete the index-th node in the linked list, if the index is valid. */
void deleteAtIndex(int index) {
if(index>=size) return;
for(int i=0;i<index;i++) temp=temp->next;
Node* temp1=temp->next;
temp->next=temp1->next;
temp1->next=NULL;
size--;
delete temp1;
}
};
``````

### Design Linked List LeetCode Solution in Java

``````class MyLinkedList {

/** Initialize your data structure here. */
int length;
class Node {
int val;
Node next;
Node(int x) {
this.val = x;
}
}

this.length = 0;
}

/** Get the value of the index-th node in the linked list. If the index is invalid, return -1. */
public int get(int index) {
if(index < 0 || index >= this.length) {
return -1;
}
else {
int counter = 0;
Node curr = head;
while(counter != (index)) {
curr = curr.next;
counter++;
}
return curr.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. */
Node newNode = new Node(val);
this.length++;
}

/** Append a node of value val to the last element of the linked list. */
public void addAtTail(int val) {
if(this.length == 0) {
return;
}
Node newNode = new Node(val);
Node temp = head;
while(temp.next != null) {
temp = temp.next;
}
temp.next = newNode;
newNode.next = null;
this.length++;
}

/** Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted. */
public void addAtIndex(int index, int val) {
Node newNode = new Node(val);
Node temp = head;
int counter = 0;
if((index) == this.length) {
return;
}
if(index > this.length) {
return;
}
if(index == 0){
return;
}
while(counter != (index -1)) {
temp = temp.next;
counter++;
}
newNode.next = temp.next;
temp.next = newNode;
this.length++;
}

/** Delete the index-th node in the linked list, if the index is valid. */
public void deleteAtIndex(int index) {

if(index < 0 || index >= this.length) {
return;
}
Node curr = head;
if(index == 0) {
}
else {
Node current = head;
Node pre = null;
int counter =0;
while(counter != index) {
pre = current;
current = current.next;
counter++;
}
pre.next = current.next;
this.length--;
}
}
}
``````
##### Design Linked List LeetCode Solution Review:

In our experience, we suggest you solve this Design Linked List LeetCode Solution and gain some new skills from Professionals completely free and we assure you will be worth it.

If you are stuck anywhere between any coding problem, just visit Queslers to get the Design Linked List LeetCode Solution

Find on LeetCode

##### Conclusion:

I hope this Design Linked List LeetCode Solution would be useful for you to learn something new from this problem. If it helped you then don’t forget to bookmark our site for more Coding Solutions.

This Problem is intended for audiences of all experiences who are interested in learning about Data Science in a business context; there are no prerequisites.

Keep Learning!

More Coding Solutions >>

LeetCode Solutions

Hacker Rank Solutions

CodeChef Solutions