include - Informatik

#include <iostream>
using namespace std;
//"eigentlich ist ein struct eine Klasse mit nur oeffentlichen members"
struct knoten {
int info;
knoten* next;
knoten (int = 0, knoten* = NULL);
~knoten();
};
knoten::knoten(int n_info, knoten* n_next)
{
info = n_info; next = n_next;
}
knoten::~knoten()
{
if (next != NULL)
{ delete next; }
}
class zListe {
public:
knoten* start;
zListe();
~zListe();
knoten* empty();
bool isempty();
void insert_first (int neue_info);
void insert_last (int neue_info);
void insert_after (int elem_num,int neue_info); //elem_num - nummer des Elem.,
//nach dem eingef. wird
void delete_knoten (int del_info);
void invert();
//die liste umdrehen
int get (int ser_info); //gibt die Position des gesuchten Elements zurueck
void output();
};
zListe::zListe() { start = empty(); }
zListe::~zListe()
{
if (start != NULL)
{
knoten* p1 = start;
while (p1->next != start) { p1 = p1->next; }
p1->next = NULL;
delete start;
}
}
knoten* zListe::empty() { return NULL; }
bool zListe::isempty() { return (start == NULL); }
void zListe::insert_first (int neue_info)
{
knoten* neues_elem = new knoten (neue_info, start);
if (!isempty())
{
while (start->next != neues_elem->next)
{ start = start->next; }
start->next = neues_elem;
start = neues_elem;
}
else
{
start = neues_elem; //das 1. Element in die Liste einfuegen
start->next = start; //und dessen next auf sich selbst zeigen lassen
}
}
void zListe::insert_last (int neue_info)
{
knoten* neues_elem = new knoten (neue_info, start); //das neue Element
knoten* p1 = start;
if (!isempty())
{
while (p1->next != start)
{ p1 = p1->next; }
p1->next = neues_elem;
}
else
{
start = neues_elem; //das 1. Element wie oben
start->next = start;
}
}
void zListe::insert_after (int elem_num,int neue_info)
{
knoten* neues_elem;
knoten* p1 = start;
int zaehler = 1;
if ((!isempty()) && (elem_num > 0))
{
if (elem_num > 1)
{
p1 = p1->next;
zaehler++;
while ((zaehler < elem_num) && (p1 != start))
{ zaehler++; p1 = p1->next; }
}
neues_elem = new knoten (neue_info, p1->next);
p1->next = neues_elem;
}
else
{
if (isempty())
{
neues_elem = new knoten (neue_info);
neues_elem->next = neues_elem;
start = neues_elem;
}
}
}
void zListe::delete_knoten (int del_info)
{
knoten* p1 = start;
if (!isempty())
{
while ((p1->next != start) && (p1->next->info != del_info))
{ p1 = p1->next; }
if (p1->next->info == del_info)
{
knoten* p2 = p1->next->next;
if (p1->next == start) { start = p2; }
p1->next->next = NULL;
if (p1->next == NULL)
{
delete p1->next;
start = NULL; //wieder eine leere Liste
}
else { p1->next = p2; }
}
}
}
void zListe::invert()
{
if (!isempty()) //keine leer Liste bearbeiten
{
//p1 sichert start->next
//p2 sucht das letzte element
//p3 sichert den Alten kopf als Bezugspunkt
knoten* p1 = start->next,* p2 = p1,*p3 = start;
if (p2 != start)
//nur weiterm., wenn mehr als 1 Elem.
{
while (p2->next != p3) { p2 = p2->next; } //letztes Elem. suchen
p3->next = p2; //umdrehen des next-z. des 1. Elements
while (p1 != p3)
//solange, bis p1, wieder am anfang ist
{
p2 = p1;
p1 = p1->next;
p2->next = start;
start = p2;
}
}
}
}
void zListe::output()
{
knoten* p1 = start;
if (!isempty())
{
cout << " -> " << p1->info;
p1 = p1->next; //das 1. el. separat
while (p1 != start)
{
cout << " -> " << p1->info;
p1 = p1->next;
}
cout << " -> START ";
}
else
{
cout << " -> NIL";
}
}
int zListe::get (int ser_info)
{
knoten* p1 = start;
int zaehler = 0;
bool gefunden = false;
if (!isempty())
{
zaehler++;
//der zaehler ist mindestens 1;
if (p1->info != ser_info) //wenn es nicht das 1. Element ist
{
p1 = p1->next;
//p1 weitersetzen
while ((p1 != start) && (!gefunden))
{
if (p1->info == ser_info) {gefunden = true; }
zaehler++;
p1 = p1->next;
}
}
else { gefunden = true; } //hier ist das ges. Element an 1. stelle
}
if (gefunden) { return zaehler; } //wenn wirs gefunden haben, zaehler zur.
else { return 0; }
//ansonsten 0
}
main()
{
zListe meine_zListe;
int
element, pos;
char
Auswahl
= '1';
//dies ist meine zirkulaere Liste
//wird zum einfuegen und loeschen benutzt
//Variable, um das Progr. zu steuern
do
{ //Darstellung eines kleinen Menues
cout << "\n1. Element an Listenanfang einfügen";
cout << "\n2. Element an Listenende einfügen";
cout << "\n3. Element nach bestimmtem Element einfügen";
cout << "\n4. Element aus Liste löschen";
cout << "\n5. Position eines Elementes ermitteln";
cout << "\n6. Liste invertieren";
cout << "\nq Programm beenden";
cout << "\n\nWahl:";
cin >> Auswahl;
//eingeben der Auswahl
switch (Auswahl)
{
case '1': {
cout << "\nElementwert:";
cin >> element;
meine_zListe.insert_first
break;
//Meldung ausgeben
//Wert eingeben und -fuegen
(element);
//Sprung zum Ende von Switch
}
case '2': {
cout << "\nElementwert:"; //Meldung ausgeben
cin >> element;
//Wert eingeben und -fuegen
meine_zListe.insert_last (element);
break;
//Sprung zum Ende von Switch
}
case '3': {
cout << "\nElementwert:"; //Meldung ausgeben
cin >> element;
//Wert eingeben und -fuegen
cout << "\nPosition:"; //Meldung ausgeben
cin >> element;
//Wert eingeben und -fuegen
if ((pos - 1) == 0)
{
cout << "Um am Anfang der Liste einzufügen, ";
cout << "bitte entspr. Menüpkt wählen !";
}
else
{ meine_zListe.insert_after (pos - 1, element); }
break;
//Sprung zum Ende von Switch
}
case '4': {
cout << "\nzu löschender Wert:";
cin >> element;
meine_zListe.delete_knoten (element);
break;
}
case '5': {
cout << "\nElementwert:"; //Meldung ausgeben
cin >> element;
//Wert eingeben und -fuegen
pos = meine_zListe.get (element);
cout << "\nDie Position der " << element << " ist " << pos
<< '.';
break;
}
case '6': { //Liste invertieren
meine_zListe.invert();
break;
}
};
cout << "\nInhalt der Liste\n"; //zum Ende der "großen repeat-Schleife
meine_zListe.output(); //wird die aktuelle Liste immer ausgegeben
cout << '\n';
}
while (Auswahl != 'q');
return 0;
}