Binary Tree

#include<iostream>

using namespace std;

struct node
{
int data;
node* left;
node* right;
};

class btree
{
public:
btree();
~btree();

void insert (int data);
node* search(int data);
void destroy_tree();
int size();
int minValue();
int maxValue();
int maxDepth();
void printTree();
void printPostorder();
void mirror();


private:
void destroy_tree(node* leaf);
void insert(int data, node* leaf);
node* search(int data, node* leaf);
int size(node* leaf);
int minValue(node* leaf);
int maxValue(node* leaf);
int maxDepth(node* leaf);
void printTree(node* leaf);
void printPostorder(node* leaf);
void mirror(node* leaf);



node* root;
};

btree::btree()
{
root = NULL;
}
btree::~btree()
{
destroy_tree();
}
void btree::destroy_tree(node* leaf)
{
if(leaf != NULL)
{
destroy_tree(leaf->left);
destroy_tree(leaf->right);
delete leaf;
}
}
void btree::insert(int data,node* leaf)
{
if(data < leaf->data)
{
if(leaf->left != NULL)
insert(data, leaf->left);
else
{
leaf->left = new node;
leaf->left->data = data;
leaf->left->left = NULL;
leaf->left->right = NULL;
}
}
else
{
if(leaf->right != NULL)
insert(data, leaf->right);
else
{
leaf->right = new node;
leaf->right->data = data;
leaf->right->left = NULL;
leaf->right->right = NULL;
}
}
}
node* btree::search(int data, node* leaf)
{
if(leaf != NULL)
{
if(data == leaf->data)
return leaf;
if(data < leaf->data)
return search(data, leaf->left);
return search(data, leaf->right);
}
return NULL;
}
void btree::insert(int data)
{
if(root != NULL)
insert(data, root);
else
{
root = new node;
root->data = data;
root->left = NULL;
root->right = NULL;
}
}
node* btree::search(int data)
{
return search(data, root);
}
void btree::destroy_tree()
{
destroy_tree(root);
}
int btree::size(node* leaf)
{
if(leaf == NULL)
return 0;
return size(leaf->left) + 1 + size(leaf->right);
}
int btree::size()
{
if(root == NULL)
return 0;
return size(root);
}
int btree::minValue(node* leaf)
{
while(leaf->left != NULL)
{
leaf = leaf->left;
}
return leaf->data;
}
int btree::minValue()
{
if(root == NULL)
return -1;
return minValue(root);
}
int btree::maxDepth(node* leaf)
{
if(leaf == NULL)
return 0;
int leftDepth = maxDepth(leaf->left);
int rightDepth = maxDepth(leaf->right);
if(leftDepth > rightDepth)
return leftDepth + 1;
return rightDepth + 1;
}
int btree::maxDepth()
{
return maxDepth(root);
}
int btree::maxValue(node* leaf)
{
while(leaf->right != NULL)
{
leaf = leaf->right;
}
return leaf->data;
}
int btree::maxValue()
{
if(root == NULL)
return -1;
return maxValue(root);
}
void btree::printTree(node* leaf)
{
if(leaf == NULL) return;
printTree(leaf->left);
printf("%d ",leaf->data);
printTree(leaf->right);
}
void btree::printTree()
{
printTree(root);
}
void btree::printPostorder(node* leaf)
{
if(leaf == NULL) return;
printPostorder(leaf->left);
printPostorder(leaf->right);
printf("%d ",leaf->data);
}

void btree::printPostorder()
{
printPostorder(root);
}

void btree::mirror(node* leaf)
{
if(leaf == NULL) return;
node* temp;

//Tiep tuc voi subtree
mirror(leaf->left);
mirror(leaf->right);

//trao doi con trai va con phai cua node nay.
temp = leaf->left;
leaf->left = leaf->right;
leaf->right = temp;
}

void btree::mirror()
{
mirror(root);
}





int main()
{
btree b;
b.insert(4);
b.insert(2);
b.insert(5);

if(b.search(5)==NULL)
cout << "NO" << endl;
else
cout << "YES" << endl;

cout << b.size() << endl;

cout << b.minValue() << endl;

b.printTree();

cout << endl;

b.printPostorder();

cout << endl;

b.mirror();

b.printTree();

cout << endl;
system("pause");
return 0;
}