singly linked list C++ start example

sll.cpp

#include <iostream>
using namespace std;

class SinglyLinkedList { // визначення класу для однозв'язного списку
public:
    struct Node { // визначення структури вузла списку
        int data = 0; // зберігання даних у вузлі
        Node* next = nullptr; // покажчик на наступний вузол
    };

private:
    Node* head = nullptr; // покажчик на початок списку
    Node* tail = nullptr; // покажчик на кінець списку
    int count = 0; // лічильник кількості вузлів у списку

public:
    void add_to_head(int data) { // метод для додавання вузла в початок списку
        Node* new_elem = new Node; // створення нового вузла
        new_elem->data = data; // присвоєння даних новому вузлу
        new_elem->next = head; // зв’язування нового вузла з поточною головою

        if (head == nullptr) { // перевірка, чи список порожній
            tail = new_elem; // встановлення хвоста, якщо список був порожнім
        }

        head = new_elem; // оновлення голови списку
        count++; // збільшення лічильника вузлів
    }

    void add_to_tail(int data) { // метод для додавання вузла в кінець списку
        Node* new_elem = new Node; // створення нового вузла
        new_elem->data = data; // присвоєння даних новому вузлу

        if (tail == nullptr) { // перевірка, чи список порожній
            head = new_elem; // встановлення голови, якщо список був порожнім
        }
        else {
            tail->next = new_elem; // зв’язування поточного хвоста з новим вузлом
        }

        tail = new_elem; // оновлення хвоста списку
        count++; // збільшення лічильника вузлів
    }

    void insert_into(int data, int position) { // метод для вставки вузла на задану позицію
        if (position >= count) { // перевірка, чи позиція виходить за межі списку
            add_to_tail(data); // додавання в кінець, якщо позиція за межами
            return; // завершення функції
        }
        else if (position <= 0) { // перевірка, чи позиція на початку або до нього
            add_to_head(data); // додавання в початок, якщо позиція недійсна
            return; // завершення функції
        }

        Node* new_elem = new Node(); // створення нового вузла
        new_elem->data = data; // присвоєння даних новому вузлу

        int i = 1; // ініціалізація лічильника для проходження списку
        Node* before_new = head; // вказівник на вузол перед місцем вставки

        while (i++ != position) { // проходження до потрібної позиції
            before_new = before_new->next; // перехід до наступного вузла
        }

        new_elem->next = before_new->next; // зв’язування нового вузла з наступним
        before_new->next = new_elem; // вставка нового вузла в список
        count++; // збільшення лічильника вузлів
    }

    void delete_from_head() { // метод для видалення вузла з початку списку
        if (count == 0) { // перевірка, чи список порожній
            // cout << "список порожній\n";
            return; // завершення функції, якщо список порожній
        }

        Node* temp = head; // збереження вказівника на голову для видалення
        head = head->next; // оновлення голови списку
        delete temp; // звільнення пам’яті видаленого вузла
        count--; // зменшення лічильника вузлів

        if (head == nullptr) { // перевірка, чи список став порожнім
            tail = nullptr; // очищення хвоста, якщо список порожній
        }
    }

    void delete_from_tail() { // метод для видалення вузла з кінця списку
        if (count == 0) { // перевірка, чи список порожній
            // cout << "список порожній\n";
            return; // завершення функції, якщо список порожній
        }
        delete_by_index(count - 1); // виклик видалення за індексом для останнього вузла
    }

    void delete_by_index(int position) { // метод для видалення вузла за заданою позицією
        if (position <= 0) { // перевірка, чи позиція на початку або до нього
            delete_from_head(); // видалення з початку, якщо позиція недійсна
            return; // завершення функції
        }

        if (position >= count) { // перевірка, чи позиція виходить за межі списку
            position = count - 1; // корекція позиції до останнього вузла
        }

        int i = 1; // ініціалізація лічильника для проходження списку
        Node* before_del = head; // вказівник на вузол перед видаленням

        while (i++ != position) { // проходження до потрібної позиції
            before_del = before_del->next; // перехід до наступного вузла
        }

        Node* sacrifice = before_del->next; // збереження вказівника на вузол для видалення
        before_del->next = sacrifice->next; // перев’язування списку, обходячи видалений вузол
        delete sacrifice; // звільнення пам’яті видаленого вузла
        count--; // зменшення лічильника вузлів

        if (before_del->next == nullptr) { // перевірка, чи видалений вузол був останнім
            tail = before_del; // оновлення хвоста списку
        }
    }

    void clear() { // метод для очищення всього списку
        while (head != nullptr) { // цикл для видалення всіх вузлів
            delete_from_head(); // видалення вузла з початку
        }
    }

    void print() const { // метод для виведення списку
        if (count == 0) { // перевірка, чи список порожній
            cout << "список порожній\n"; // виведення повідомлення про порожній список
            return; // завершення функції
        }

        Node* current = head; // ініціалізація вказівника для проходження списку

        while (current != nullptr) { // цикл для проходження всіх вузлів
            cout << current->data << " "; // виведення даних поточного вузла
            current = current->next; // перехід до наступного вузла
        }
        cout << "\n"; // додавання нового рядка після виведення
    }

    int get_count() const { // метод для отримання кількості вузлів
        return count; // повернення значення лічильника
    }

    int index_of(int data) const { // метод для пошуку індексу вузла за значенням
        if (count == 0) { // перевірка, чи список порожній
            // cout << "список порожній\n";
            return -1; // повернення -1, якщо список порожній
        }

        Node* temp = head; // ініціалізація вказівника для проходження списку
        int i = 0; // ініціалізація лічильника позицій

        while (i < count) { // цикл для проходження всіх вузлів
            if (data == temp->data) { // перевірка збігу даних у вузлі
                return i; // повернення індексу знайденого вузла
            }
            i++; // збільшення лічильника позицій
            temp = temp->next; // перехід до наступного вузла
        }
        return -1; // повернення -1, якщо значення не знайдено
    }
};

int main() {
    SinglyLinkedList sll; // створення об’єкта однозв’язного списку

    // вставка в кінець списку
    sll.add_to_tail(10); // додавання значення 10 в кінець
    sll.add_to_tail(20); // додавання значення 20 в кінець
    sll.add_to_tail(30); // додавання значення 30 в кінець
    sll.add_to_tail(40); // додавання значення 40 в кінець
    sll.print(); // виведення списку після додавання

    // вставка в початок списку
    sll.add_to_head(50); // додавання значення 50 на початок
    sll.add_to_head(60); // додавання значення 60 на початок
    sll.add_to_head(70); // додавання значення 70 на початок
    sll.add_to_head(80); // додавання значення 80 на початок
    sll.print(); // виведення списку після додавання

    // кількість елементів та пошук
    cout << "кількість елементів: " << sll.get_count() << "\n"; // виведення кількості елементів у списку
    cout << "індекс числа 70: " << sll.index_of(70) << ", індекс числа 90: " << sll.index_of(90) << "\n"; // виведення індексу значення 70 та 90

    // вставка в середину
    sll.insert_into(-1, -1); // вставка значення -1 на недійсну позицію
    sll.print(); // виведення списку після вставки

    sll.insert_into(2, 2); // вставка значення 2 на позицію 2
    sll.print(); // виведення списку після вставки

    sll.insert_into(22, 22); // вставка значення 22 за межі списку
    sll.print(); // виведення списку після вставки

    // видалення з початку списку
    sll.delete_from_head(); // видалення першого вузла
    sll.delete_from_head(); // видалення другого вузла
    sll.delete_from_head(); // видалення третього вузла
    sll.print(); // виведення списку після видалення

    // видалення з кінця списку
    sll.delete_from_tail(); // видалення останнього вузла
    sll.delete_from_tail(); // видалення передостаннього вузла
    sll.delete_from_tail(); // видалення ще одного вузла з кінця
    sll.print(); // виведення списку після видалення

    // видалення по вказаному індексу
    sll.delete_by_index(0); // видалення вузла за індексом 0
    sll.delete_by_index(1); // видалення вузла за індексом 1
    sll.delete_by_index(2); // видалення вузла за індексом 2
    sll.print(); // виведення списку після видалення

    // очищення списку
    sll.clear(); // видалення всіх вузлів зі списку
    sll.print(); // виведення списку після очищення

    return 0;
}