## Linked Lists
* like arrays, a linked list is used to represent sequential data. it's a linear collection of data elements (nodes) whose order is not given by their physical placement in memory (as opposed to arrays where data is stored in sequential blocks of memory). instead, each element contains an address of the next element.
```python
class Node:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
```
* unlike an array, a linked list does not provide constant time access to an index (as it needs to interact through all `k` elements), however addition and removal of elements are constant time (`O(1)`).
* if you need to add or delete a node frequently, a linked list could be a good choice.
* if you need to access an element by index often, an array might be a better choice than a linked list.
* linked lists can be of the following types:
* **singled linked list**: a linked list where each node points to the next node and the last node points to `None`.
* **doubly linked list**: a linked list where each node has two pointers, `next` and `prev`. the `prev` pointer of the first node and the `next` pointer of the last node point to `None`.
* **circular linked list**: a singly linked list where the past node points back to the first node. if it's doubly, the `prev` pointer of the first node points to the last node, and the `next` pointer of the last node points to the first node.
* each node in a singly-linked list contains a value and a reference field to link to the next node. the head node (first node) usually represents the whole list.
* nodes can be added at the beginning, head needs to be updated (`current -> head` and `head = current`).
* to remove a node you set `prev.next` equal to `node.next`. if it's a double list, you also update `node.next` with `node.next.prev` to `node.prev` (and deallocate the memory).
* adding a sentinel/dummy node at the head and/or tail might help handle many edge cases where operations have to be performed at the head or the tail.
* the presence of dummy nodes ensures that operations will never be done on the head or the tail (removing the need of conditional checks to deal with `None` pointers). the only extra steps is that they need to be removed at the end of the operation.
* examples are LRU cache (where sentinel nodes are used as pseudo-head and pseudo-tail) and tree level order traversal (where sentinel nodes are used to mark level end).
* two pointers can be used to solve several problems:
* getting the kth from last node: have two pointers, where one is `k` nodes ahead of the other, when the node ahead reaches the end, the other node is `k` behind.
* detecting cycles: have two pointers, where one pointer increments twice as much as the other. if the two pointers meet, there is a cycle. if there is no cycle, the faster pointer takes `N/2` to reach the end of the list (`N` being the length).
* getting in the middle node: have two pointers, where one pointer increments twices as much as the other. when the faster node reaches the end of the list, the slower node will be at the middle.
----
### deleting without head
```python
def delete_node_without_head(node):
node.val = node.next.val
node.next = node.next.next
```
----
### detecting cycles
```python
def has_cycle(head) -> bool:
if not head:
return False
p1 = head
p2 = head.next
while p1 != p2:
if not p1 or not p2 or not p2.next:
return False
p1 = p1.next
p2 = p2.next.next
return True
```
----
### reversing the list
* keep track of the original head node and the new head node (for instance, with two pointers).
```python
def reverse_list(head):
if head is None:
return head
prev = None
curr = head
while curr:
next_temp = curr.next // save the pointer for the next node so we can continue the loop
curr.next = prev // revert the list
prev = curr // save for the next node revert
curr = next_temp // receive the pointer for the next node so we can continue the loop
return prev
```
---
### removing elements
* given a head of a linked list and a value, how to remove all the nodes of the list that have that value? this problem is easy if one has to delete a node in the middle, as all you need to do is loop until the predecessor node and change the pointers.
* however, if the node to be deleted is in the head of the list, the best way is to use a sentinel node. sentinel nodes are widely used in trees and linked lists as pseudo-heads, pseudo-tails, markers of level end, etc. they are purely functional and usually do not hold any data. their main purpose is to standardize the process (by making the list never empty or headless).
*
```python
def remove_elements(head, val):
sentinel = ListNode(0)
sentinel.next = head
prev, node = sentinel, head
while node:
if node.val == val:
prev.next = node.next
else:
prev = node
node = node.next
return sentinel.next
```
----
### doubly linked lists
* in doubly linked lists, a node has a `previous` field.
* when it comes to add and delete operations, extra attention is needed when you want to delete or insert at the beginning or at the end of the list.
----
### swap every two nodes
```python
def swap_pairs(head):
if not head or not head.next:
return head
first_node = head
second_node = head.next
first_node.next = swap_pairs(second_node.next)
second_node.next = first_node
return second_node
```