Circular Linked List Visualizer

// tail.next is always the headinsertHead(v):  node = new Node(v)  if tail = null: node.next = node; tail = node; return  node.next = tail.next   // the old head  tail.next = node  (head is now node)insertTail(v):  node = new Node(v)   // empty list: same as insertHead  node.next = tail.next  tail.next = node  tail = nodeinsertAt(i, v):  if i = 0: insertHead(v); return  cur = tail.next; repeat i − 1 times: cur = cur.next  node = new Node(v)  node.next = cur.next  cur.next = node; if cur = tail: tail = nodedelete(v):  cur = tail.next  repeat n times: if cur.value = v: stop; cur = cur.next  if not found: return  prev.next = cur.next; fix tail if cur was tail  free cursearch(v):  cur = tail.next; i = 0  do: if cur.value = v: return i      cur = cur.next; i = i + 1  while cur ≠ tail.next; return −1reverse():  prev = tail; cur = tail.next  repeat n times    next = cur.next    cur.next = prev    prev = cur; cur = next  tail = old head (tail.next is the new head)

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

class CircularList {          // only a tail pointer: head is tail->next
    Node* tail = nullptr;
public:
    void insertHead(int v) {
        Node* node = new Node{v, nullptr};
        if (!tail) { node->next = node; tail = node; return; }
        node->next = tail->next;
        tail->next = node;
    }
    void insertTail(int v) { insertHead(v); tail = tail->next; }
    void remove(int v) {
        if (!tail) return;
        Node* prev = tail;
        do {
            if (prev->next->value == v) {
                Node* cur = prev->next;
                if (cur == prev) tail = nullptr;          // only node
                else { prev->next = cur->next; if (cur == tail) tail = prev; }
                delete cur;
                return;
            }
            prev = prev->next;
        } while (prev != tail);
    }
    void print() const {
        if (!tail) return;
        Node* cur = tail->next;
        do { std::cout << cur->value << ' '; cur = cur->next; } while (cur != tail->next);
    }
};

class CircularList {          // only a tail pointer: head is tail.next
    static class Node { int value; Node next; Node(int v) { value = v; } }
    Node tail;

    void insertHead(int v) {
        Node node = new Node(v);
        if (tail == null) { node.next = node; tail = node; return; }
        node.next = tail.next;
        tail.next = node;
    }
    void insertTail(int v) { insertHead(v); tail = tail.next; }
    void remove(int v) {
        if (tail == null) return;
        Node prev = tail;
        do {
            if (prev.next.value == v) {
                Node cur = prev.next;
                if (cur == prev) tail = null;
                else { prev.next = cur.next; if (cur == tail) tail = prev; }
                return;
            }
            prev = prev.next;
        } while (prev != tail);
    }
    boolean contains(int v) {
        if (tail == null) return false;
        Node cur = tail.next;
        do { if (cur.value == v) return true; cur = cur.next; } while (cur != tail.next);
        return false;
    }
}

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

class CircularList:
    """Only a tail pointer is kept: the head is tail.next."""
    def __init__(self):
        self.tail = None

    def insert_head(self, v):
        node = Node(v)
        if self.tail is None:
            node.next = node
            self.tail = node
            return
        node.next = self.tail.next
        self.tail.next = node

    def insert_tail(self, v):
        self.insert_head(v)
        self.tail = self.tail.next

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

    def values(self):
        if self.tail is None:
            return []
        out, cur = [], self.tail.next
        while True:
            out.append(cur.value)
            cur = cur.next
            if cur is self.tail.next:
                return out

class Node {
  constructor(value) { this.value = value; this.next = null; }
}
class CircularList {   // only a tail pointer: head is tail.next
  constructor() { this.tail = null; }
  insertHead(v) {
    const node = new Node(v);
    if (!this.tail) { node.next = node; this.tail = node; return; }
    node.next = this.tail.next;
    this.tail.next = node;
  }
  insertTail(v) { this.insertHead(v); this.tail = this.tail.next; }
  delete(v) {
    if (!this.tail) return;
    let prev = this.tail;
    do {
      const cur = prev.next;
      if (cur.value === v) {
        if (cur === prev) this.tail = null;
        else { prev.next = cur.next; if (cur === this.tail) this.tail = prev; }
        return;
      }
      prev = cur;
    } while (prev !== this.tail);
  }
  *[Symbol.iterator]() {
    if (!this.tail) return;
    let cur = this.tail.next;
    do { yield cur.value; cur = cur.next; } while (cur !== this.tail.next);
  }
}

// head.prev = tail and tail.next = headinsertHead(v):  node = new Node(v)  if head = null: node.next = node.prev = node; head = tail = node; return  node.next = head; node.prev = tail  head.prev = node; tail.next = node  head = nodeinsertTail(v):  node = new Node(v)  node.next = head; node.prev = tail  tail.next = node; head.prev = 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  cur.next.prev = node  cur.next = node; if cur = tail: tail = nodedelete(v):  cur = head  repeat n times: if cur.value = v: stop; cur = cur.next  if not found: return  cur.prev.next = cur.next  cur.next.prev = cur.prev; fix head or tail if needed  free cursearch(v):  cur = head; i = 0  do: if cur.value = v: return i      cur = cur.next; i = i + 1  while cur ≠ head; return −1reverse():  cur = head  repeat n times: swap cur.next and cur.prev    cur = cur.prev   // the old next  swap head and tail

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

class CircularDoublyList {
    Node* head = nullptr;               // tail is head->prev
public:
    void insertTail(int v) {
        Node* node = new Node{v, nullptr, nullptr};
        if (!head) { node->prev = node->next = node; head = node; return; }
        Node* tail = head->prev;
        node->next = head; node->prev = tail;
        tail->next = node; head->prev = node;
    }
    void insertHead(int v) { insertTail(v); head = head->prev; }
    void remove(int v) {
        if (!head) return;
        Node* cur = head;
        do {
            if (cur->value == v) {
                if (cur->next == cur) head = nullptr;
                else {
                    cur->prev->next = cur->next;
                    cur->next->prev = cur->prev;
                    if (cur == head) head = cur->next;
                }
                delete cur;
                return;
            }
            cur = cur->next;
        } while (cur != head);
    }
};

class CircularDoublyList {
    static class Node { int value; Node prev, next; Node(int v) { value = v; } }
    Node head;                           // tail is head.prev

    void insertTail(int v) {
        Node node = new Node(v);
        if (head == null) { node.prev = node.next = node; head = node; return; }
        Node tail = head.prev;
        node.next = head; node.prev = tail;
        tail.next = node; head.prev = node;
    }
    void insertHead(int v) { insertTail(v); head = head.prev; }
    void remove(int v) {
        if (head == null) return;
        Node cur = head;
        do {
            if (cur.value == v) {
                if (cur.next == cur) head = null;
                else {
                    cur.prev.next = cur.next;
                    cur.next.prev = cur.prev;
                    if (cur == head) head = cur.next;
                }
                return;
            }
            cur = cur.next;
        } while (cur != head);
    }
}

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

class CircularDoublyList:
    def __init__(self):
        self.head = None               # tail is head.prev

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

    def insert_head(self, v):
        self.insert_tail(v)
        self.head = self.head.prev

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

class Node {
  constructor(value) { this.value = value; this.prev = this; this.next = this; }
}
class CircularDoublyList {
  constructor() { this.head = null; }     // tail is head.prev
  insertTail(v) {
    const node = new Node(v);
    if (!this.head) { this.head = node; return; }
    const tail = this.head.prev;
    node.next = this.head; node.prev = tail;
    tail.next = node; this.head.prev = node;
  }
  insertHead(v) { this.insertTail(v); this.head = this.head.prev; }
  delete(v) {
    if (!this.head) return;
    let cur = this.head;
    do {
      if (cur.value === v) {
        if (cur.next === cur) this.head = null;
        else {
          cur.prev.next = cur.next;
          cur.next.prev = cur.prev;
          if (cur === this.head) this.head = cur.next;
        }
        return;
      }
      cur = cur.next;
    } while (cur !== this.head);
  }
}