double linked list

#include <iostream>
#include <string>
using namespace std;

struct TListenKnoten
{
	int data;
	TListenKnoten* next, * prev;
};


void hinten_anfuegen(TListenKnoten*& anker, const int wert)
{
	TListenKnoten* neuer_eintrag = new TListenKnoten;
	neuer_eintrag->data = wert;
	neuer_eintrag->next = nullptr;
	neuer_eintrag->prev = nullptr;
	if (anker == nullptr)
		anker = neuer_eintrag;
	else
	{
		TListenKnoten* ptr = anker;
		while (ptr->next != nullptr)
		{
			ptr = ptr->next;
		}
		neuer_eintrag->prev = ptr;
		ptr->next = neuer_eintrag;
	}
}
//wert_neu in die Liste einfügt, und zwar vor der Stelle des ersten Vorkommens des Wertes vor_wert
//Sollte der Wert vor_wert nicht in der Liste vorkommen, so soll wert_neu ans Ende der Liste angehängt werden.
//Die Funktion in_liste_einfuegen() soll auch in der Lage sein, einen Wert in eine bisher leere Liste einzufügen.
void in_liste_einfuegen(TListenKnoten*& anker, int wert_neu, int vor_wert)
{
	//tao mot Knote moi voi data = wert_neu
	TListenKnoten* neuer_eintrag = new TListenKnoten;
	neuer_eintrag->data = wert_neu;
	neuer_eintrag->next = nullptr;
	neuer_eintrag->prev = nullptr;
	//neu liste rong, anker = nullptr, anker veraendert.
	//neu liste khong rong, kiem tra xem co ton tai vor_wert khong
	//neu vor_wert khong ton tai, them vao hinten
	//neu vor_wert ton tai, kiem tra vi tri cua pointer
	//pointer = anker, them neuer_eintrag vorne, chuyen anker chi vao pointer
	//pointer khac anker, neuer ein trag vao giua.
	if (anker == nullptr) //liste ist leer
	{
		anker = neuer_eintrag;
	}
	else
	{
		TListenKnoten* ptr = anker;
		for (ptr = anker; (ptr->data != vor_wert) && (ptr->next != nullptr); ptr = ptr->next)
		if (ptr->data == vor_wert) //vor_wert gefunden => vorner einfuegen
		{
			//kiem tra vi tri cua pointer
			if (ptr == anker) //vor_wert an anker
			{
				neuer_eintrag->next = anker;
				anker->prev = neuer_eintrag;
				anker = neuer_eintrag;
			}
			else //vor_wert nicht an anker
			{
				neuer_eintrag->next = ptr;
				neuer_eintrag->prev = ptr->prev;
				ptr->prev = neuer_eintrag;
				ptr->prev->next = neuer_eintrag;
			}
		}
		else if (ptr->next == nullptr)// vor_wert nicht vorkommen => hinter einfugen
		{
			neuer_eintrag->prev = ptr;
			ptr->next = neuer_eintrag;
		}
	}
}

string liste_als_string(TListenKnoten* anker)
{
	string resultat = "";
	if (anker == nullptr)
		return "Leere Liste.";
	else
	{
		resultat += "[ ";
		TListenKnoten* ptr = anker;
		do
		{
			resultat += std::to_string(ptr->data);
			if (ptr->next != nullptr) resultat += " , ";
			else resultat += " ";
			ptr = ptr->next;
		} while (ptr != nullptr);
		resultat += "]";
	}
	return resultat;
}
void liste_ausgeben(TListenKnoten* anker)
{
	cout << liste_als_string(anker) << endl;
}
void liste_ausgeben_rueckwaerts(TListenKnoten* anker)
{	//chay ptr voi dieu kien ptr->next den cuoi day, tu cuoi day chay ptr voi dieu kien ptr->prev ve.
	string resultat = "";
	TListenKnoten* ptr = anker;
	if (anker == nullptr)
	{
		cout << "Leere Liste." << endl;
	}
	else
	{
		while (ptr->next != nullptr)
		{
			ptr = ptr->next;
		}
		resultat += "[ ";
		do
		{
			resultat += std::to_string(ptr->data);
			if (ptr->prev != nullptr) resultat += " , ";
			else resultat += " ";
			ptr = ptr->prev;
		} while (ptr != nullptr);
		resultat += "]";
		cout << resultat << endl;
	}
}

void aus_liste_loeschen(TListenKnoten*& anker, int wert)
{
	for (TListenKnoten* ptr = anker; ptr->next != nullptr; ptr = ptr->next)//Liste durchgehen und sucht den Wert
	{
		if (ptr->data == wert) //den Wert gefunden
		{
			if (ptr == anker) //Wert an die erste Knote begegnet
			{
				if (anker->next == nullptr)// Liste besteht aus nur eine Knote
					anker = nullptr;
				else // Liste besteht aus mehrere Knoten
					anker = anker->next; anker->prev = nullptr;
			}
			else if (ptr != anker) // Wert nicht an die erste Knote
			{
				ptr->prev->next = ptr->next;
				ptr->next->prev = ptr->prev;
			}
			break;
		}
	}
}

void liste_loeschen(TListenKnoten*& anker)
{
	anker = nullptr;
}

int main()
{	//kiem tra in liste einfuegen
	const int laenge = 10;
	TListenKnoten* anker = nullptr;
	for (int i = 0; i < laenge; i++) // neu
		in_liste_einfuegen(anker, i * i, 9999); // neu
	liste_ausgeben(anker);
	liste_ausgeben_rueckwaerts(anker);
	int wert_neu = 0, vor_wert = 0; // neu
	cout << "Einzufuegender Wert: "; cin >> wert_neu; //neu
	cout << "Vor welchem Wert? "; cin >> vor_wert; // neu
	in_liste_einfuegen(anker, wert_neu, vor_wert); // neu
	liste_ausgeben(anker);
	liste_ausgeben_rueckwaerts(anker);
	system("PAUSE");
	return 0;
}