Treeee

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

typedef int T;
struct  TreeNode
{
	T key; // ключ/данные
	TreeNode *left; // указатель на левого потомка
	TreeNode *right; // указатель на правого потомка
	TreeNode *parent; // указатель на предка
};

TreeNode *node(int x)
{
	TreeNode *n = new TreeNode;
	n->key = x;
	n->left = n->right = NULL;
	n->parent = NULL;
	return n;
}

void inorderTraversal(TreeNode* root) //обход узлов в отсортированном порядке
{
	if (root == NULL)
	{
		return;
	}
	inorderTraversal(root->left);
	cout << root->key << " ";
	inorderTraversal(root->right);
}

void preorderTraversal(TreeNode* root) //обход узлов в порядке: вершина, левое поддерево, правое поддерево
{
	if (root == NULL)
	{
		return;
	}
	cout << root->key << " ";
	preorderTraversal(root->left);
	preorderTraversal(root->right);
}

void postorderTraversal(TreeNode *root) //обход узлов в порядке: левое поддерево, правое поддерево, вершина
{
	if (root == NULL)
	{
		return;
	}
	postorderTraversal(root->left);
	postorderTraversal(root->right);
	cout << root->key << " ";
}

TreeNode search(TreeNode* root, int k)
{
	if ((root == NULL) || (k == root->key))
	{
		return *root;
	}
	if (k < root->key)
	{
		return search(root->left, k);
	}
	else
	{
		return search(root->right, k);
	}
}

void insert(TreeNode *&root, int z)
{
	TreeNode *n = node(z);
	if (!root)
	{
		root = n;
	}
	else
	{
		TreeNode *y = root;
		while (y)
		{
			if (n->key > y->key)
			{
				if (y->right)
				{
					y = y->right;
				}
				else
				{
					n->parent = y;
					y->right = n;
					break;
				}
			}
			else
			{
				if (n->key < y->key)
				{
					if (y->left)
					{
						y = y->left;
					}
					else
					{
						n->parent = y;
						y->left = n;
						break;
					}
				}
			}
		}
	}
}

TreeNode* minimum(TreeNode* root)
{
	if (root->left == NULL)
		return root;
	return minimum(root->left);
}
TreeNode* maximum(TreeNode* root)
{
	if (root->right == NULL)
		return root;
	return maximum(root->right);
}

TreeNode* next(TreeNode* root)
{
	if (root->right != NULL)
		return minimum(root->right);
	TreeNode* y = root->parent;
	while (y != NULL && root == y->left)
	{
		root = y;
		y = y->parent;
	}
	return y;
}
void _delete(TreeNode* t, TreeNode* v)
{
	TreeNode *p = v->parent;
	if (v->left == NULL && v->right == NULL)
	{
		if (p->left == v)
			p->left = NULL;
		if (p->right == v)
			p->right = NULL;
	}
	else if (v->left == NULL || v->right == NULL)
	{
		if (v->left == NULL)
		{
			if (p->left == v)
			{
				p->left = p->right;
			}
			else
			{
				p->right = p->left;
				v->right->parent = p;
			}
		}
		else
		{
			if (p->left == v)
			{
				p->left = v->left;
			}
			else
			{
				p->right = v->left;
				v->left->parent = p;
			}
		}
	}
	else
	{
		TreeNode* successor = next(t);
		v->key = successor->key;
		if (successor->parent->left == successor)
		{
			successor->parent->left = successor->right;
			if (successor->right != NULL)
			{
				successor->right->parent = successor->parent;
			}
		}
		else
		{
			successor->parent->right = successor->right;
			if (successor->right != NULL)
			{
				successor->right->parent = successor->parent;
			}
		}
	}
 }

int main()
{
	TreeNode *tree = NULL;
	int n;
	cout << "Enter amount keys: ";
	cin >> n;
	srand(time(0));
	for (int i = 0; i < n; i++)
	{
		int x;
		x = rand() % 20;
		insert(tree, x);
	}
	cout << "Inorder: ";
	inorderTraversal(tree);
	cout <<endl;
	cout << "Preorder: ";
	preorderTraversal(tree);
	cout << endl;
	cout << "Postorder: ";
	postorderTraversal(tree);
	cout << endl;
	system("pause");
	return 0;
}