Verwaltung von Objekten - bin. Baum

[Gast]

Hallo,

ich musste für mein Studium ein Projekt erstellen. Ich bin soweit fertig, es fehlt nur noch die Dokumentation.
Ich brauche unbedingt ne 2. Könnt ihr euch mal den Code ansehen. Ist das Programm OK?

Hier die Aufgabenstellung:
Zur Verwaltung von Objekten soll ein System auf Basis eines binären Baumes erstellt werden. Die verwalteten Objekten sollen vom Nutzer frei definierbar sein. Alle Verwaltungsfunktionen sind so zu gestalten, dass keine Veränderungen in der Verwaltung zu realisieren sind, wenn neue Objekte (Klassen) verwaltet werden.

Als Verwaltungsfunktionen sind umzusetzen:
- einfügen
- löschen
- suchen
- größtes Element
- kleinstes Element
- linker / rechter Nachbar

Hinweise zur Modellierung und Umsetzung:
Für die Umsetzung und den Nachweis der Verwaltung sind nutzerspezifische Testobjekte zu erstellen. Als Basis der Testobjekte dient die Klasse Daten. Der Zugriffsschlüssel soll Name und Vorname sein.
Es sind mind. 20 Objekte im Test zu verwalten. Dabei sind alle Methoden des Verwaltungsobjektes zu benutzen und deren Funktion nachzuweisen.

Hier der Code:
Objekt.h

#pragma once

template <class T>

class Objekt
{

public:

	T* m_tplObjekt;

	Objekt()
	{		
		m_tplObjekt = new T();
	}

	Objekt(char cW)
	{		
		m_tplObjekt = new T(cW);
	}

	~Objekt(void)
	{
		delete this->m_tplObjekt;
	}
};

Objektverwaltung.cpp

#include "stdafx.h"
#include <iostream>
#include "binarytree.h"

void ShowMenue(void);

int main(void)
{
	BinaryTree* root = new BinaryTree();
	BinaryTree* pTemp = NULL;
	char select = 'x';
	char buf[100];
	char sstr[100];
	char cRL = 'x';
	int  item = -1;

	while ( select != 'b')			
	{
		ShowMenue();
		std::cin >> select;

		switch ( select )
		{

		case '0':
			{
				root->PreorderPrint( root );
				fflush( stdin );
				getchar();
			}
			break;

		case '1':
			{
				if( root->PrintFreeNodes(root) == 2 )
				{
					std::cout << "\nBitte waehlen Sie den Anfuegeknoten: ";
					fflush( stdin );
					std::cin >> buf;
					item = atoi( buf );
					pTemp = root->TreeContains( root, item );
					if( pTemp )
					{
						if( (pTemp->m_pLeft == NULL) && (pTemp->m_pRight == NULL) )
						{
							std::cout << "\nBitte waehlen Sie links (Taste 'l') oder rechts (Taste 'r'): ";
							fflush( stdin );
							std::cin >> cRL;
							if( cRL == 'l' )
							{
								root->TreeInsert( pTemp, 'l' , root->MaxItem( root ) + 1  );
							}
							else if( cRL == 'r' )
							{
								root->TreeInsert( pTemp, 'r' , root->MaxItem( root ) + 1  );
							}
							else
							{
								std::cout << "\nFehlerhafte Eingabe, Anfuegen abgebrochen!\n ";								
							}
						}
						else if( pTemp->m_pLeft == NULL )
						{
							root->TreeInsert( pTemp, 'l' , root->MaxItem( root ) + 1  );
						}
						else if( pTemp->m_pRight == NULL )
						{
							root->TreeInsert( pTemp, 'r' , root->MaxItem( root ) + 1  );
						}
						else
						{
							std::cout << "\nFehler, Anfuegen abgebrochen!\n ";							
						}
					}
					else
					{
						std::cout << "\nFehlerhafte Eingabe, Anfuegen abgebrochen!\n ";						
					}
				}
				strcpy( buf, "" );
				strcpy( sstr, "" );
				cRL = 'x';
				pTemp = NULL;				
				item = -1;
				fflush( stdin );
				getchar();				
			}
			break;

		case '2':
			{				
				root->PreorderPrint( root );
				std::cout << "\nBitte waehlen Sie den zu loeschenden Eintrag.\n";
				fflush( stdin );
				std::cin >> buf;
				item = atoi( buf );				
				int ret = root->DeleteNode( root, item );

				if( ret == 0 )
				{
					std::cout << "\nLoeschen fehlgeschlagen.";					
				}
				else if( ret == -2 )
				{
					std::cout << "\nWurzelknoten kann nicht geloescht werden! ";
				}
				else if( ret == -1 )
				{
					std::cout << "\nLoeschen nicht moeglich - Subtrees vorhanden! ";
				}
				else if( ret == 1 )
				{
					std::cout << "\nLoeschen erfolgreich ausgefuehrt. ";
				}
				else
				{
					std::cout << "\nUnbekannter Fehler. ";
				}

				pTemp = NULL;
				strcpy( buf, "" );
				item = -1;
				fflush( stdin );
				getchar();			
			}
			break;

		case '3':
			{				
				std::cout << "\nBitte geben Sie den Suchbegriff ein: ";
				fflush( stdin );
				std::cin >> sstr;							
				pTemp = root->TreeContains( root, sstr );

				if( pTemp )
				{
					std::cout << "\nEintrag gefunden. ";
					pTemp->m_pObjekt->m_tplObjekt->ShowDaten();
				}
				else
				{
					std::cout << "\nLeider keinen Eintrag gefunden. ";
				}

				pTemp = NULL;
				strcpy( sstr, "" );				
				fflush( stdin );
				getchar();

			}
			break;

		case '4':
			{
				std::cout << "\nDas groesste Element ist:  ";
				std::cout << root->MaxItem( root ) << "   ";
				pTemp = root->TreeContains( root, root->MaxItem( root ));
				if( pTemp )
					pTemp->m_pObjekt->m_tplObjekt->ShowDaten();

				pTemp = NULL;
				strcpy( sstr, "" );
				item = -1;
				fflush( stdin );
				getchar();
			}
			break;

		case '5':
			{
				std::cout << "\nDas kleinste Element ist:  ";
				std::cout << root->MinItem( root ) << "   ";

				pTemp = root->TreeContains( root, root->MinItem( root ));
				if( pTemp )
					pTemp->m_pObjekt->m_tplObjekt->ShowDaten();

				pTemp = NULL;
				strcpy( sstr, "" );
				item = -1;
				fflush( stdin );
				getchar();
			}
			break;

		case '6':
			{
				root->PreorderPrint( root );
				std::cout << "\nBitte waehlen Sie einen Eintrag.\n";
				fflush( stdin );
				std::cin >> buf;
				item = atoi( buf );				
				pTemp = root->PrintNeighbour( root, item );

				pTemp = NULL;
				strcpy( buf, "" );
				item = -1;
				fflush( stdin );
				getchar();				
			}
			break;

		case 'b':
			{
				std::cout << "\nBeenden... ";
			}
			break;

		default:
			std::cout << "Falsche Eingabe";
			fflush( stdin );
			getchar();
		}
	}

	fflush( stdin );
	getchar();
	delete root;
	return 0;
}

void ShowMenue(void)
{
	system("cls");
	std::cout << "\n\n\t\tHauptmenue\n";
	std::cout << "\t\t==========\n\n";
	std::cout << "\t0 - Objektbaum anzeigen\n";
	std::cout << "\t1 - Neues Objekt einfuegen\n";
	std::cout << "\t2 - Objekt loeschen\n";
	std::cout << "\t3 - Objekt suchen\n";
	std::cout << "\t4 - Groesstes Element ausgeben\n";
	std::cout << "\t5 - Kleinstes Element ausgeben\n";
	std::cout << "\t6 - Nachbarobjekt anzeigen\n";
	std::cout << "\tb - Beenden\n";
	std::cout << "\n\tIhre Auswahl: ";
}

Daten.h

#pragma once

typedef struct _DAYOFBIRTH
{
	unsigned short day;
	unsigned short month;
	unsigned int   year;

}DAYOFBIRTH;

class Daten
{
public:
	 Daten(void);							// Konstruktor
	 Daten(char cW);
	~Daten(void);							// Destruktor

private:
	char m_cRootFlag;
	char m_szName[100];
	char m_szVorname[100];
	char m_szPLZ[8];
	char m_szOrt[50];
	char m_szStrasse[50];
	int  m_nHausnummer;
	DAYOFBIRTH* m_strctDOB;

public:
	void Set_Name(const char* newName);
	void Set_Vorname(const char* newVorname);
	void Set_PLZ(const char* newPLZ);
	void Set_Ort(const char* newOrt);
	void Set_Strasse(const char* newStrasse);
	void Set_DOB(unsigned short day, unsigned short month, unsigned int year);

	char* Get_Name(void);
	char* Get_Vorname(void);
	char* Get_PLZ(void);
	char* Get_Ort(void);
	char* Get_Strasse(void);
	DAYOFBIRTH* Get_DOB(void);
	unsigned short Get_DOB_day(void);
	unsigned short Get_DOB_month(void);
	unsigned int Get_DOB_year(void);

	void FillDaten(void);
	void FillRootDaten(void);
	void ShowDaten(void);

};

Daten.cpp

#include "StdAfx.h"
#include ".\daten.h"

Daten::Daten(void)
{
	strcpy(this->m_szName,    "<leer>");
	strcpy(this->m_szVorname, "<leer>");
	strcpy(this->m_szPLZ,     "<leer>");
	strcpy(this->m_szOrt,     "<leer>");
	strcpy(this->m_szStrasse, "<leer>");
	this->m_nHausnummer = 0;
	this->m_strctDOB = new DAYOFBIRTH;
	this->m_strctDOB->day   = 0;
	this->m_strctDOB->month = 0;
	this->m_strctDOB->year  = 0;

	this->FillDaten();
}

Daten::Daten(char cW)
{
	strcpy(this->m_szName,    "<leer>");
	strcpy(this->m_szVorname, "<leer>");
	strcpy(this->m_szPLZ,     "<leer>");
	strcpy(this->m_szOrt,     "<leer>");
	strcpy(this->m_szStrasse, "<leer>");
	this->m_nHausnummer = 0;
	this->m_strctDOB = new DAYOFBIRTH;
	this->m_strctDOB->day   = 0;
	this->m_strctDOB->month = 0;
	this->m_strctDOB->year  = 0;

	if( cW == 'w')
	{
		this->m_cRootFlag = 'w';
		this->FillRootDaten();
	}
	else
		this->FillDaten();
}

Daten::~Daten(void)
{
}

//************************************************************

void Daten::Set_Name(const char* newName)
{
	strcpy(this->m_szName, newName);
}

void Daten::Set_Vorname(const char* newVorname)
{
}

void Daten::Set_PLZ(const char* newPLZ)
{
}

void Daten::Set_Ort(const char* newOrt)
{
}

void Daten::Set_Strasse(const char* newStrasse)
{
}

void Daten::Set_DOB(unsigned short day, unsigned short month, unsigned int year)
{
}

char* Daten::Get_Name(void)
{
	return this->m_szName;
}

char* Daten::Get_Vorname(void)
{
	return this->m_szVorname;
}

char* Daten::Get_PLZ(void)
{
	return this->m_szPLZ;
}

char* Daten::Get_Ort(void)
{
	return this->m_szOrt;
}

char* Daten::Get_Strasse(void)
{
	return this->m_szStrasse;
}

DAYOFBIRTH* Daten::Get_DOB(void)
{
	return this->m_strctDOB;
}

unsigned short Daten::Get_DOB_day(void)
{
	return this->m_strctDOB->day;
}

unsigned short Daten::Get_DOB_month(void)
{
	return this->m_strctDOB->month;
}

unsigned int Daten::Get_DOB_year(void)
{
	return this->m_strctDOB->year;
}

void Daten::FillDaten(void)					// Eingabe zur Erfassung der Daten
{
	char szBuf[200];

	std::cout << "\n\tEingabe des zu erfassenden Datensatzes\n" ;
	std::cout << "\n\t======================================\n\n";
	fflush( stdin );

	std::cout << "\n\tBitte Name eingeben: ";		
	std::cin >> szBuf;
	if( strcmp(szBuf, "l"))
		strcpy(this->m_szName, szBuf);
	fflush( stdin );

	std::cout << "\n\tBitte Vorname eingeben: ";
	std::cin >> szBuf;
	if( strcmp(szBuf, "l"))		
		strcpy(this->m_szVorname, szBuf);
	fflush( stdin );

	std::cout << "\n\tBitte Postleitzahl eingeben: ";
	std::cin >> szBuf;
	if( strcmp(szBuf, "l"))
		strcpy(this->m_szPLZ, szBuf);
	fflush( stdin );

	std::cout << "\n\tBitte Ort eingeben: ";
	std::cin >> szBuf;
	if( strcmp(szBuf, "l"))		
		strcpy(this->m_szOrt, szBuf);
	fflush( stdin );

	std::cout << "\n\tBitte Strasse eingeben: ";
	std::cin >> szBuf;
	if( strcmp(szBuf, "l"))	
		strcpy(this->m_szStrasse, szBuf);
	fflush( stdin );

	std::cout << "\n\tBitte Hausnummer eingeben: ";
	std::cin >> szBuf;
	if( strcmp(szBuf, "l"))
		this->m_nHausnummer = atoi(szBuf);
	fflush( stdin );

	std::cout << "\n\tBitte Geburtsjahr eingeben: ";		
	std::cin >> szBuf;
		if( strcmp(szBuf, "l"))
	this->m_strctDOB->year = atoi(szBuf);
	fflush( stdin );

	std::cout << "\n\tBitte Geburtsmonat eingeben: ";		
	std::cin >> szBuf;
	if( strcmp(szBuf, "l"))
		this->m_strctDOB->month = atoi(szBuf);
	fflush( stdin );

	std::cout << "\n\tBitte Geburtstag eingeben: ";		
	std::cin >> szBuf;
	if( strcmp(szBuf, "l"))
		this->m_strctDOB->day = atoi(szBuf);
	fflush( stdin );

	std::cout << "\n\tOK, weiter... ";
	getchar();
}

void Daten::ShowDaten(void)					// Zeigt die erfassten Daten
{
	if( this->m_cRootFlag == 'w' )
	{
		std::cout << "\n\tHauptknoten, Bezeichnung: " << this->m_szName << "\n ";
	}

	else
	{
		std::cout << "\n\tName:       " << this->m_szName << " ";
		std::cout << "\n\tVorname:    " << this->m_szVorname << " ";
		std::cout << "\n\tPLZ:        " << this->m_szPLZ << " ";
		std::cout << "\n\tOrt:        " << this->m_szOrt << " ";
		std::cout << "\n\tStrasse:    " << this->m_szStrasse << " ";
		std::cout << "\n\tHausnummer: " << this->m_nHausnummer << " ";
		std::cout << "\n\tGeburtstag: " << this->m_strctDOB->day << "." << this->m_strctDOB->month << "." << this->m_strctDOB->year << "\n ";
	}

}

void Daten::FillRootDaten(void)				// Eingabe der Hauptbezeichnung
{
	char szBuf[200];

	std::cout << "\n\tAnlegen des Hauptknotens (Wurzel-oder Rootknoten)\n" ;
	std::cout << "\n\t=================================================\n\n";
	fflush( stdin );

	std::cout << "\n\tBitte geben Sie eine Hauptbezeichnung ein: ";		
	std::cin >> szBuf;
	if( strcmp(szBuf, "l"))
		strcpy(this->m_szName, szBuf);
	fflush( stdin );

	std::cout << "\n\tOK, weiter... ";
	getchar();
}

BinaryTree.h

#pragma once
#include "Objekt.h"
#include "Daten.h"

class BinaryTree
{
public:

	 BinaryTree(int newItem);
	 BinaryTree(void);
	~BinaryTree(void);

	int				m_nItem;
	BinaryTree*		m_pLeft;   
	BinaryTree*		m_pRight;
	BinaryTree*		m_pParent;	
	Objekt<Daten>*  m_pObjekt;

	void TreeInsert(BinaryTree* &root, char cRL, int newItem);
	void PreorderPrint( BinaryTree *root );
	int  CountNodes( BinaryTree* root );
	BinaryTree* TreeContains( BinaryTree* root, int item ); 
	BinaryTree* TreeContains( BinaryTree* root, char* item ); 
	int MaxItem( BinaryTree *root ); 
	int MinItem( BinaryTree *root ); 
	BinaryTree* GetNeighbour( BinaryTree* root, int item );
	int DeleteNode(BinaryTree* root, int item);
	int PrintFreeNodes(BinaryTree* root);
	BinaryTree* GetParent( BinaryTree* root, int item );
	BinaryTree* PrintNeighbour( BinaryTree* root, int item );

};

BinaryTree.cpp

#include "Stdafx.h"
#include "binarytree.h"

BinaryTree::BinaryTree(int newItem)
{
	this->m_nItem   = newItem;
	this->m_pLeft   = NULL;
	this->m_pRight  = NULL;	
	this->m_pParent = NULL;
	this->m_pObjekt = new Objekt<Daten>();
}
BinaryTree::BinaryTree()
{
	this->m_nItem   = 1;
	this->m_pLeft   = NULL;
	this->m_pRight  = NULL;	
	this->m_pParent = NULL;
	this->m_pObjekt = new Objekt<Daten>('w');
}

BinaryTree::~BinaryTree(void)				// Destruktor
{
	delete this->m_pObjekt;
}

void BinaryTree::TreeInsert(BinaryTree* &root, char cRL, int newItem)
{              
	if ( root == NULL ) 
	{                
		root = new BinaryTree( 1 );
		std::cout << "\nEin neuer Objektbaum wurde mit der Nummer 1 angelegt.";
		return;
	}
	else if ( cRL == 'l' ) 
	{
		root->m_pLeft = new BinaryTree( newItem );
		root->m_pLeft->m_pParent = root;
		std::cout << "\nEin neuer Objektknoten wurde am Elternknoten->links angelegt.";
	}
	else if ( cRL == 'r' ) 
	{
		root->m_pRight = new BinaryTree( newItem );
		root->m_pRight->m_pParent = root;
		std::cout << "\nEin neuer Objektknoten wurde am Elternknoten->rechts angelegt.";
	}
	else 
	{
		std::cout << "\nDie Einfuegeoperation ist fehlgeschlagen.";
	}
} 

void BinaryTree::PreorderPrint( BinaryTree *root ) 
{          
	if ( root != NULL ) 
	{  
		std::cout << "\nNode-Eintrag = " << root->m_nItem << "    " ; 
		std::cout << "Node = " << root << "    "; 
		std::cout << "Node->right = " << root->m_pRight << "    ";
		std::cout << "Node->left = " << root->m_pLeft << "    ";

		root->m_pObjekt->m_tplObjekt->ShowDaten();

		if(root->m_pLeft)
			PreorderPrint( root->m_pLeft );
		if(root->m_pRight)
			PreorderPrint( root->m_pRight );   
    }
} 

int BinaryTree::CountNodes( BinaryTree* root ) 
{           
	if ( root == NULL )
		return 0;  
	else 
	{
		int count = 1;   
		count += CountNodes(root->m_pLeft);                                            
		count += CountNodes(root->m_pRight);                                           
		return count;  
	}
}

BinaryTree* BinaryTree::TreeContains( BinaryTree* root, int item ) 
{
	if ( root == NULL ) 
	{
		return NULL;
	}
	else if ( item == root->m_nItem ) 
	{		
		return root;
	}
	else  
	{
		if ( root->m_pLeft )
		{			
			if(TreeContains( root->m_pLeft, item ))
			{
				return TreeContains( root->m_pLeft, item );
			}
			else if ( root->m_pRight )
			{				
				return TreeContains( root->m_pRight, item );
			}		
		}
		else if ( root->m_pRight )
		{			
			if(TreeContains( root->m_pRight, item ))
			{
				return TreeContains( root->m_pRight, item );
			}
			else if ( root->m_pLeft )
			{			
				return TreeContains( root->m_pLeft, item );
			}		
		}		
	}
	return NULL;
}

int BinaryTree::MaxItem( BinaryTree *root ) 
{
	static int max = -1;

	if ( root != NULL ) 
	{  
		if( root->m_nItem > max)
		{
			max = root->m_nItem;
		}

		max = MaxItem( root->m_pLeft );    
		max = MaxItem( root->m_pRight );   
    }

	return max;
} 

int BinaryTree::MinItem( BinaryTree *root ) 
{
	static int min = 100;

	if ( root != NULL ) 
	{  
		if( root->m_nItem < min)
		{
			min = root->m_nItem;
		}

		min = MinItem( root->m_pLeft );    
		min = MinItem( root->m_pRight );   
    }

	return min;
}

int BinaryTree::DeleteNode(BinaryTree* root, int item)
{
	BinaryTree* pTemp = NULL; 

	if( root != NULL )
	{
		pTemp = this->TreeContains( root, item );
	}

	if( pTemp )
	{
		if( (pTemp->m_pLeft == NULL) && (pTemp->m_pRight == NULL) )
		{
			if( pTemp->m_pParent != NULL )
			{
				if( pTemp->m_pParent->m_pLeft == pTemp )
				{
					pTemp->m_pParent->m_pLeft = NULL;
					delete pTemp;					
					return 1;
				}
				else if( pTemp->m_pParent->m_pRight == pTemp )
				{
					pTemp->m_pParent->m_pRight = NULL;
					delete pTemp;					
					return 1;
				}
			}
			else if( pTemp->m_pParent == NULL )
			{
				root = NULL;
				return -2;
			}
		}
		else
		{
			return -1;
		}
	}
	return 0;
}

int BinaryTree::PrintFreeNodes(BinaryTree* root) 
{              
	if ( root == NULL ) 
	{                
		std::cout << "\nKeine Baumstruktur vorhanden. ";		
		return 1;
	}
	else 
	{
		if ( root->m_pLeft == NULL ) 
		{
			std::cout << "\nEinfuegen moeglich bei Knoten Nummer: " << root->m_nItem << ", links ";
		}
		else
		{
			PrintFreeNodes( root->m_pLeft );
		}
		if ( root->m_pRight == NULL ) 
		{
			std::cout << "\nEinfuegen moeglich bei Knoten Nummer: " << root->m_nItem << ", rechts ";
		}
		else
		{
			PrintFreeNodes( root->m_pRight );
		}
		return 2;
	}
	return 0;
}

BinaryTree* BinaryTree::GetParent( BinaryTree* root, int item ) 
{
	BinaryTree* pTemp = NULL;

	if ( root != NULL ) 
	{
		pTemp = this->TreeContains( root, item ); 
	}

	if ( pTemp ) 
	{
		return pTemp->m_pParent;
	}
	else  
	{		
		return NULL;
	}
	return NULL;
}

BinaryTree* BinaryTree::PrintNeighbour( BinaryTree* root, int item ) 
{
	BinaryTree* pParent = this->GetParent( root, item );
	std::cout << "\nSpeicheradresse von pParent = " << pParent << ". ";

	if( pParent != NULL )
	{
		if( pParent->m_pLeft == this->TreeContains( root, item ))
		{
			std::cout << "\nGesucht wurde nach einem Knoten mit der Nummer: " << pParent->m_pLeft->m_nItem << " ";
			std::cout << "\nGefunden wurde ein Elternknoten mit der Nummer: " << pParent->m_nItem << " ";
			std::cout << "\nund der Speicheradresse: " << pParent << ". ";
			if( pParent->m_pRight != NULL )
			{
				std::cout << "\nGefunden wurde ein Nachbarknoten rechts mit der Nummer: " << pParent->m_pRight->m_nItem << " ";
				std::cout << "\nund der Speicheradresse: " << pParent->m_pRight << ". ";
				std::cout << "\nDer Knoten beinhaltet folgende Daten: ";
				pParent->m_pRight->m_pObjekt->m_tplObjekt->ShowDaten();
			}
			else
			{
				std::cout << "\nEs wurde kein Nachbarknoten gefunden. ";
				std::cout << "\nDer Adresszeiger des Elternknotens rechts ist NULL. ";
			}
			return pParent->m_pRight;
		}
		else if( pParent->m_pRight == this->TreeContains( root, item ))
		{
			std::cout << "\nGesucht wurde nach einem Knoten mit der Nummer: " << pParent->m_pRight->m_nItem << " ";
			std::cout << "\nGefunden wurde ein Elternknoten mit der Nummer: " << pParent->m_nItem << " ";
			std::cout << "\nund der Speicheradresse: " << pParent << ". ";
			if( pParent->m_pLeft != NULL )
			{
				std::cout << "\nGefunden wurde ein Nachbarknoten links mit der Nummer: " << pParent->m_pLeft->m_nItem << " ";
				std::cout << "\nund der Speicheradresse: " << pParent->m_pLeft << ". ";
				std::cout << "\nDer Knoten beinhaltet folgende Daten: ";
				pParent->m_pLeft->m_pObjekt->m_tplObjekt->ShowDaten();
			}
			else
			{
				std::cout << "\nEs wurde kein Nachbarknoten gefunden. ";
				std::cout << "\nDer Adresszeiger des Elternknotens links ist NULL. ";
			}
			return pParent->m_pLeft;
		}
		else
		{
			std::cout << "\nFehler - Eintrag nicht gefunden. Bitte Eingabe pruefen und wiederholen! ";
			return NULL;
		}

	}
	else
	{
		std::cout << "\nFehler - root ist NULL oder der Wurzelknoten. ";
		return NULL;
	}
	return NULL;	
}

BinaryTree* BinaryTree::TreeContains( BinaryTree* root, char* item ) 
{
	if ( root == NULL ) 
	{
		return NULL;
	}
	else if ( strcmp( item, root->m_pObjekt->m_tplObjekt->Get_Name()) == 0 ) 
	{		
		return root;
	}
	else if ( strcmp( item, root->m_pObjekt->m_tplObjekt->Get_Vorname()) == 0 ) 
	{		
		return root;
	}
	else  
	{
		if ( root->m_pLeft )
		{			
			if(TreeContains( root->m_pLeft, item ))
			{
				return TreeContains( root->m_pLeft, item );
			}
			else if ( root->m_pRight )
			{				
				return TreeContains( root->m_pRight, item );
			}		
		}
		else if ( root->m_pRight )
		{			
			if(TreeContains( root->m_pRight, item ))
			{
				return TreeContains( root->m_pRight, item );
			}
			else if ( root->m_pLeft )
			{			
				return TreeContains( root->m_pLeft, item );
			}		
		}		
	}
	return NULL;
}

Danke!
Gruß

[ghorst]

ok, eigentlich neige ich nicht zu dieser antwort: glaubst du ernsthaft, dass sich jemand deinen code reinzieht? bitte beschreibe dein problem?

[Gast]

Hallo,
Probleme gibt es eigentlich keine.
Ich möchte ja nur, dass mal jemand das Programm testet, ob es auch mit der Aufgabenstellung übereinstimmt. Aus Erfahrung kann ich sagen, dass es oft besser ist, jemand fremden nochmals drüber schauen zu lassen. Man hat doch oft ein "Brett vorm Kopf".

Ich hätte auch die .exe zum Test angefügt, aber leider funktioniert das nicht!

[Tachyon]

So, wie das Programm aussieht, gehört es eher ins C-Forum. Außerdem ist es keine gute Idee, Inputstreams zu flushen.

[drakon]

Und wenn es doch C++ sein soll, dann solltest du unbedingt ein wenig mehr C++ Mittel nutzen. std::string und konsorten, anstatt ein char Array und strcpy.

Ansonsten gibt es da einen Haufe zu zu sagen.
Du solltest das ganze ein wenig allgemeiner halten. Ein Baum muss ja nicht nur genau auf deine Weise genutzt werden. Stell dir vor, dass du für ein anderes Projekt auch einen solchen Baum brauchst. Dann kannst du aber diesen Code hier nicht nutzen, weil der der viel zu spezifisch für dein aktuelles Problem ist. Daten füllen hat eigenltich nichts mit dem Baum zu tun. Er muss es ledigich unterstützen und füllen machst du dann in der main, oder in einer anderen Klasse.
Dann getter und setter solltest du inline machen, weil die ja so trivial sind.

TreeContains kannst du viel einfacher schreiben. Du überprüfst da je ein Haufen Dinge und gibst immer das gleiche zurück. Überprüf doch einfach den einzigen Fall und ansonsten gib gleich root zurück.