Singly Linked List

class Node:
    def __init__(self, val):
        self.val = val
        self.next = None

class SLL:
    def __init__(self):
        self.head = None

    def push_front(self, val):  # O(1)
        node = Node(val)
        node.next = self.head
        self.head = node

    def append(self, val):  # O(n)
        node = Node(val)
        if not self.head:
            self.head = node
            return
        curr = self.head
        while curr.next:
            curr = curr.next
        curr.next = node

    def pop_front(self):  # O(1)
        if not self.head:
            return None
        val = self.head.val
        self.head = self.head.next
        return val

    def find(self, val):  # O(n)
        curr = self.head
        while curr:
            if curr.val == val:
                return True
            curr = curr.next
        return False

class Node {
  constructor(val) {
    this.val = val;
    this.next = null;
  }
}

class SLL {
  constructor() { this.head = null; }

  pushFront(val) {  // O(1)
    const node = new Node(val);
    node.next = this.head;
    this.head = node;
  }

  append(val) {  // O(n)
    const node = new Node(val);
    if (!this.head) { this.head = node; return; }
    let curr = this.head;
    while (curr.next) curr = curr.next;
    curr.next = node;
  }

  popFront() {  // O(1)
    if (!this.head) return null;
    const val = this.head.val;
    this.head = this.head.next;
    return val;
  }

  find(val) {  // O(n)
    let curr = this.head;
    while (curr) {
      if (curr.val === val) return true;
      curr = curr.next;
    }
    return false;
  }
}

class Node {
    int val;
    Node next;
    Node(int val) { this.val = val; }
}

class SLL {
    Node head;

    void pushFront(int val) {  // O(1)
        Node node = new Node(val);
        node.next = head;
        head = node;
    }

    void append(int val) {  // O(n)
        Node node = new Node(val);
        if (head == null) { head = node; return; }
        Node curr = head;
        while (curr.next != null) curr = curr.next;
        curr.next = node;
    }

    Integer popFront() {  // O(1)
        if (head == null) return null;
        int val = head.val;
        head = head.next;
        return val;
    }

    boolean find(int val) {  // O(n)
        Node curr = head;
        while (curr != null) {
            if (curr.val == val) return true;
            curr = curr.next;
        }
        return false;
    }
}

struct Node {
    int val;
    Node* next = nullptr;
    Node(int v) : val(v) {}
};

class SLL {
    Node* head = nullptr;
public:
    void push_front(int val) {      // O(1)
        Node* node = new Node(val);
        node->next = head;
        head = node;
    }

    void append(int val) {          // O(n)
        Node* node = new Node(val);
        if (!head) { head = node; return; }
        Node* curr = head;
        while (curr->next) curr = curr->next;
        curr->next = node;
    }

    int pop_front() {               // O(1)
        if (!head) return -1;
        int val = head->val;
        Node* old = head;
        head = head->next;
        delete old;
        return val;
    }

    bool find(int val) const {      // O(n)
        for (Node* c = head; c; c = c->next)
            if (c->val == val) return true;
        return false;
    }
};