二叉排序树的源码

#include<iostream>

#include<stack>

#include<queue>

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 insertNode(int data);

void insertNode1(int data);

Node *searchNode(int data);

void deleteNode(int data);

void InorderTree();

void InorderTreeRec();

void PreorderTree();

void PreorderTreeRec();

void PostorderTree();

void PostorderTreeRec();

void LevelorderTree();

bool IsSortedTree(Tree tree);

private:

void insertNode(Node *current,int data);

Node *searchNode(Node *current,int data);

void deleteNode(Node *current);

void InorderTree(Node *current);

void PreorderTree(Node *current);

void PostorderTree(Node *current);

private:

Node *root;

};

Tree::Tree(int num[],int len)

{

root=new Node(num[0]);

for(int i=1;i<len;i++)

{

insertNode1(num[i]);

}

}

void Tree::insertNode1(int data)

{

Node *p,*par;

Node *newNode=new Node(data);

p=par=root;

while(NULL!=p)

{

par=p;

if(data>p->data)

{

p=p->right;

}

else if(data<p->data)

{

p=p->left;

}

else if(data==p->data)

{

delete newNode;

return;

}

}

newNode->parent=par;

if(par->data>newNode->data)

{

par->left=newNode;

}

else

{

par->right=newNode;

}

}

void Tree::insertNode(int data)

{

if(NULL!=root)

{

insertNode(root,data);

}

}

void Tree::insertNode(Node *current,int data)

{

if(data<current->data)

{

if(NULL==current->left)

{

current->left=new Node(data);

current->left->parent=current;

}

else

{

insertNode(current->left,data);

}

}

else if(data>current->data)

{

if(NULL==current->right)

{

current->right=new Node(data);

current->right->parent=current;

}

else

{

insertNode(current->right,data);

}

}

return;

}

Node * Tree::searchNode(int data)

{

Node *current=NULL;

if(NULL!=root)

{

current=searchNode(root,data);

}

return current;

}

Node * Tree::searchNode(Node *current,int data)

{

if(data<current->data)

{

if(NULL==current->left)

return NULL;

return searchNode(current->left,data);

}

else if(data>current->data)

{

if(NULL==current->right)

return NULL;

return searchNode(current->right,data);

}

return current;

}

void Tree::deleteNode(int data)

{

Node *current=NULL;

current=searchNode(data);

if(NULL!=current)

{

deleteNode(current);

}

}

void Tree::deleteNode(Node *current)

{

if(NULL!=current->left)

{

deleteNode(current->left);

}

else if(NULL!=current->right)

{

deleteNode(current->right);

}

if(NULL==current->parent)

{

delete current;

root=NULL;

return;

}

if(current->parent->data>current->data)

{

current->parent->left=NULL;

}

else

{

current->parent->right=NULL;

}

delete current;

}

void Tree::InorderTree()

{

if(NULL==root)

{

return;

}

InorderTree(root);

}

void Tree::InorderTree(Node *current)

{

if(NULL!=current)

{

InorderTree(current->left);

cout<<current->data<<" ";

InorderTree(current->right);

}

}

void Tree::InorderTreeRec()

{

stack<Node *> s;

Node *p=root;

while(NULL!=p||!s.empty())

{

while(NULL!=p)

{

s.push(p);

p=p->left;

}

if(!s.empty())

{

p=s.top();

s.pop();

cout<<p->data<<" ";

p=p->right;

}

}

}

void Tree::PreorderTree()

{

if(NULL==root)

{

return;

}

PreorderTree(root);

}

void Tree::PreorderTree(Node *current)

{

if(NULL!=current)

{

cout<<current->data<<" ";

PreorderTree(current->left);

PreorderTree(current->right);

}

}

void Tree::PreorderTreeRec()

{

stack<Node *> s;

Node *p=root;

while(NULL!=p||!s.empty())

{

while(NULL!=p)

{

cout<<p->data<<" ";

s.push(p);

p=p->left;

}

if(!s.empty())

{

p=s.top();

s.pop();

p=p->right;

}

}

}

void Tree::PostorderTree()

{

if(NULL==root)

{

return;

}

PostorderTree(root);

}

void Tree::PostorderTree(Node *current)

{

if(NULL!=current)

{

PostorderTree(current->left);

PostorderTree(current->right);

cout<<current->data<<" ";

}

}

void Tree::PostorderTreeRec()

{

stack<Node *> s;

Node *p=root;

while(NULL!=p||!s.empty())

{

while(NULL!=p)

{

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::LevelorderTree()

{

queue<Node *> q;

Node *ptr=root;

q.push(root);

while(!q.empty())

{

ptr=q.front();

q.pop();

cout<<ptr->data<<" ";

if(NULL!=ptr->left)

{

q.push(ptr->left);

}

if(NULL!=ptr->right)

{

q.push(ptr->right);

}

}

}

bool Tree::IsSortedTree(Tree tree)

{

int lastvalue=0;

stack<Node *> s;

Node *p=tree.root;

while(NULL!=p||!s.empty())

{

while(NULL!=p)

{

s.push(p);

p=p->right;

}

if(!s.empty())

{

p=s.top();

s.pop();

if(0==lastvalue||lastvalue<p->data)

{

lastvalue=p->data;

}

else if(lastvalue>=p->data)

{

return false;

}

p=p->right;

}

}

return true;

}

int main()

{

int num[]={5,3,7,2,4,6,8,1};

Tree tree(num,8);

cout<<"Inorder:";

tree.InorderTree();

cout<<"\nInorder:";

tree.InorderTreeRec();

cout<<endl<<endl;

cout<<"Perorder:";

tree.PostorderTree();

cout<<"\nPreorder: ";

tree.PostorderTreeRec();

return 0;

}