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 <iostream>
#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();
}