Kursova izchistena bez while-a

// Raboti fixnata e.
#include <iostream>
#include <string>
using namespace std;

string names;
string addresses[3];
string phoneNumbers[3];

struct Node
{
	string data;
	Node* next;
	Node* child;
}*prevPerson = NULL;

struct StackNode
{
	struct Node* data;
	struct StackNode* next;
}*top = NULL;

void enterPerson();	// Read input from the console
// third name, address1, address2, address3, Phone number 1,2,3.
struct Node* addNode();	// Create a new node from the values entered in enterPerson()
void insertStack(struct Node* n);	// Inserting an element in the stack
struct Node* popStack();	// Poping element from stack
void traverseList(struct Node* FIRST);	// Traversing the list
void traverseListEmployedNew(struct Node* p);	// Traversing the list, printing the employed people new version
void printStack();
int stackNumberOfElements();

struct Node* lastPersonAdded;
struct Node* firstPersonAdded = NULL;

int numberOfPeople = 0;
static int counterEmployed = 0;
int whileFlag = 1;
int flagPrint = 1;
int static counterTraverse = 0;
int static counterTraverse2 = 0;


struct Node* TEMP = NULL;
struct Node* LAST = NULL;
int main()
{
	int loop = 1;
	while (loop)
	{
		cout << "\nMenu: " << endl;
		cout << "1. Press 1 to add person" << endl;
		cout << "2. Press 2 to show the whole list" << endl;
		cout << "3. Press 3 to show the list of employed people" << endl;
		cout << "5. Press 0 to exit" << endl;
		int inputCommand;
		cin >> inputCommand;
		switch (inputCommand)
		{
		case 1:
		{
			enterPerson();

			// Connecting the list name[n] with name[n+1]
			if (TEMP == NULL)
			{
				TEMP = addNode();
				TEMP->next = NULL;
				LAST = TEMP;
			}
			else
			{
				TEMP = addNode();
				TEMP->next = NULL;
				LAST->next = TEMP;
				LAST = TEMP;
			}
			break;
		}
		case 2:
		{
			if (firstPersonAdded)
			{
				traverseList(firstPersonAdded);
			}
			else
			{
				cout << "The list is empty." << endl;
			}
			counterTraverse = 0;
			break;
		}
		case 3:
		{
			if (firstPersonAdded)
			{
				traverseListEmployedNew(firstPersonAdded);
			}
			else
			{
				cout << "The list is empty. " << endl;
			}
			counterEmployed = 0;
			counterTraverse2 = 0;
		}
		break;


		case 0:
			loop = 0;
			break;
		default:

			break;
		}
	}
}

void enterPerson()
{
	cin.ignore();
	cout << "Enter first name: " << endl;
	cin >> names;
	cout << "Enter first address: " << endl;
	cin >> addresses[0];
	cout << "Enter second address: " << endl;
	cin.ignore();
	getline(cin, addresses[1]);
	cout << "Enter third address: " << endl;
	getline(cin, addresses[2]);
	cout << "Enter first phone number: " << endl;
	cin >> phoneNumbers[0];
	cout << "Enter second phone number: " << endl;
	cin >> phoneNumbers[1];
	cout << "Enter third phone number: " << endl;
	cin >> phoneNumbers[2];

}

struct Node* addNode()
{
	struct Node* first;
	first = new Node;
	first->data = names;
	first->next = NULL;
	prevPerson = first;

	struct Node* adress1Node = new Node;
	adress1Node->data = addresses[0];
	adress1Node->child = NULL;

	struct Node* adress2Node = new Node;
	adress2Node->data = addresses[1];
	adress1Node->next = adress2Node;
	adress2Node->child = NULL;

	struct Node* adress3Node = new Node;
	adress3Node->data = addresses[2];
	adress2Node->next = adress3Node;
	adress3Node->child = NULL;

	first->child = adress1Node;

	struct Node* firstNumberNode = new Node;
	firstNumberNode->data = phoneNumbers[0];
	firstNumberNode->next = NULL;
	firstNumberNode->child = NULL;

	struct Node* secondNumberNode = new Node;
	secondNumberNode->data = phoneNumbers[1];
	secondNumberNode->next = NULL;
	secondNumberNode->child = NULL;
	firstNumberNode->next = secondNumberNode;

	struct Node* thirdNumberNode = new Node;
	thirdNumberNode->data = phoneNumbers[2];
	thirdNumberNode->next = NULL;
	thirdNumberNode->child = NULL;

	adress1Node->child = firstNumberNode;
	adress3Node->child = thirdNumberNode;

	if (numberOfPeople > 0)
	{
		lastPersonAdded->next = first;
		lastPersonAdded = first;
	}
	else
	{
		firstPersonAdded = first;
		lastPersonAdded = first;
	}
	numberOfPeople++;
	return first;
}

void traverseList(struct Node* p)
{
	int traverseFlag = 1;
	int temp = 0;
	if (numberOfPeople > 1)
	{
		temp = 1;
	}
	if (counterTraverse == (numberOfPeople * 7) + temp)
	{
		counterTraverse = 0;
		traverseFlag = 0;
	}
	counterTraverse++;

	if (traverseFlag)
	{
		if (p)
		{
			cout << " " << p->data;
		}
		if (p->child && p->next)
		{
			insertStack(p->next);
			traverseList(p->child);
		}
		else if (p->child)
		{
			traverseList(p->child);
		}
		else if (p->next)
		{
			traverseList(p->next);
		}
		else if (top == NULL && p->child == NULL && p->next == NULL)
		{
		}

		else if (p->next == NULL && p->child == NULL && top != NULL)
		{
			p = popStack();
			traverseList(p);
		}
	}
}

void traverseListEmployedNew(struct Node* p)
{
	struct Node* address2 = NULL;
	struct Node* address3 = NULL;
	counterTraverse2++;
	if (counterTraverse2 == 8)
	{
		counterTraverse2 = 1;
		if (p->child != nullptr)
		{
			if (p->child->next)
				address2 = p->child->next;
			if (p->child->next->next)
				address3 = p->child->next->next;
		}
		if (address2->data.empty() == 1 && address3->data.empty() == 1)
		{
			flagPrint = 0;
		}
		else
		{
			flagPrint = 1;
		}
	}

	if (p)
	{
		if (flagPrint)
		{
			cout << " " << p->data;
		}
	}
	if (p->child && p->next)
	{
		insertStack(p->next);
		traverseListEmployedNew(p->child);
	}
	else if (p->child)
	{
		traverseListEmployedNew(p->child);
	}
	else if (p->next)
	{
		traverseListEmployedNew(p->next);
	}
	else if (top == NULL && p->child == NULL && p->next == NULL)
	{
		return;
	}

	// There are no child and next pointers but stack is not empty.
	else if (p->next == NULL && p->child == NULL && top != NULL)
	{
		p = popStack();
		traverseListEmployedNew(p);
	}
}



void insertStack(struct Node* p)
{
	if (top == NULL)
	{
		top = new StackNode;
		top->data = p;
		top->next = NULL;
	}
	else
	{
		StackNode* t = new StackNode;
		t->data = p;
		t->next = top;
		top = t;
	}
}

int stackNumberOfElements()
{
	int countStack = 0;
	StackNode* p = top;
	while (p)
	{
		p = p->next;
		countStack++;
	}
	return countStack;
}

struct Node* popStack()
{
	struct StackNode* p;
	struct Node* t;
	p = top;
	t = top->data;
	top = top->next;
	delete p;
	return t;

}

void printStack()
{
	struct StackNode* p = top;
	while (p != NULL)
	{
		cout << p->data->data << " ";
		p = p->next;
	}
	cout << endl;
}