Untitled

#include <iostream>
using namespace std;


struct node
{
    node * next;
    int val;
};
bool isEmpty(node*head)
{
    return !head;
}

void addFrontList(node *&head, int v)
{
    node * s = new node;
    s->next = head;
    s->val = v;
    head = s;
}

void removeFrontList(node *&head)
{
    if (isEmpty(head))
    {
        cout << "List is Empty!!" << endl;
        return;
    }
    else
    {
        node * s = head;
        head = head->next;
        delete s;
    }
}

void showList(node *&head)
{
    node * s = head;
    while (s)
    {
        cout << s->val << " ";
        s = s->next;
    }
    cout << endl << endl;
}

void mergeLists(node *&head1,node*&head2)
{
    node * s = head1;
    while (s->next)
    {
        s = s->next;
    }
    s->next = head2;
}

void switchFirstLast(node *&head)
{
    node * s = head;
    if (isEmpty(head))
    {
        cout << "stack is empty!" << endl;
        return;
    }
    if (s->next == nullptr)
    {
        cout << "can't switch only 1 element!" << endl;
        return;
    }
    if (s->next->next == nullptr)
    {

        node * x = s->next;
        x->next = s;
        s->next = nullptr;
        head = x;
    }
    else
    {
        while (s->next->next)
        {
            s = s->next;
        }
        node * x = s->next;
        x->next = head->next;
        s->next = head;
        head->next = nullptr;
        head = x;

    }
}

void switchXToNext(node *&head,int v)
{

    node * s = head;
    if (isEmpty(head))
    {
        cout << "list is empty!" << endl;
        return;
    }
    if(s->next == nullptr)
    {
        cout << "only one element!" << endl;
        return;
    }
    if (s->next->next == nullptr && s->val == v)
    {
        node * x = s->next;
        s->next = nullptr;
        x->next = s;
        head = x;
        return;
    }

    while (s->next->next)
    {
        if (s->val == v && s == head)
        {
            node * x = s->next;
            s->next = x->next;
            x->next = s;
            head = x;


        }

    if (s->next->val == v)
        {

            node * x = s->next;
            s->next = s->next->next;
            if (s->next->next == nullptr)
            {
                s->next->next = x;
                x->next = nullptr;
                return;
            }
            else
            {
                x->next = s->next->next;
            }
            s->next->next = x;
            s = s->next;
        }
     s = s->next;
    }
}

void switchXToPrev(node*&head, int v)
{
    node * s = head;
    if (isEmpty(head))
    {
        cout << "list is Empty!" << endl;
        return;
    }
    if (s->next == nullptr)
    {
        cout << "only one element!" << endl;
        return;
    }
    if (s->next->val == v & s==head)
    {
        node * x = s->next;
        if (s->next->next == nullptr)
        {
            s->next = nullptr;
            x->next = s;
            head = x;
            return;
        }
        else
        {
            s->next = s->next->next;
            x->next = s;
            head = x;
        }

    }

    while (s->next->next)
    {


        if (s->next->next->val == v)
        {
            node * x = s->next;
            s->next = s->next->next;
            if (s->next->next == nullptr)
            {
                x->next = nullptr;
                s->next->next = x;
                return;
            }
            else
            {
                x->next = s->next->next;
                s->next->next = x;
            }

        }
        s = s->next;
    }

}

void deleteEverySecond(node*head)
{
    if (isEmpty(head))
    {
        cout << "list is Empty!" << endl;
    }
    node * s = head;
    while (s->next)
    {
        node * x = s->next;
        if (s->next->next == nullptr)
        {
            s->next = nullptr;
            delete x;
            return;
        }
        else
        {
            s->next = x->next;
            delete x;
            s = s->next;
        }
    }
}

void deleteEveryThird(node *head)
{


    node * s = head;
    if (isEmpty(head))
    {
        cout << "list is empty!" << endl;
    }
    else
    {
        while (s->next->next)
        {
            node * x = s->next->next;
            if (s->next->next->next == nullptr)
            {
                s->next->next = nullptr;
                delete x;
                return;
            }
            else
            {
                s->next->next = x->next;
                s = s->next->next;
                delete x;
            }
        }
    }
}

void deleteNAfterX(node *head, int N, int X)
{
    if (isEmpty(head))
    {
        cout << "list is empty!" << endl;
        return;
    }
    else
    {
        node * s = head;
        int tmp = N;
        if (s->next == nullptr)
        {
            cout << "only one element!" << endl;
            return;
        }
        while (s->next)

        {
            if (s->val == X)
        {
                while (tmp)
                {
                    if (s->next == nullptr)
                    {
                        return;
                    }
                    else
                    {
                        node * x = s->next;
                        if (s->next->next == nullptr)
                        {
                            s->next = nullptr;
                            delete x;
                            return;
                        }
                        else
                        {
                            s->next = s->next->next;
                            delete x;
                        }

                    }

                    tmp--;
                }


        }
            s = s->next;
        }
    }
}

void reverseList(node *&head)
{
    if (isEmpty(head))
    {
        cout << "list is Empty!" << endl;
        return;
    }
    else
    {
        node * p = head;

        while (p->next)
        {
            node * x = p->next;
            p->next = x->next;
            x->next = head;
            head = x;

        }
    }
}

void copyListAfter(node *head)
{
    if (isEmpty(head))
    {
        cout << "stack is Empty!" << endl;
    }
    else
    {
        node * s = head;
        node * pointer = head;
        while (s->next)
        {
            s = s->next;
        }
        node * stop = s;
        if (pointer == stop)
        {
            node * element = new node;
            element->next = nullptr;
            element->val = pointer->val;
            s->next = element;
            s = s->next;
        }
        while (pointer)
        {
            node * element = new node;
            element->next = nullptr;
            element->val = pointer->val;
            s->next = element;
            s = s->next;
            if (pointer == stop) return;
            else pointer = pointer->next;
        }


    }
}

void copyAfterXtimesX(node *head)
{
    node * s = head;

    while (s)
    {
        int tmp = (s->val)-1;


            {
                if (s->next == nullptr)
                {
                    while (tmp)
                    {
                        node * elem = new node;
                        elem->next = nullptr;
                        elem->val = s->val;
                        s->next = elem;
                        s = s->next;
                        tmp--;

                    }
                    return;
                }
                else
                {
                    while (tmp)
                    {

                        node * elem = new node;
                        elem->next = s->next;
                        elem->val = s->val;
                        s->next = elem;
                        s = s->next;
                        tmp--;
                    }

                }
            s = s->next;
            }


    }

}

void insertSort(node *&head,int v)
{

        node * s = head;
        node * elem = nullptr;
        if (s == nullptr)
        {
            elem = new node;
            elem->val = v;
            elem->next = nullptr;
            s = elem;
            head = s;
            return;
        }

        else if (s->next == nullptr)
        {
            elem = new node;
            elem->val = v;
            if (v > s->val)
            {
                s->next = elem;
                elem->next = nullptr;
                return;
            }
            if (v < s->val)
            {
                elem->next = s;
                head = elem;
                return;
            }

        }

        if (s == head && v < s->val)
        {
            elem = new node;
            elem->next = s;
            elem->val = v;
            head = elem;
            return;
        }
            while (s->next)
            {
                if (s->val<v && s->next->val>v)
                {
                    elem = new node;
                    elem->val = v;
                    node * x = s->next;
                    s->next = elem;
                    elem->next = x;
                    return;


                }
            s=s->next;
            }
            elem = new node;
            elem->val = v;
            s->next = elem;
            elem->next = nullptr;
            return;

        }

void bubbleSort(node *&head)
{

}


int main()
{
node * head1 = nullptr;

addFrontList(head1, 6); // bubblesort
addFrontList(head1, 7);
addFrontList(head1, 1);
addFrontList(head1, 8);
addFrontList(head1, 5);
showList(head1);


/*insertSort(head1, 4); //insertsort
insertSort(head1, 5);
insertSort(head1, 6);
insertSort(head1, 3);
insertSort(head1, 2);
showList(head1);*/


/*addFrontList(head1, 5); // dla pracy na listach
addFrontList(head1, 4);
addFrontList(head1, 3);
addFrontList(head1, 2);
addFrontList(head1, 2);
showList(head1);*/

/*copyAfterXtimesX(head1);
showList(head1);*/

/*copyListAfter(head1);
showList(head1);*/

/*reverseList(head1);
showList(head1);*/

/*deleteNAfterX(head1, 2, 5);
showList(head1);*/

/*deleteEveryThird(head1);
showList(head1);*/


/*deleteEverySecond(head1);
showList(head1);*/

/*switchXToPrev(head1,5);
showList(head1);*/

/*switchXToNext(head1, 2);
showList(head1);*/

/*switchFirstLast(head1);
showList(head1);*/

/*node* head2 = NULL;
addFrontList(head2, 10);
addFrontList(head2, 9);
addFrontList(head2, 8);
addFrontList(head2, 7);
addFrontList(head2, 6);
showList(head2);

mergeStacks(head1, head2);
showList(head1);*/
system("pause");
return 0;
}