🔗 Linked List – Danh sách liên kết

void pushFront(int value) {
    Node* node = new Node(value);

    node->next = head;
    head = node;

    if (tail == nullptr) {
        tail = node;
    }
}

void pushBack(int value) {
    Node* node = new Node(value);

    if (tail == nullptr) {
        head = tail = node;
        return;
    }

    tail->next = node;
    tail = node;
}

bool insertAt(int position, int value) {
    if (position < 0) return false;

    if (position == 0) {
        pushFront(value);
        return true;
    }

    Node* previous = head;

    for (int index = 1;
         index < position && previous != nullptr;
         index++) {
        previous = previous->next;
    }

    if (previous == nullptr) return false;

    if (previous == tail) {
        pushBack(value);
        return true;
    }

    Node* node = new Node(value);
    node->next = previous->next;
    previous->next = node;

    return true;
}

bool popFront() {
    if (head == nullptr) return false;

    Node* old = head;
    head = head->next;

    if (head == nullptr) {
        tail = nullptr;
    }

    delete old;
    return true;
}

bool eraseFirst(int value) {
    if (head == nullptr) return false;

    if (head->data == value) {
        return popFront();
    }

    Node* previous = head;
    Node* current = head->next;

    while (current != nullptr
           && current->data != value) {
        previous = current;
        current = current->next;
    }

    if (current == nullptr) return false;

    previous->next = current->next;

    if (current == tail) {
        tail = previous;
    }

    delete current;
    return true;
}

void reverseList() {
    Node* previous = nullptr;
    Node* current = head;

    tail = head;

    while (current != nullptr) {
        Node* nextNode = current->next;

        current->next = previous;
        previous = current;
        current = nextNode;
    }

    head = previous;
}

Node* middleNode(Node* head) {
    Node* slow = head;
    Node* fast = head;

    while (fast != nullptr
           && fast->next != nullptr) {
        slow = slow->next;
        fast = fast->next->next;
    }

    return slow;
}

bool hasCycle(Node* head) {
    Node* slow = head;
    Node* fast = head;

    while (fast != nullptr
           && fast->next != nullptr) {
        slow = slow->next;
        fast = fast->next->next;

        if (slow == fast) {
            return true;
        }
    }

    return false;
}

#include <bits/stdc++.h>
using namespace std;

int main() {
    list<int> values = {10, 20, 30};

    values.push_front(5);
    values.push_back(40);

    auto iterator = values.begin();
    advance(iterator, 2);

    values.insert(iterator, 15);

    for (int value : values) {
        cout << value << ' ';
    }
}