Skip to main content

One Pass

One pointer​

Array to Linked List​

Easy·
FIG. ARRAY TO LINKED LIST● INTERACTIVE
visualization loads as you reach it
def array_to_linked_list(arr):
head = ListNode(arr[0])
curr = head
for i in range(1, len(arr)):
curr.next = ListNode(arr[i])
curr = curr.next
return head

1290. Convert Binary Number in a Linked List to Integer​

Easy·
2 Approaches · 2 patterns
FIG. CONVERT BINARY NUMBER IN A LINKED LIST T● INTERACTIVE
visualization loads as you reach it
def getDecimalValue(head):
number = 0
curr = head
while curr:
number = number * 2 + curr.val
curr = curr.next
return number

3263. Convert Doubly Linked List to Array I​

2 Approaches
FIG. CONVERT DOUBLY LINKED LIST TO ARRAY I● INTERACTIVE
visualization loads as you reach it
def toArray(head):
array = []
curr = head
while curr:
array.append(curr.val)
curr = curr.next
return array

3294. Convert Doubly Linked List to Array II​

Medium·
2 Approaches
FIG. CONVERT DOUBLY LINKED LIST TO ARRAY II● INTERACTIVE
visualization loads as you reach it
def toArray(head):
array = collections.deque()
curr = head
while curr:
array.appendleft(curr.val)
curr = curr.prev
curr = head.next if head else None
while curr:
array.append(curr.val)
curr = curr.next
return array

237. Delete Node in a Linked List​

Medium·
FIG. DELETE NODE IN A LINKED LIST● INTERACTIVE
visualization loads as you reach it
def deleteNode(node):
node.val = node.next.val
node.next = node.next.next

Search In Linked List​

Basic·
FIG. SEARCH IN LINKED LIST● INTERACTIVE
visualization loads as you reach it
def searchLinkedList(head, x):
while head:
if head.data == x:
return True
head = head.next
return False

Is Linked List Length Even?​

Basic·
FIG. IS LINKED LIST LENGTH EVEN● INTERACTIVE
visualization loads as you reach it
def isLengthEven(head):
length = 0
while head:
head = head.next
length += 1
return length % 2 == 0

Frequency in a Linked List​

Easy·
FIG. FREQUENCY IN A LINKED LIST● INTERACTIVE
visualization loads as you reach it
def count(head, key):
count = 0
while head:
count += head.data == key
head = head.next
return count

Modular Node​

Basic·
FIG. MODULAR NODE● INTERACTIVE
visualization loads as you reach it
def modularNode(head, k):
mod_node = None
curr = head
index = 1
while curr:
if index % k == 0:
mod_node = curr
curr = curr.next
index += 1
return mod_node.data if mod_node else -1

Remove Nodes​

203. Remove Linked List Elements​

Easy·
2 Approaches
FIG. REMOVE LINKED LIST ELEMENTS● INTERACTIVE
visualization loads as you reach it
def removeElements(head, val):
sentinel = ListNode(None, next=head)
current_node = sentinel
while current_node and current_node.next:
if current_node.next.val == val:
current_node.next = current_node.next.next
else:
current_node = current_node.next
return sentinel.next

83. Remove Duplicates from Sorted List​

2 Approaches
FIG. REMOVE DUPLICATES FROM SORTED LIST● INTERACTIVE
visualization loads as you reach it
def deleteDuplicates(head):
current_node = head
while current_node and current_node.next:
if current_node.val == current_node.next.val:
current_node.next = current_node.next.next
else:
current_node = current_node.next
return head

1474. Delete N Nodes After M Nodes of a Linked List​

Easy·
FIG. DELETE N NODES AFTER M NODES OF A LINKED● INTERACTIVE
visualization loads as you reach it
class Solution:
def deleteNodes(self, head: ListNode, m: int, n: int) -> ListNode:
sentinel = ListNode(None, head) # Sentinel node
p = sentinel
while p and p.next:
for _ in range(m):
if p:
p = p.next
for _ in range(n):
if p and p.next:
p.next = p.next.next
return sentinel.next

Modify Nodes​

2046. Sort Linked List Already Sorted Using Absolute Values​

Medium·
FIG. SORT LINKED LIST ALREADY SORTED USING AB● INTERACTIVE
visualization loads as you reach it
def sortLinkedList(head):
sentinel = ListNode(None, next=head)
current_node = sentinel.next
while current_node and current_node.next:
if current_node.next.val < 0:
next_node = current_node.next
current_node.next = next_node.next
next_node.next = sentinel.next
sentinel.next = next_node
else:
current_node = current_node.next
return sentinel.next

Counter​

3063. Linked List Frequency​

Easy·
2 Approaches
FIG. LINKED LIST FREQUENCY● INTERACTIVE
visualization loads as you reach it
def frequenciesOfElements(head):
counter = Counter()
curr = head
while curr:
counter[curr.val] += 1
curr = curr.next
sentinel = ListNode(None)
curr = sentinel
for freq in counter.values():
curr.next = ListNode(freq)
curr = curr.next
return sentinel.next