
class List
{
  public:
     void move(List& other);
};


void List::move(List& other)
{
    while (other.first != nullptr)
    {
        Item* a = other.first;
        other.unlink(other.first);
        insertLast(a);
    }
}


    List b;
    b.move(seznam);

    seznam.print();
    b.print();


#include 
#include "assert.h"
using namespace std;

class Item;

class List
{
private:
    Item* first;
    Item* last;

public:
    Item* getFirst() { return first; }
    Item* getLast() { return last; }

private:
    void link(Item* before, Item* fresh, Item* after);

public:
    void insertFirst(Item* fresh);
    void insertLast(Item* fresh);

    void insertBefore(Item* target, Item* fresh);
    void insertAfter(Item* target, Item* fresh);

    void unlink(Item* elem);
    void remove(Item* elem);

    Item* find(string name0);
    Item* get(int inx);
    void print();

    void move(List& other);
    void reverse();

    void add(string name0);
    void add(Item* elem);
    void sort();

    List();
    ~List();
};

class Item
{
public:
    string name;

private:
    Item* prev;
    Item* next;
    // List* up;

public:
    Item* getPrev() { return prev; }
    Item* getNext() { return next; }

    Item(string name0);

    friend class List;
};

List::List() :
    first(nullptr),
    last(nullptr)
{
}

List :: ~List()
{
    while (first != nullptr)
    {
        remove(first);
    }
}

Item::Item(string name0) :
    name(name0),
    prev(nullptr),
    next(nullptr)
{
}

void List::link(Item* before, Item* fresh, Item* after)
// a - seznam do ktereho vkladame
// fresh - nove vkladany prvek (musi existovat, nesmi byt v zadnem seznamu)
// before - ukazatel na predchozi prvek ( before == nullptr => fresh bude prvni)
// after - ukazatel na nasledujici prvek ( after == nullptr => fresh bude posledni)
{
    fresh->prev = before;
    fresh->next = after;

    if (before != nullptr)
        before->next = fresh; // nekdo je pred
    else
        first = fresh; // jsme prvni

    if (after != nullptr)
        after->prev = fresh;
    else
        last = fresh;
}

void List::insertFirst(Item* fresh)
{
    link(nullptr, fresh, first);
}

void List::insertLast(Item* fresh)
{
    link(last, fresh, nullptr);
}

void List::insertBefore(Item* target, Item* fresh)
{
    assert(target != nullptr);
    // assert(target->up == this);
    link(target->prev, fresh, target);
}

void List::insertAfter(Item* target, Item* fresh)
{
    assert(target != nullptr);
    link(target, fresh, target->next);
}

void List::unlink(Item* elem)
{
    if (elem != nullptr)
    {
        Item* before = elem->prev;
        Item* after = elem->next;

        if (before != nullptr)
            before->next = after;
        else
            first = after;

        if (after != nullptr)
            after->prev = before;
        else
            last = before;

        elem->prev = nullptr;
        elem->next = nullptr;
    }
}

void List::remove(Item* elem)
{
    if (elem != nullptr)
    {
        unlink(elem);
        delete elem;
    }
}

Item* List::get(int inx) // inx == 0, prvni prvek
{
    Item* p = first;
    while (inx > 0 && p != nullptr) {
        inx--;
        p = p->next;
    }
    return p;
}

Item* List::find(string name0)
{
    Item* p = first;
    while (p != nullptr && p->name != name0)
    {
        p = p->next;
    }
    return p;
}

void List::print()
{
    Item* p = first;
    if (p == nullptr)
    {
        cout << "seznam je prazdny" << endl;
    }
    while (p != nullptr)
    {
        cout << p->name << endl;
        p = p->next;
    }
    cout << endl;
}

void List::move(List& other)
// a.move (b); ... presunout prvky ze seznamu b do seznamu a
{
    while (other.first != nullptr)
    {
        Item* a = other.first;
        other.unlink(other.first);
        insertLast(a);
    }
}

void List::reverse()
{
    List other;
    other.move(*this);
    while (other.first != nullptr)
    {
        Item* a = other.first;
        other.unlink(other.first);
        insertFirst(a);
    }

    /*
    Item* p = other.first;
    while (p != nullptr)
    {
        Item * t = p->next;
        other.unlink(p);
        insertFirst (p);
        p = t;
    }
    */
}

void List::add(string name0)
{
    Item* p = first;
    while (p != nullptr && p->name <= name0) p = p->next;
    if (p == nullptr)
        insertLast(new Item(name0));
    else
        insertBefore(p, new Item(name0));
}

/*
void List::add(string name0)
{
    Item* p = new Item(name0);
    add(p);
}
*/

void List::add(Item * elem)
{
    Item* p = first;
    while (p != nullptr && p->name <= elem->name) p = p->next;
    if (p == nullptr)
        insertLast(elem);
    else
        insertBefore(p, elem);
}

void List::sort ()
{
    List other;
    other.move(*this);

    Item* p = other.first;
    while (p != nullptr)
    {
        Item* t = p->next;
        other.unlink(p);
        add (p);
        p = t;
    }

    /*
    Item* p = other.first;
    while (p != nullptr)
    {
        add (p->name);
        p = p->next;
    }
    */
}

List seznam;

int main()
{
    seznam.insertFirst(new Item("cervena"));
    seznam.insertLast(new Item("zelena"));
    seznam.insertBefore(seznam.getLast(), new Item("oranzova"));

    Item* t = seznam.get(1); // index 1 ... druhy prvek
    if (t != nullptr)
        seznam.insertAfter(t, new Item("modra"));

    Item* m = seznam.find("modra");
    if (m != nullptr)
        seznam.insertBefore(m, new Item("zluta"));

    seznam.print();

    List b;
    b.move(seznam);

    seznam.print();
    b.print();

    b.reverse();
    b.print();

    b.sort();
    b.print();
}