// ConsoleApplication6.cpp : Этот файл содержит функцию "main". Здесь начинается и заканчивается выполнение программы.
//
#include <iostream>

struct mystruct {
    int x;
    mystruct* Next;

};

void insert(mystruct* item, int index, int  value) {
    mystruct* Current = item;
    int i = 1;
    while (!(Current->Next == item || i == index)) {
        Current = Current->Next;
        i++;
    } 
    
    mystruct* Newitem = new mystruct;
    Newitem->x = value;
    Newitem->Next = Current->Next;
    Current->Next = Newitem;


    std::cout << i<< std::endl;

}

mystruct* deleteitem(mystruct* item, int x) {//ищет в кольце все значения равные x и удаляет их
    mystruct* Nextitem = item;
    mystruct* Currentitem = item;
    

    Nextitem = item;
    //delete(Currentitem);
    int size = sizeof(item);

    if (Currentitem->x == x && Currentitem == item)
        //значит элемент по счету номер 1 надо удалить
        //для этого найдем второй элемент
        //и последний, в последнем сделаем ссылку на первый
        //а первый отвяжем у далим.
    {
        mystruct* DelItem = nullptr;
        mystruct* Last = item;
        Nextitem = Currentitem->Next;
        do {
            Last = Last->Next;
        } while (Last->Next != item);
        Last->Next = Nextitem;
        DelItem = Currentitem;
        delete DelItem; //вот такой костыль я придумал чтобы удалить из кучи мой объект.
        Currentitem = Nextitem;
        Currentitem = deleteitem(Currentitem, x);//пойдем дальше удалять рекурсивно вдруг
        // и элемент номер 2 искомый и его тоже надо удалить
    }

    else { // значит искомые элемент стоит не сначала кольца
        mystruct* Postitem = 0;
        do {
            mystruct* NextNextitem = item;

            Nextitem = Currentitem->Next;
            NextNextitem = Nextitem->Next;

            if (Nextitem->x == x) {
                Currentitem->Next = NextNextitem;
                delete Nextitem;

            }
            else { //delete Currentitem; 
            Currentitem = Currentitem->Next; }




        } while (Currentitem->Next != item);
        Currentitem = item;
    }
    return Currentitem;
};
int main()
{
    mystruct* item = new mystruct;
    mystruct* first = item;
    mystruct* Nextitem = item;
    bool iffirst = true;
    item->x = 0;
    int input = 0;
    //считываем в цикле числа, помещая их в кольцао, до тех пор пока не будет введено 0. тогда цикл завершаем.
    //проще алгоритма чтобы было всё четко я не додумал. :(
    do {

        std::cin >> input;
        if (iffirst && input != 0) { item->x = input; iffirst = false; }
        else {
            if (input != 0) {
                Nextitem = Nextitem->Next = new mystruct;
                Nextitem->x = input;
            }
            else Nextitem->Next = first;
        }
    } while (input != 0);



    std::cout << std::endl;

    item = deleteitem(item, 5);

    //insert(item, 2,555);

    Nextitem = item;
    //вывод кольца . цикл завершается только крестиком в окне, ведь это кольцо, 
    //а оно бесконечно, можно было бы и завершить по желанию , но не в этом суть :)
    do {
        std::cout << Nextitem->x << std::endl;
        Nextitem = Nextitem->Next;
        system("pause");
    } while (true);

    
    


}

       DelItem = Currentitem;
       delete DelItem; 

struct mystruct {
    int x;
    mystruct* Next;

};

// ConsoleApplication6.cpp : Этот файл содержит функцию "main". Здесь начинается и заканчивается выполнение программы.
//
#include <iostream>
#include <conio.h>

#ifdef _DEBUG
#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>
#define DEBUG_NEW new(_NORMAL_BLOCK, __FILE__, __LINE__)
#define new DEBUG_NEW
#endif

const int KEY_ESC = 27;

struct mystruct {
    int x;
    mystruct* Next;

};

mystruct* insert(mystruct* item, int index, int  value) {
// по сути процедура абсурдна так как индекс для элемента кольца это что-то нелепое
// но грубо говоря будем считать , что индекс это порядковый номер их занесения в кольцо.

    if (item == nullptr) // если кольцо пустое , тогда индекс не имеет значения вставляем первым да и всё
    {
        
        item = new mystruct;
        item->x = value;
        item->Next = item;
        std::cout << "The ring was empty. Was added one element x="<<value << std::endl << std::endl;
        return item;
    } 
    
        
    
    if (index == 0) {//если хотим "в начало" кольца вставить новый элемент
        
        mystruct* Last = item;
        while (Last->Next != item)  Last = Last->Next;  //посчитаем последний элемент
        mystruct* Newitem = new mystruct;
        Last->Next = Newitem;
        Newitem->x = value;
        Newitem->Next = item;
        item = Newitem;
        std::cout << "Was added one element x="<<value <<" at first place " << std::endl << std::endl;
        return item;
    }
    
        int i = 1;
        mystruct* Current = item;
        while (!(Current->Next == item || i == index)) {
            Current = Current->Next;
            i++;
        }

        mystruct* Newitem = new mystruct;
        Newitem->x = value;
        Newitem->Next = Current->Next;
        Current->Next = Newitem;
        std::cout << "Was added one element x="<< value<< " after element #"<<index << std::endl << std::endl;
        return item;
    
    
    //std::cout << i<< std::endl;

}

mystruct* deleteitem(mystruct* Item,  int x) {//ищет в кольце все значения равные x и удаляет их

    mystruct* second;
    mystruct* Last=Item;
    mystruct* del;
    if (Item != nullptr ) // если кольцо не пустое , то будем работать
    {
        while (Last->Next != Item)  Last = Last->Next;  //посчитаем последний элемент

    //если первый же элемент кольца наш искомый
    while (Item->x == x)
    {
        //нужно найти второй элемент 
        //и последний
        //приравниваем к последнему next = указатель на второй элемент.
        //висящий первый элемент удаляем delete
        if (Item->Next == Item && Item->x == x) return nullptr;// Если кольцо из одного элемента и этот элемент надо удалить, то сразу nullptr
        second = Item->Next;
        Last->Next= second;
        delete Item;
        Item = second;
        

    }
    }
    if (Item != nullptr) //если наше кольцо не пустое , то посмотрим наличие элемента далее.
    {
        mystruct* Next = Item;
        do
        {
            if (Next->Next->x == x) {
                del = Next->Next;  
                Next->Next = Next->Next->Next; delete del;
            } else 
            Next = Next->Next;
        } while (Next->Next != Item);
    }

    std::cout << "Was deleted all elements equal " << x<< std::endl << std::endl;
    return Item;
};

mystruct* initring(mystruct* item) {//функция заполняет кольцо элементами

mystruct* first = item;
mystruct* Nextitem = item;
mystruct* last = item;

bool iffirst = true;
item->x = 0;
int input = 0;
int count = 0;
//считываем в цикле числа, помещая их в кольцао, до тех пор пока не будет введено 0. тогда цикл завершаем.

std::cout << "Enter ring. Enter 0 for finish " << std::endl << std::endl;
do {

    std::cout << "Enter element of ring ";  std::cin >> input;
    if (iffirst && input != 0) { item->x = input; iffirst = false; }
    else {
        if (input != 0) {
            Nextitem = Nextitem->Next = new mystruct;
            Nextitem->x = input;
            count++;
        }
        else { Nextitem->Next = first; last = Nextitem; }
    }
} while (input != 0);

if (count == 0) { item = nullptr; }
return item;
}
void printRing (mystruct*  item)
{
    mystruct*  Nextitem = item;
//вывод кольца . выводит по одному элементу . завершаем вывод клавишей Esc, а то так будет бесконечно выводить :)
    std::cout << "It's printing ring. Press Enter for next elements and Esc for finish "<< std::endl ;
char l;
if (item != nullptr) {
    do {
        std::cout << Nextitem->x << " " ;
        Nextitem = Nextitem->Next;

    } while (_getch() != KEY_ESC);
    std::cout << std::endl << std::endl;
}
else std::cout << "Ring is empty" <<std::endl << std::endl;
}

int main()
{
    mystruct* item = new mystruct;
    item = initring(item); //инициализация. ввод элементов кольца.

    std::cout << std::endl;
    printRing(item); //выводим кольцо
    item = insert(item, 0, 5);//вставляем в начало элемент равный 5
    printRing(item); //выводим кольцо
    item = insert(item, 1, 80);//вставляем после элемента №1 элемент равный 80
    printRing(item); //выводим кольцо
    item = insert(item, 0, 5);//вставляем в начало элемент равный 5
    printRing(item); //выводим кольцо
    item = insert(item, 2, 90);//вставляем после элемента №2 элемент равный 90
    printRing(item); //выводим кольцо
    item = insert(item, 4, 74);//вставляем после элемента №3 элемент равный 74
    printRing(item);//выводим кольцо

    item = deleteitem(item, 5);//ищем элементы равные 5 и удаяем их
    printRing(item);//выводим кольцо
 
#ifdef _DEBUG
    _CrtDumpMemoryLeaks();
#endif 
}