二叉排序树的源码

#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;
 
}