circular linked list

#include <iostream>

// Csomópont struktúra
struct Node {
    int data;
    Node* next;

    Node(int d) : data(d), next(nullptr) {}
};

// Ciklikus láncolt lista osztály
class CircularLinkedList {
private:
    Node* tail; // Az utolsó elemre mutató pointer

public:
    CircularLinkedList() : tail(nullptr) {}

    // Elem beszúrása a lista végére
    void insertAtEnd(int value) {
        Node* newNode = new Node(value);
        if (!tail) {  // Ha a lista üres
            tail = newNode;
            tail->next = tail; // Önmagára mutat
        } else {
            newNode->next = tail->next; // Új csomópont mutat a fejre
            tail->next = newNode; // Régi utolsó csomópont mutat az újra
            tail = newNode; // Frissítjük a tail pointert
        }
    }

    // Elem törlése egy adott érték alapján
    void deleteValue(int value) {
        if (!tail) return; // Ha a lista üres

        Node* current = tail->next;
        Node* prev = tail;

        do {
            if (current->data == value) {
                if (current == tail->next && current == tail) { 
                    // Ha egyetlen elem van
                    delete current;
                    tail = nullptr;
                    return;
                }
                if (current == tail->next) { 
                    // Ha a fejet töröljük
                    tail->next = current->next;
                }
                if (current == tail) { 
                    // Ha az utolsó elemet töröljük
                    tail = prev;
                }
                prev->next = current->next;
                delete current;
                return;
            }
            prev = current;
            current = current->next;
        } while (current != tail->next);
    }

    // Lista kiírása
    void printList() {
        if (!tail) {
            std::cout << "A lista üres.\n";
            return;
        }
        Node* temp = tail->next;
        do {
            std::cout << temp->data << " -> ";
            temp = temp->next;
        } while (temp != tail->next);
        std::cout << "(vissza a fejre)\n";
    }

    // Destruktor (memóriaszivárgás elkerülése)
    ~CircularLinkedList() {
        if (!tail) return;
        Node* current = tail->next;
        Node* nextNode;
        while (current != tail) {
            nextNode = current->next;
            delete current;
            current = nextNode;
        }
        delete tail;
    }
};

// Főprogram
int main() {
    CircularLinkedList cll;

    cll.insertAtEnd(1);
    cll.insertAtEnd(2);
    cll.insertAtEnd(3);
    cll.insertAtEnd(4);

    std::cout << "Ciklikus láncolt lista elemei:\n";
    cll.printList();

    cll.deleteValue(2);
    std::cout << "2 törlése után:\n";
    cll.printList();

    return 0;
}

#include <iostream>

// Csomópont struktúra
struct Node {
    int data;
    Node* next;
    Node* prev;

    Node(int d) : data(d), next(nullptr), prev(nullptr) {}
};

// Kétszeresen ciklikus láncolt lista osztály
class DoublyCircularLinkedList {
private:
    Node* tail;

public:
    DoublyCircularLinkedList() : tail(nullptr) {}

    // Elem beszúrása a lista végére
    void insertAtEnd(int value) {
        Node* newNode = new Node(value);
        if (!tail) {
            tail = newNode;
            tail->next = tail;
            tail->prev = tail;
        } else {
            newNode->prev = tail;
            newNode->next = tail->next;
            tail->next->prev = newNode;
            tail->next = newNode;
            tail = newNode;
        }
    }

    // Lista kiírása előre és visszafelé
    void printList() {
        if (!tail) {
            std::cout << "A lista üres.\n";
            return;
        }
        Node* temp = tail->next;
        std::cout << "Előrefelé: ";
        do {
            std::cout << temp->data << " <-> ";
            temp = temp->next;
        } while (temp != tail->next);
        std::cout << "(vissza a fejre)\n";
    }

    // Destruktor (memóriaszivárgás elkerülése)
    ~DoublyCircularLinkedList() {
        if (!tail) return;
        Node* current = tail->next;
        while (current != tail) {
            Node* temp = current;
            current = current->next;
            delete temp;
        }
        delete tail;
    }
};

// Főprogram
int main() {
    DoublyCircularLinkedList dcll;

    dcll.insertAtEnd(1);
    dcll.insertAtEnd(2);
    dcll.insertAtEnd(3);
    dcll.insertAtEnd(4);

    dcll.printList();

    return 0;
}