SHARE
TWEET

Untitled

a guest Dec 11th, 2019 85 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <iostream>
  2. #include <string>
  3. using namespace std;
  4. struct TListenKnoten
  5. {
  6.     TListenKnoten* prev;
  7.     int data;
  8.     TListenKnoten* next;
  9.  
  10. };
  11. void liste_loeschen(TListenKnoten*& anker) {
  12.  
  13.     TListenKnoten* ptr = anker;
  14.     TListenKnoten* prevptr = ptr;
  15.  
  16.     while (ptr != nullptr)
  17.     {
  18.         ptr = ptr->next;
  19.         delete prevptr;
  20.         prevptr = NULL;
  21.         ptr->prev = nullptr;
  22.         if (ptr->next==nullptr)
  23.         {
  24.             delete ptr;
  25.             ptr = NULL;
  26.         }
  27.     }
  28.     anker = nullptr;
  29.  
  30.  
  31. }
  32. void aus_liste_loeschen(TListenKnoten*& anker, int wert) {
  33.  
  34.     bool found = 0;
  35.     TListenKnoten* ptr = anker;
  36.  
  37.     while (ptr!=nullptr && !found)
  38.     {
  39.        
  40.         if (ptr->data==wert)
  41.         {
  42.             if (ptr->prev != nullptr)
  43.             {
  44.                 ptr->prev->next= ptr->next;
  45.             }
  46.             else if (ptr->next != nullptr)
  47.             {
  48.                 ptr->next->prev = nullptr;
  49.             }
  50.  
  51.             if (ptr->next != nullptr)
  52.             {
  53.                 ptr->next->prev = ptr->prev;
  54.             }
  55.             delete ptr;
  56.             ptr = NULL;
  57.         }
  58.         else
  59.         {
  60.             ptr = ptr->next;
  61.         }
  62.  
  63.     }
  64.  
  65. }
  66. void in_liste_einfuegen(TListenKnoten*& anker, int wert_neu, int vor_wert) {
  67.    
  68.     TListenKnoten* neuer_eintrag = new TListenKnoten;
  69.     bool found = 0;
  70.     neuer_eintrag->data = wert_neu;
  71.     if (anker == nullptr) {
  72.         anker = neuer_eintrag;
  73.         neuer_eintrag->prev = nullptr;
  74.         neuer_eintrag->next = nullptr;
  75.  
  76.     }
  77.     else
  78.     {
  79.         TListenKnoten* ptr = anker;
  80.         while (ptr->next != nullptr)
  81.         {
  82.             if (ptr->data==vor_wert)
  83.             {
  84.                 if (ptr->prev == nullptr)
  85.                 {
  86.                     neuer_eintrag->prev = nullptr;
  87.                     anker = neuer_eintrag;
  88.                 }
  89.                 else
  90.                 {
  91.                     neuer_eintrag->prev = ptr->prev;
  92.                     ptr->prev->next = neuer_eintrag;
  93.                 }
  94.                 found = 1;
  95.                 neuer_eintrag->next = ptr;
  96.                 ptr->prev = neuer_eintrag;
  97.             }
  98.             ptr = ptr->next;
  99.         }
  100.         if (ptr->next==nullptr && ptr->data == vor_wert)
  101.         {
  102.             found = 1;
  103.             neuer_eintrag->prev = ptr->prev;
  104.             ptr->prev->next = neuer_eintrag;
  105.             neuer_eintrag->next = ptr;
  106.             ptr->prev = neuer_eintrag;
  107.         }
  108.         if (found!=1)
  109.         {
  110.             neuer_eintrag->prev = ptr;
  111.             neuer_eintrag->next = nullptr;
  112.             ptr->next = neuer_eintrag;
  113.         }
  114.     }
  115.  
  116. }
  117. void liste_ausgeben_rueckwaerts(TListenKnoten* anker) {
  118.     string resultat = "";
  119.     if (anker == nullptr) {
  120.  
  121.         string resultat = "Leere Liste";
  122.         cout << resultat << endl;
  123.  
  124.     }
  125.     else
  126.     {
  127.         TListenKnoten* ptr = anker;
  128.         string resultat = "[";
  129.         while (ptr->next != nullptr)
  130.         {
  131.             ptr = ptr->next;
  132.         }
  133.  
  134.         do
  135.         {
  136.             resultat += std::to_string(ptr->data);
  137.             if (ptr->prev != nullptr) resultat += " , ";
  138.             else resultat += " ";
  139.             ptr = ptr->prev;
  140.         } while (ptr != nullptr);
  141.         resultat += "]";
  142.         cout << resultat << endl;
  143.     }
  144.  
  145.  
  146. }
  147. void hinten_anfuegen(TListenKnoten*& anker, const int wert)
  148. {
  149.     TListenKnoten* neuer_eintrag = new TListenKnoten;
  150.     neuer_eintrag->data = wert;
  151.     neuer_eintrag->next = nullptr;
  152.     if (anker == nullptr) {
  153.         anker = neuer_eintrag;
  154.         neuer_eintrag->prev = nullptr;
  155.  
  156.     }
  157.     else
  158.     {
  159.         TListenKnoten* ptr = anker;
  160.         while (ptr->next != nullptr)
  161.         {
  162.             ptr = ptr->next;
  163.         }
  164.         neuer_eintrag->prev = ptr;
  165.         ptr->next = neuer_eintrag;
  166.     }
  167. }
  168. string liste_als_string(TListenKnoten* anker)
  169. {
  170.     string resultat = "";
  171.     if (anker == nullptr)
  172.         return "Leere Liste.";
  173.     else
  174.     {
  175.         resultat += "[ ";
  176.         TListenKnoten* ptr = anker;
  177.         do
  178.         {
  179.             resultat += std::to_string(ptr->data);
  180.             if (ptr->next != nullptr) resultat += " , ";
  181.             else resultat += " ";
  182.             ptr = ptr->next;
  183.         } while (ptr != nullptr);
  184.         resultat += "]";
  185.     }
  186.     return resultat;
  187. }
  188. void liste_ausgeben(TListenKnoten* anker)
  189. {
  190.     cout << liste_als_string(anker) << endl;
  191. }
  192. int main()
  193. {
  194.     const int laenge = 10;
  195.     TListenKnoten* anker = nullptr;
  196.     liste_ausgeben(anker);
  197.     liste_ausgeben_rueckwaerts(anker);
  198.     liste_loeschen(anker);
  199.     hinten_anfuegen(anker, 77);
  200.     hinten_anfuegen(anker, 88);
  201.     hinten_anfuegen(anker, 99);
  202.     liste_ausgeben(anker);
  203.     liste_ausgeben_rueckwaerts(anker);
  204.     liste_loeschen(anker); // war: aus_liste_loeschen(anker, 99);
  205.     liste_ausgeben(anker);
  206.     liste_ausgeben_rueckwaerts(anker);
  207.     for (int i = 0; i < laenge; i++)
  208.         in_liste_einfuegen(anker, i * i, 9999);
  209.     liste_ausgeben(anker);
  210.     liste_ausgeben_rueckwaerts(anker);
  211.     in_liste_einfuegen(anker, -1, 0);
  212.     in_liste_einfuegen(anker, 24, 25);
  213.     in_liste_einfuegen(anker, 80, 81);
  214.     in_liste_einfuegen(anker, 99, 9999);
  215.     liste_ausgeben(anker);
  216.     liste_ausgeben_rueckwaerts(anker);
  217.     aus_liste_loeschen(anker, 24);
  218.     aus_liste_loeschen(anker, 80);
  219.     liste_ausgeben(anker);
  220.     liste_ausgeben_rueckwaerts(anker);
  221.     liste_loeschen(anker);
  222.     liste_ausgeben(anker);
  223.     liste_ausgeben_rueckwaerts(anker);
  224.     system("PAUSE");
  225.     return 0;
  226. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!
 
Top