二叉排序数（创建，插入，删除，查找及前序、中序、后序遍历）

// erchapaixushu.cpp : 定义控制台应用程序的入口点。
//


#include "stdafx.h"
#include <iostream>
#include "stdlib.h"
#include <stack>
using namespace std;




class Node
{
public:
int data;
Node *parent;
Node*left;
Node *right;
int tag;//标志位，用于后序遍历中找左子树，还是右子树
public:
Node() :data(-1), parent(NULL), left(NULL), right(NULL), tag(0)
{
};
Node(int num) :data(num), parent(NULL), left(NULL), right(NULL), tag(0)
{
};
};


class Tree
{
public:
Tree(int num[], int len);
void insertNode1(int data);//非递归
void insertNode(int data);//递归
Node * searchNode(int data);
void deleteNode(int data);


void inOrderThee();//中序遍历递归方法
void inOrderFeiDiGuiThee(); //中序遍历非递归方法


void preOrderThee();//前序遍历递归方法
void preOrderFeiDiGuiThee(); //前序遍历非递归方法


void lastOrderThee();//后序遍历递归方法
void lastOrderFeiDiGuiThee(); //后序遍历非递归方法


~Tree();
private:
void insertNode(Node*current, int data);
Node * searchNode(Node*current, int data);
void delteNode(Node*current);
void inOrderThee(Node * current);
void preOrderThee(Node * current);
void lastOrderThee(Node * current);
private:
Node * root;
};
//构造函数
Tree::Tree(int num[], int len)
{
root = new Node(num[0]);
for (int i = 0; i < len; i++)
{
//insertNode1(num[i]);
insertNode(num[i]);
}
}


void Tree::insertNode1(int data)//fei递归
{
Node*p, *par;
Node*newNode = new Node(data);
p = par = root;
while (p != NULL)
{
par = p;
if (data > p->data)
{
p = p->right;
}
else if (data < p->data)
{
p = p->left;
}
else
{
delete newNode;
return;
}
}


newNode->parent = par;


if (par->data > newNode->data)
{
par->left = newNode;
}
else
{
par->right = newNode;
}
}




void Tree::insertNode(int data)//递归
{
if (root != NULL)
{
insertNode(root, data);
}
}
Node * Tree::searchNode(int data)
{
Node *current = NULL;
if (root != NULL)
{
current = searchNode(root, data);
}
return current;
}
void Tree::deleteNode(int data)
{
Node * current = NULL;
current = searchNode(data);
if (current != NULL)
{
delteNode(current);
}


}


void Tree::insertNode(Node*current, int data)
{
if (data < current->data)
{
if (current->left ==NULL)
{
current->left = new Node(data);
current->left->parent = current;
}
else
{
insertNode(current->left, data);
}
}
else if(data > current->data)
{
if (current->right == NULL)
{
current->right = new Node(data);
current->right->parent = current;
}
else
{
insertNode(current->right, data);
}
}
return;
}
Node * Tree::searchNode(Node*current, int data)
{
if (data < current->data)
{
if (current->left == NULL)
{
return NULL;
}
return  searchNode(current->left, data);
}
else if (data > current->data)
{
if (current->right == NULL)
{
return NULL;
}
return  searchNode(current->right, data);
} 


return current;
}
void Tree::delteNode(Node*current)
{
if (current->left != NULL)
{
delteNode(current->left);
}
if (current->right!=NULL)
{
delteNode(current->right);
}
if (current->parent == NULL)
{
delete current;
root = NULL;
return;
}
if (current->parent->data > current->data)
{
current->parent->left = NULL;
}
else
{
current->parent->right = NULL;
}


delete current;
}


void Tree::inOrderThee()
{
if (root == NULL)
{
return;
}
inOrderThee(root);


}


void Tree::inOrderThee(Node * current)
{
if (current!=NULL)
{
inOrderThee(current->left);
cout << current->data << "   ";
inOrderThee(current->right);
}
}


void Tree::inOrderFeiDiGuiThee()
{
stack<Node*>s;
Node *p = root;
while (p != NULL || !s.empty())
{
while (p != NULL)
{
s.push(p);
p = p->left;
}
if (!s.empty())
{
p = s.top();
s.pop();
cout << p->data << "  ";
p = p->right;
}
}
}




void  Tree::preOrderThee()//前序遍历递归方法
{
if (root == NULL)
{
return;
}
preOrderThee(root);
}




void  Tree::preOrderFeiDiGuiThee() //前序遍历非递归方法
{
stack<Node*>s;
Node *p = root;
while (p != NULL || !s.empty())
{
while (p != NULL)
{
cout << p->data << "  ";
s.push(p);
p = p->left;
}
if (!s.empty())
{
p = s.top();
s.pop();
p = p->right;
}
}
}


void  Tree::lastOrderThee()//前序遍历递归方法
{
if (root == NULL)
{
return;
}
lastOrderThee(root);
}
void  Tree::lastOrderFeiDiGuiThee() //前序遍历非递归方法
{
stack<Node*>s;
Node *p = root;
while (p != NULL || !s.empty())
{
while (p != NULL)
{
s.push(p);
p = p->left;
}
if (!s.empty())
{
p = s.top();
if (p->tag)
{
cout << p->data << "  ";
s.pop();
p = NULL;
}
else
{
p->tag = 1;
p = p->right;
}
}
}
}




void Tree::preOrderThee(Node * current)
{
if (current != NULL)
{
cout << current->data << "   ";
preOrderThee(current->left);
preOrderThee(current->right);
}
}




void Tree::lastOrderThee(Node * current)
{
if (current != NULL)
{
lastOrderThee(current->left);
lastOrderThee(current->right);
cout << current->data << "   ";
}
}


Tree::~Tree()
{
}




int main()
{
int num[] = { 5,3,7,2,4,6,8,1 };
Tree tree(num, 8);


cout << "inorder";
tree.inOrderThee();
cout << "\ninorder:";
tree.inOrderFeiDiGuiThee();


cout << "\npreorder";
tree.preOrderThee();
cout << "\npreorder:";
tree.preOrderFeiDiGuiThee();

cout << "\nlastorder";
tree.lastOrderThee();
cout << "\nlastorder:";
tree.lastOrderFeiDiGuiThee();


system("pause");
return 0;
}