Advertisement
Guest User

Untitled

a guest
Dec 11th, 2019
195
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 4.50 KB | None | 0 0
  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. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement