Lab2 - Pb7

#include <iostream>

struct NOD
{
    int info;
    NOD* next;
};

struct LISTA
{
    NOD* FIRST = NULL, * LAST = NULL;
    int NR_ELEM = 0;

    void ADD_FIRST(int key)
    {
        NOD* x = new NOD;
        x->info = key;
        x->next = NULL;
        FIRST = x;
        LAST = x;
    }

    void PUSH_FRONT(int key)
    {
        if (EMPTY())
            ADD_FIRST(key);
        else
        {
            NOD* newFRONT = new NOD;
            newFRONT->info = key;
            newFRONT->next = FIRST;
            FIRST = newFRONT;
        }
        NR_ELEM++;
    }

    void PUSH_BACK(int key)
    {
        if (EMPTY())
            ADD_FIRST(key);
        else
        {
            NOD* newLAST = new NOD;
            newLAST->info = key;
            newLAST->next = NULL;
            LAST->next = newLAST;
            LAST = newLAST;
        }
        NR_ELEM++;
    }

    NOD* SEARCH(int key)
    {
        NOD* x = new NOD;
        x = FIRST;
        while (x != NULL && x->info != key)
            x = x->next;
        return x;
    }

    void ERASE(NOD* node)
    {
        if (node == FIRST)
            FIRST = FIRST->next;
        else
        {
            NOD* prevNode = new NOD;
            prevNode = FIRST;

            while (prevNode->next != node)
                prevNode = prevNode->next;
            prevNode->next = node->next;
        }
        delete node;
    }

    void ERASE(int key)
    {
        if (FIRST->info == key)
            FIRST = FIRST->next, NR_ELEM--;
        else
        {
            NOD* x = new NOD;
            x = SEARCH(key);
            if (x != NULL)
            {
                ERASE(x);
                NR_ELEM--;
            }
        }
    }

    bool EMPTY()
    {
        if (NR_ELEM == 0)
            return 1;
        return 0;
    }

    void ERASE_DOUBLES()
    {
        NOD* i = new NOD;
        NOD* copyDel = new NOD;
        i = FIRST;

        while (i->next != NULL)
        {
            if (i->info == i->next->info)
            {
                copyDel = i->next;
                ERASE(i->info);
                i = copyDel;
            }
            else
                i = i->next;
        }
    }

    void ERASE(LISTA L)
    {
        for (NOD* i = L.FIRST; i != NULL; i = i->next)
            if (SEARCH(i->info) != NULL)
                ERASE(i->info);
    }

    void CLEAR()
    {
        NOD* del = new NOD;
        del = FIRST;

        while (del->next != NULL)
        {
            NOD* copyDel = new NOD;
            copyDel = del->next;
            ERASE(del);
            del = copyDel;
        }
        if (!EMPTY())
            ERASE(del);

        NR_ELEM = 0;
    }

    void PRINT()
    {
        NOD* x = new NOD;
        x = FIRST;

        while (x != NULL)
        {
            std::cout << x->info << ' ';
            x = x->next;
        }
        std::cout << "\n";
    }

    // Inseram o noua cheie dupa un element node. Daca lista este goala sau elementul node nu se gaseste, atunci nu inseram elementul
    void INSERT(int key, NOD* node)
    {
        NOD* insert = new NOD;
        insert->info = key;
        insert->next = NULL;

        if (FIRST == node)
        {
            insert->next = FIRST;
            FIRST = insert;
        }
        else
        {
            insert->next = node->next;
            node->next = insert;
        }
        NR_ELEM++;
    }

    void SORT()
    {
        for (NOD* i = FIRST; i->next != NULL; i = i->next)
            for (NOD* j = i->next; j != NULL; j = j->next)
                if (i->info > j->info)
                    std::swap(i->info, j->info);
    }
};

int main()
{
    LISTA ListaPrincipala;

    std::cout << "-----Comenzi-----\n";
    std::cout << "1 pentru adaugare la inceputul listei\n";
    std::cout << "2 pentru adaugare la sfarsitul listei\n";
    std::cout << "3 pentru afisarea elementelor listei\n";
    std::cout << "4 pentru stergerea unui element\n";
    std::cout << "5 pentru a goli lista\n";
    std::cout << "6 pentru a insera o valoare dupa un element dat\n";
    std::cout << "7 pentru a elimina dublurile\n";
    std::cout << "8 pentru a elimina din lista elementele comune cu cele dintr-o alta lista\n";
    std::cout << "0 pentru a iesi din meniu\n\n";

    int comandaPrincipala = 0, key;
    do
    {
        std::cout << "Introduceti numarul comenzii: ";
        std::cin >> comandaPrincipala;

        if (ListaPrincipala.EMPTY() && comandaPrincipala >= 3)
        {
            if (comandaPrincipala == 5)
                std::cout << "  Lista era deja goala. \n";
            else
                if (comandaPrincipala >= 3 && comandaPrincipala <= 8)
                    std::cout << "  Lista este goala. \n";
        }
        else
            switch (comandaPrincipala)
            {
            case 1:
            {
                std::cout << "  Introduceti valoarea: ";
                std::cin >> key;
                ListaPrincipala.PUSH_FRONT(key);
                std::cout << "  Am adaugat valoarea " << key << " la inceputul listei. \n";
                break;
            }
            case 2:
            {
                std::cout << "  Introduceti valoarea: ";
                std::cin >> key;
                ListaPrincipala.PUSH_BACK(key);
                std::cout << "  Am adaugat valoarea " << key << " la sfarsitul listei. \n";
                break;
            }
            case 3:
            {
                std::cout << "  Elementele listei: ";
                ListaPrincipala.PRINT();
                break;
            }
            case 4:
            {
                std::cout << "  Introduceti valoarea pe care doriti sa o stergeti: ";
                std::cin >> key;
                if (ListaPrincipala.SEARCH(key) != NULL)
                {
                    ListaPrincipala.ERASE(key);
                    std::cout << "  Am eliminat " << key << " din lista. \n";
                }
                else
                    std::cout << "  Nu s-a gasit niciun element in lista cu cheia " << key << ". \n";
                break;
            }
            case 5:
            {
                ListaPrincipala.CLEAR();
                std::cout << "Am golit lista. \n";
                break;
            }
            case 6:
            {
                int element;
                std::cout << "  Introduceti valoarea de inserat si cheia elementului din lista dupa care dorim sa inseram: ";
                std::cin >> key >> element;
                if (ListaPrincipala.SEARCH(element))
                {
                    ListaPrincipala.INSERT(key, ListaPrincipala.SEARCH(element));
                    std::cout << "  Am introdus " << key << " in lista. \n";
                }
                else
                    std::cout << "  Nu exista elementul " << element << ". Nu am putut insera valoarea " << key << " in lista. \n";
                break;
            }
            case 7:
            {

                ListaPrincipala.SORT();
                ListaPrincipala.ERASE_DOUBLES();
                std::cout << "  Am sortat lista si am eliminat dublurile. \n";

                break;
            }
            case 8:
            {
                LISTA ListaSecundara;
                int dimensiune, comandaSecundara;
                std::cout << "  A doua lista: \n";
                std::cout << "  Introduceti numarul de elemente pe care le are lista: ";
                std::cin >> dimensiune;

                std::cout << "      1 pentru adaugarea la inceput\n";
                std::cout << "      2 pentru adaugarea la sfarsit\n";
                while (dimensiune)
                {
                    std::cout << "      Introduceti numarul comenzii si valoarea de introdus: ";
                    std::cin >> comandaSecundara >> key;
                    switch (comandaSecundara)
                    {
                    case 1:
                    {
                        ListaSecundara.PUSH_FRONT(key);
                        break;
                    }
                    case 2:
                    {
                        ListaSecundara.PUSH_BACK(key);
                        break;
                    }
                    }
                    dimensiune--;
                }
                std::cout << "  Lista secundara: ";
                ListaSecundara.PRINT();
                ListaPrincipala.ERASE(ListaSecundara);
                ListaSecundara.CLEAR();
                break;
            }
            }

        std::cout << "\n";
    } while (comandaPrincipala != 0);

    if (!ListaPrincipala.EMPTY())
        ListaPrincipala.CLEAR();

    return 0;
}