One Pass
One pointer
Array to Linked List
- Solution
- Python
def constructLL(self, arr):
if not arr:
return None
curr = head = Node(arr[0])
for i in range(1, len(arr)):
curr.next = Node(arr[i])
curr = curr.next
return heads
1290. Convert Binary Number in a Linked List to Integer
Interactive Visualization
- Mathematical
- Bit Manipulation
- Python
def getDecimalValue(self, head: Optional[ListNode]) -> int:
number = 0
curr = head
while curr:
number = number * 2 + curr.val
curr = curr.next
return number
- Python
def getDecimalValue(self, head: Optional[ListNode]) -> int:
number = 0
curr = head
while curr:
number = (number << 1) | curr.val
curr = curr.next
return number
3263. Convert Doubly Linked List to Array I
- Store & Return
- Yield
- Python
def toArray(self, root: "Optional[Node]") -> List[int]:
array = []
curr = root
while curr:
array.append(curr.val)
curr = curr.next
return array
- Python
def toArray(self, root: "Optional[Node]") -> List[int]:
curr = root
while curr:
yield curr.val
curr = curr.next
3294. Convert Doubly Linked List to Array II
- Store & Return
- Yield
- Python
def toArray(self, node: "Optional[Node]") -> List[int]:
array = collections.deque()
curr = node
while curr:
array.appendleft(curr.val)
curr = curr.prev
curr = node.next if node else None
while curr:
array.append(curr.val)
curr = curr.next
return arrays
- Python
def toArray(self, node: "Optional[Node]") -> List[int]:
curr = node
while curr.prev:
curr = curr.prev
while curr:
yield curr.val
curr = curr.next
237. Delete Node in a Linked List
- Solution
- Python
def deleteNode(self, node) -> None:
node.val = node.next.val
node.next = node.next.next
Search In Linked List
- Solution
- Python
def searchLinkedList(self, head, x):
while head:
if head.data == x:
return True
head = head.next
return False
Is Linked List Length Even?
- Solution
- Python
def isLengthEven(self, head):
length = 0
while head:
head = head.next
length += 1
return length % 2 == 0
Frequency in a Linked List
- Solution
- Python
def count(self, head, key):
count = 0
while head:
count += head.data == key
head = head.next
return count
Modular Node
BasicModular Node
- Solution
- Python
def modularNode(self, 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
- Iterative
- Recursive
Interactive Visualization
- Python
def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
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
Interactive Visualization
- Python
def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
def recursion(node):
if node is None:
return None
node.next = recursion(node.next)
return node if node.val != val else node.next
return recursion(head)
83. Remove Duplicates from Sorted List
:::
- Iterative
- Recursive
- Python
def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
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
- Python
def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
def recursion(node):
if node is None or node.next is None:
return node
node.next = recursion(node.next)
return node if node.val != node.next.val else node.next
return recursion(head)
1474. Delete N Nodes After M Nodes of a Linked List
- Solution
Interactive Visualization
- Python
def deleteNodes(self, head: Optional[ListNode], m: int, n: int) -> Optional[ListNode]:
sentinel = ListNode(None)
curr = sentinel
while curr:
for _ in range(m):
if curr:
curr = curr.next
for _ in range(n):
if curr:
curr.next = curr.next.next
return sentinel.next
Modify Nodes
2046. Sort Linked List Already Sorted Using Absolute Values
- Solution
Interactive Visualization
- Python
def sortLinkedList(self, head: Optional[ListNode]) -> Optional[ListNode]:
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
- Two Pass
- One Pass
- Python
def frequenciesOfElements(self, head: Optional[ListNode]) -> Optional[ListNode]:
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.nexts
- Python
def frequenciesOfElements(self, head: Optional[ListNode]) -> Optional[ListNode]:
hm = {}
curr = head
freq_head = None
while curr:
if curr.val not in hm:
freq_head = ListNode(0, next=freq_head)
hm[curr.val] = freq_head
hm[curr.val].val += 1
curr = curr.next
return freq_head