Sponsored
Sponsored
In this approach, you will design a singly linked list where each node has a value and a pointer to the next node. This type of list is simple and efficient for certain operations, especially when traversing only forwards is sufficient.
Time Complexity:
- get
: O(n)
- addAtHead
: O(1)
- addAtTail
: O(n)
- addAtIndex
: O(n)
- deleteAtIndex
: O(n)
Space Complexity: O(n), where n is the number of nodes in the list.
1class MyLinkedList {
2 class Node {
3 int val;
4 Node next;
5 Node(int val) { this.val = val; }
6 }
7
8 private Node head;
9
10 public MyLinkedList() {
11 head = null;
12 }
13
14 public int get(int index) {
15 Node current = head;
16 for (int i = 0; current != null && i < index; i++) {
17 current = current.next;
18 }
19 return current == null ? -1 : current.val;
20 }
21
22 public void addAtHead(int val) {
23 Node node = new Node(val);
24 node.next = head;
25 head = node;
26 }
27
28 public void addAtTail(int val) {
29 Node node = new Node(val);
30 if (head == null) {
31 head = node;
32 return;
33 }
34 Node current = head;
35 while (current.next != null) {
36 current = current.next;
37 }
38 current.next = node;
39 }
40
41 public void addAtIndex(int index, int val) {
42 if (index == 0) {
43 addAtHead(val);
44 return;
45 }
46 Node current = head;
47 for (int i = 0; current != null && i < index - 1; i++) {
48 current = current.next;
49 }
50 if (current == null) return;
51 Node node = new Node(val);
52 node.next = current.next;
53 current.next = node;
54 }
55
56 public void deleteAtIndex(int index) {
57 if (index == 0 && head != null) {
58 head = head.next;
59 return;
60 }
61 Node current = head;
62 for (int i = 0; current != null && i < index - 1; i++) {
63 current = current.next;
64 }
65 if (current != null && current.next != null) {
66 current.next = current.next.next;
67 }
68 }
69}
The Java solution creates a simple singly linked list using inner classes for the nodes. The main methods support adding nodes to the head, the tail, and at specific indices while maintaining links consistently.
This approach designs a doubly linked list, allowing traversal both forwards and backwards. Each node maintains a reference to both the next and previous node, facilitating operations such as adding or removing nodes from either end more efficiently.
Time Complexity:
- get
: O(n)
- addAtHead
: O(1)
- addAtTail
: O(n)
- addAtIndex
: O(n)
- deleteAtIndex
: O(n)
Space Complexity: O(n), where n is the number of nodes in the list.
1
private class Node {
public int val;
public Node next;
public Node prev;
public Node(int _val) { val = _val; }
}
private Node head;
public MyLinkedList() {
head = null;
}
public int Get(int index) {
Node current = head;
for (int i = 0; i < index && current != null; i++) {
current = current.next;
}
return current == null ? -1 : current.val;
}
public void AddAtHead(int val) {
Node node = new Node(val);
node.next = head;
if (head != null) head.prev = node;
head = node;
}
public void AddAtTail(int val) {
Node node = new Node(val);
if (head == null) {
head = node;
} else {
Node current = head;
while (current.next != null) {
current = current.next;
}
current.next = node;
node.prev = current;
}
}
public void AddAtIndex(int index, int val) {
if (index == 0) {
AddAtHead(val);
return;
}
Node current = head;
for (int i = 0; i < index - 1 && current != null; i++) {
current = current.next;
}
if (current != null) {
Node node = new Node(val);
node.next = current.next;
if (current.next != null) current.next.prev = node;
current.next = node;
node.prev = current;
}
}
public void DeleteAtIndex(int index) {
Node current = head;
for (int i = 0; current != null && i < index; i++) {
current = current.next;
}
if (current != null) {
if (current.prev != null) current.prev.next = current.next;
else head = current.next;
if (current.next != null) current.next.prev = current.prev;
}
}
}
This C# implementation introduces previous pointers in nodes, supporting multi-directional traversal for doubly linked lists, while maintaining the same basic linked-list operations.