KURSACH

//кольцевой односвязный список векторов целого типа на односвязном списке


#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

using namespace std;

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

struct Vec {
    struct Node* first = NULL;
    int counter = 0;
};
struct ListNode {
    Vec value;
    struct ListNode* next;
};
struct List {
    struct ListNode* first = NULL;
    struct ListNode* Last = NULL;
    struct ListNode* current = NULL;
    int counter = 0;
};

void alloc_check(void* p) {
    if (p == NULL) {
        printf("\n= Ошибка выделения памяти. =\n");
        exit(-1);
    }
}
bool current_check(List* L) {
    if (L->current == NULL) {
        printf("= Ошибка! Нет выбранного вектора! = \n");
        return true;
    }
    else return false;
}
bool ListEmptyCheck(List* L) {
    if (L->counter == 0) {
        printf("Список пуст!\n");
        return true;
    }
    else return false;
}
void clear_buff() {
    int c;
    while ((c = getchar()) != '\n' && c != EOF) {}
}
void MakeEmpty(Vec* V) {
    struct Node* p, * p1;
    p = V->first;
    for (int i = 0; i < V->counter;i++) {
        p1 = p->next;
        free (p);
        p = p1;
    }
    V->first = NULL;
    V->counter = 0;
    printf("Список очищен!\n");
}
void EmptyCheck(Vec* V) {
    if (V->counter == 0) {
        printf("Список пуст!\n");
    }
    else {
        printf("Список не пуст\n");
    }
}
void ShowInd(Vec* V) {
    int num = 0;
    Node *tmp = V->first;
    if (V->counter == 0) {
        printf("Список пуст!\n");

    }
    else {
        printf("Введите индекс элемента: ");
        if (scanf_s("%d", &num)==1 && num > 0 && num<=(V->counter)) {
            for (int i = 0; i < num-1; i++) {
                tmp = tmp->next;
            }
            printf("Значение элемента: %d\n", tmp->value);
        }
        else {
            printf("Введите правильное число!\n");
        }
    }
}
void EndAdd(Vec* V) {
    int val = 0;
    printf("Введите элемент:");
    scanf_s("%d", &val);
    Node* tmp = V->first;
    if (V->first)
    {
        while (tmp->next)
        {
            tmp = tmp->next;
        }
        tmp->next = (Node*)malloc(sizeof(Node));
        tmp->next->value = val;
        tmp->next->next = NULL;
    }
    else
    {
        V->first = (Node*)malloc(sizeof(Node));
        V->first->value = val;
        V->first->next = NULL;
    }

    V->counter++;
    printf("Элемент добавлен\n");
}
void ShowVec(Vec* V) {
    if (V->counter != 0) {
        Node* curr = V->first;
        while (curr) {
            cout << curr->value << ' ';
            curr = curr->next;
        }
        cout << endl;
    }
    else {
        printf("Вектор пуст!\n");
        return;
    }
}
void EndDel(Vec* V) {
    Node* tmp = V->first;
    if (V->first)
    {
        while (tmp->next->next!=NULL)
        {
            tmp = tmp->next;
        }
        free(tmp->next);
        tmp->next = NULL;
        V->counter--;
    }
    printf("Элемент удален!\n");
}
void ChangebyInd(Vec* V)
{
    int num = 0;
    int val;
    Node* tmp = V->first;
    if (V->counter == 0) {
        printf("Список пуст!\n");
    }
    else {
        printf("Введите индекс элемента: ");
        scanf_s("%d", &num);
        printf("Введите новое значение элемента: ");
        scanf_s("%d", &val);
        if (num > 0 && num <= V->counter) {
            for (int i = 1; i < num; i++) {
                tmp = tmp->next;
            }
            tmp->value = val;
        }
        else {
            printf("Элемента под данным индексом не существует!\n");
            return;
        }
    }
}
void TakebyInd(Vec* V) {
    int num = 0;
    Node* tmp = V->first;
    Node* prevTmp = NULL;
    if (V->counter <= 0) {
        printf("Список пуст!\n");
    }
    else {
        printf("Введите индекс элемента: ");
        scanf_s("%d", &num);
        for (int i = 1; i <  num; i++) {
            prevTmp = tmp;
            tmp = tmp->next;
        }
        printf("Элемент: %d\n", tmp->value);
        if (num != 1) {
            prevTmp->next = tmp->next;
        }
        free(tmp);
        V->counter--;
    }
}

void VecStart(Vec* V) {
    while (1) {
        int num;

        printf("= Обработка вектора =\n\
1.Сделать пустым\n\
2.Пуст ли ?\n\
3.Сколько элементов ?\n\
4.Показать значение элемента по индексу, при некорректном индексе выводится сообщение\n\
5.Удалить элемент из конца\n\
6.Взять элемент по индексу\n\
7.Изменить значение по индексу\n\
8.Добавить элемент в конец\n\
9.Распечатать вектор\n\
10.Закончить работу\n");
        if (scanf_s("%d", &num) == 1) {
            switch (num)
            {
            case 1:
                system("cls");
                MakeEmpty(V);

                break;
            case 2:
                system("cls");
                EmptyCheck(V);

                break;
            case 3:
                system("cls");
                printf("Количество элементов: %d\n", V->counter);

                break;
            case 4:
                system("cls");
                ShowInd(V);

                break;
            case 5:
                system("cls");
                EndDel(V);

                break;
            case 6:
                system("cls");
                TakebyInd(V);

                break;
            case 7:
                system("cls");
                ChangebyInd(V);

                break;
            case 8:
                system("cls");
                EndAdd(V);

                break;
            case 9:
                system("cls");
                ShowVec(V);

                break;
            case 10:
                return;
                break;
            default:
                printf("Неправильное число!\n");

            }
        }
        else {
            clear_buff();
            printf("Неправильный символ!\n");
        }
    }

}
//------------------------------



//Разделитель



//------------------------------

void ListFree(List* L){
    struct ListNode* p, * p1;
    p = L->first;
    for(int i=0; i<L->counter;i++) {
        p1 = p->next;
        MakeEmpty(&p->value);
        //возможна утечка
        //free (p);
        p = p1;
    }
    L->first = NULL;
    L->Last = NULL;
    L->current = NULL;
    L->counter = 0;
}
void MoveIndFw(List* L){

    L->current = L->current->next;
}
void LookAfterInd(List* L){
        printf("Вектор: ");
        ShowVec(&L->current->next->value);
}

void DelAftInd(List* L) {
    if (L->counter == 0) {
        printf("Список пуст!\n");
    }
    else {
        ListNode* del;
        del = (ListNode*)L->current->next;
        L->current->next = del->next;
        free(del);
        L->counter--;
        printf("Элемент удален!\n");
    }
}
void TakeAftInd(List* L) {
    if (L->counter == 0) {
        printf("Список пуст!\n");
    }
    else {
        ListNode* del;
        del = (ListNode*)L->current->next;
        printf("Вектор: ");
        ShowVec(&del->value);
        L->current->next = del->next;
        free(del);
        L->counter--;
        printf("Элемент удален!\n");
    }
}
void ChangeAftInd(List* L) {
    int val;
    if (L->counter == 0) {
        printf("Список пуст!\n");
    }
    else {
        VecStart(&L->current->value);
    }
}
void AddAftInd(List* L) {

        ListNode* str;
        if (L->counter == 0) {
            str = (ListNode*)malloc(sizeof(ListNode));
            alloc_check(str);
            str->value = { NULL,0 };
            L->first = str;
            L->current = str;
            L->Last = str;
            L->counter++;
        }
        else {
            str = (ListNode*)malloc(sizeof(ListNode));
            alloc_check(str);
            str->value = { NULL,0 };
            if (L->current == L->Last) {
                str->next = L->first;
                L->current->next = str;
                L->Last = str;
                L->counter++;
            }
            else {
                str->next = L->current->next;
                L->current->next = str;
                L->counter++;
            }

        }


}
void PrintList(List* L) {
    ListNode* pr = L->first;
    for (int i = 0;i<L->counter; i++) {
        ShowVec(&pr->value);
        pr = pr->next;
    }
}

void ListMenu(List *L)
{
    while (1) {
        int num;
        if (L->current == NULL) {
            printf("Указатель нулл!!!!!!!!!\n");
        }
        else { printf("Значение текущего указателя, указатель старт, указатель конец: %d, %d, %d, %d\n", L->current, L->first, L->Last, L->counter); }
        printf("= Обработка кольцевого списка =\n\
1. Сделать список пустым\n\
2. Пусто ли? \n\
3. Установить рабочий указатель в начало списка\n\
4. В конце ли списка рабочий указатель? \n\
5. Передвинуть рабочий указатель вперёд\n\
6. Посмотреть за указатель\n\
7. Удалить за указателем\n\
8. Взять элемент за указателем\n\
9. Изменить значение элемента списка за указателем\n\
10. Добавить за указатель.\n\
11. Распечатать\n\
12. Закончить работу\n");

        if (scanf_s("%d", &num) == 1) {
            switch (num)
            {

            case 1:
                system("cls");
                ListFree(L);
                printf("Список очищен!\n");

                break;
            case 2:
                system("cls");
                if (L->counter == 0) {
                    printf("Список пуст!\n");
                }
                else {
                    printf("Список не пуст\n");
                }

                break;
            case 3:
                system("cls");
                L->current = L->first;
                printf("Курсор установлен\n");

                break;
            case 4:
                system("cls");
                if (ListEmptyCheck(L)) break;
                if (L->current == L->Last) {
                    printf("Указатель на последнем элементе!\n");
                }
                else
                    printf("Указатель не на последнем элементе!\n");

                break;
            case 5:
                system("cls");
                if (ListEmptyCheck(L)) break;
                MoveIndFw(L);

                break;
            case 6:
                system("cls");
                if (ListEmptyCheck(L)) break;
                if (current_check(L)) break;
                LookAfterInd(L);

                break;
            case 7:
                system("cls");
                if (ListEmptyCheck(L)) break;
                if (current_check(L)) break;
                DelAftInd(L);

                break;
            case 8:
                system("cls");
                if (ListEmptyCheck(L)) break;
                if (current_check(L)) break;
                TakeAftInd(L);

                break;
            case 9:
                system("cls");
                if (ListEmptyCheck(L)) break;
                if (current_check(L)) break;
                ChangeAftInd(L);
                break;
            case 10:
                system("cls");
                AddAftInd(L);
                ChangeAftInd(L);
                printf("Элемент добавлен!\n");
                break;
            case 11:
                system("cls");
                PrintList(L);
                break;
            case 12:
                system("cls");
                ListFree(L);
                printf("Работа закончена\n");
                return;

            default:
                printf("Неправильное число!\n");

            }

        }
        else {
            clear_buff();
            printf("Неправильный символ!\n");
        }
    }

}

void ProgramStart(List* L) {
    int num = 0;
    while (1) {
        printf("1. Начать программу\n\
2. Выйти из программы\n");
        if (scanf_s("%d", &num) == 1) {
            switch (num) {
            case 1:
                system("cls");

                ListMenu(L);

                break;
            case 2:
                exit(1);
                break;

            default:
                printf("Неправильное число!\n");
            }
        }
        else {
            clear_buff();
            printf("Неправильный символ!\n");
        }
    }
}

int main() {
    setlocale(LC_ALL, "Russian");
    Vec V;
    List L;
    ProgramStart(&L);
}