Build a Linked List From Scratch

```python
class Node:
    def __init__(self, value, next=None):
        self.value = value
        self.next = next

class LinkedList:
    def __init__(self) -> None:
        self.head: Node | None = None
        self.tail: Node | None = None
        self.size = 0

    def push_front(self, value) -> None:              # O(1)
        self.head = Node(value, next=self.head)
        if self.tail is None:                         # was empty
            self.tail = self.head
        self.size += 1

    def push_back(self, value) -> None:               # O(1) via tail
        node = Node(value)
        if self.tail is None:                         # empty list
            self.head = self.tail = node
        else:
            self.tail.next = node                     # old tail links on
            self.tail = node
        self.size += 1

    def find(self, value) -> Node | None:             # O(n)
        curr = self.head
        while curr is not None:
            if curr.value == value:
                return curr
            curr = curr.next
        return None

    def delete(self, value) -> bool:                  # O(n)
        prev, curr = None, self.head
        while curr is not None:
            if curr.value == value:
                if prev is None:                      # deleting the head
                    self.head = curr.next
                else:
                    prev.next = curr.next             # splice curr out
                if curr is self.tail:                 # deleting the tail
                    self.tail = prev
                self.size -= 1
                return True
            prev, curr = curr, curr.next
        return False

    def to_list(self) -> list:                        # O(n) — for testing
        out, curr = [], self.head
        while curr is not None:
            out.append(curr.value)
            curr = curr.next
        return out
```

```typescript
class ListNode<T> {
  constructor(
    public value: T,
    public next: ListNode<T> | null = null,
  ) {}
}

class LinkedList<T> {
  head: ListNode<T> | null = null;
  tail: ListNode<T> | null = null;
  size = 0;

  pushFront(value: T): void {
    // O(1)
    this.head = new ListNode(value, this.head);
    if (this.tail === null) this.tail = this.head; // was empty
    this.size++;
  }

  pushBack(value: T): void {
    // O(1) via tail
    const node = new ListNode(value);
    if (this.tail === null) {
      this.head = this.tail = node; // empty list
    } else {
      this.tail.next = node; // old tail links on
      this.tail = node;
    }
    this.size++;
  }

  find(value: T): ListNode<T> | null {
    // O(n)
    let curr = this.head;
    while (curr !== null) {
      if (curr.value === value) return curr;
      curr = curr.next;
    }
    return null;
  }

  delete(value: T): boolean {
    // O(n)
    let prev: ListNode<T> | null = null;
    let curr = this.head;
    while (curr !== null) {
      if (curr.value === value) {
        if (prev === null) this.head = curr.next; // deleting the head
        else prev.next = curr.next; // splice curr out
        if (curr === this.tail) this.tail = prev; // deleting the tail
        this.size--;
        return true;
      }
      prev = curr;
      curr = curr.next;
    }
    return false;
  }

  toArray(): T[] {
    // O(n) — for testing
    const out: T[] = [];
    for (let curr = this.head; curr !== null; curr = curr.next) {
      out.push(curr.value);
    }
    return out;
  }
}
```