Doubly Linked List Visualizer

insertHead(v):  node = new Node(v)  node.next = head  if head ≠ null: head.prev = node  else: tail = node  head = nodeinsertTail(v):  node = new Node(v)  node.prev = tail  if tail ≠ null: tail.next = node  else: head = node  tail = nodeinsertAt(i, v):  if i = 0: insertHead(v); return  cur = head; repeat i − 1 times: cur = cur.next  node = new Node(v)  node.next = cur.next; node.prev = cur  if cur.next ≠ null: cur.next.prev = node else tail = node  cur.next = nodedelete(v):  cur = head  while cur ≠ null and cur.value ≠ v: cur = cur.next  if cur = null: return   // not found  if cur.prev ≠ null: cur.prev.next = cur.next else head = cur.next  if cur.next ≠ null: cur.next.prev = cur.prev else tail = cur.prev  free cursearch(v):  cur = head; i = 0  while cur ≠ null: if cur.value = v: return i    cur = cur.next; i = i + 1  return −1reverse():  cur = head  while cur ≠ null: swap cur.next and cur.prev    cur = cur.prev   // the old next  swap head and tail

struct Node { int value; Node* prev; Node* next; };

class DoublyLinkedList {
    Node *head = nullptr, *tail = nullptr;
public:
    void insertHead(int v) {
        Node* node = new Node{v, nullptr, head};
        if (head) head->prev = node; else tail = node;
        head = node;
    }
    void insertTail(int v) {
        Node* node = new Node{v, tail, nullptr};
        if (tail) tail->next = node; else head = node;
        tail = node;
    }
    void insertAt(int i, int v) {
        if (i == 0) { insertHead(v); return; }
        Node* cur = head;
        for (int k = 1; k < i; k++) cur = cur->next;
        Node* node = new Node{v, cur, cur->next};
        if (cur->next) cur->next->prev = node; else tail = node;
        cur->next = node;
    }
    void remove(int v) {
        Node* cur = head;
        while (cur && cur->value != v) cur = cur->next;
        if (!cur) return;
        if (cur->prev) cur->prev->next = cur->next; else head = cur->next;
        if (cur->next) cur->next->prev = cur->prev; else tail = cur->prev;
        delete cur;
    }
    void reverse() {
        for (Node* cur = head; cur; cur = cur->prev) std::swap(cur->next, cur->prev);
        std::swap(head, tail);
    }
};

class DoublyLinkedList {
    static class Node { int value; Node prev, next; Node(int v) { value = v; } }
    Node head, tail;

    void insertHead(int v) {
        Node node = new Node(v);
        node.next = head;
        if (head != null) head.prev = node; else tail = node;
        head = node;
    }
    void insertTail(int v) {
        Node node = new Node(v);
        node.prev = tail;
        if (tail != null) tail.next = node; else head = node;
        tail = node;
    }
    void insertAt(int i, int v) {
        if (i == 0) { insertHead(v); return; }
        Node cur = head;
        for (int k = 1; k < i; k++) cur = cur.next;
        Node node = new Node(v);
        node.next = cur.next; node.prev = cur;
        if (cur.next != null) cur.next.prev = node; else tail = node;
        cur.next = node;
    }
    void remove(int v) {
        Node cur = head;
        while (cur != null && cur.value != v) cur = cur.next;
        if (cur == null) return;
        if (cur.prev != null) cur.prev.next = cur.next; else head = cur.next;
        if (cur.next != null) cur.next.prev = cur.prev; else tail = cur.prev;
    }
    void reverse() {
        for (Node cur = head; cur != null; cur = cur.prev) {
            Node t = cur.next; cur.next = cur.prev; cur.prev = t;
        }
        Node t = head; head = tail; tail = t;
    }
}

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

class DoublyLinkedList:
    def __init__(self):
        self.head = self.tail = None

    def insert_head(self, v):
        node = Node(v)
        node.next = self.head
        if self.head:
            self.head.prev = node
        else:
            self.tail = node
        self.head = node

    def insert_tail(self, v):
        node = Node(v)
        node.prev = self.tail
        if self.tail:
            self.tail.next = node
        else:
            self.head = node
        self.tail = node

    def delete(self, v):
        cur = self.head
        while cur and cur.value != v:
            cur = cur.next
        if cur is None:
            return
        if cur.prev:
            cur.prev.next = cur.next
        else:
            self.head = cur.next
        if cur.next:
            cur.next.prev = cur.prev
        else:
            self.tail = cur.prev

    def reverse(self):
        cur = self.head
        while cur:
            cur.next, cur.prev = cur.prev, cur.next
            cur = cur.prev
        self.head, self.tail = self.tail, self.head

class Node {
  constructor(value) { this.value = value; this.prev = null; this.next = null; }
}
class DoublyLinkedList {
  constructor() { this.head = null; this.tail = null; }
  insertHead(v) {
    const node = new Node(v);
    node.next = this.head;
    if (this.head) this.head.prev = node; else this.tail = node;
    this.head = node;
  }
  insertTail(v) {
    const node = new Node(v);
    node.prev = this.tail;
    if (this.tail) this.tail.next = node; else this.head = node;
    this.tail = node;
  }
  delete(v) {
    let cur = this.head;
    while (cur && cur.value !== v) cur = cur.next;
    if (!cur) return;
    if (cur.prev) cur.prev.next = cur.next; else this.head = cur.next;
    if (cur.next) cur.next.prev = cur.prev; else this.tail = cur.prev;
  }
  reverse() {
    for (let cur = this.head; cur; cur = cur.prev) [cur.next, cur.prev] = [cur.prev, cur.next];
    [this.head, this.tail] = [this.tail, this.head];
  }
}