二叉树的存储结构及实现

顺序存储

二叉树的顺序存储结构就是用一维数组存储二叉树中的结点，并且结点的存储位置（下标）应能体现结点之间的逻辑关系——父子关系。
完全二叉树和满二叉树中结点的序号可以唯一地反映出结点之间的逻辑关系 。
前序遍历

void Preorder(int root, char data[]){
	if(data[root]!='\0'){
		cout<<data[root] ;			
		Preorder(2*root,data);
		Preorder(2*root+1,data);

	}
	return;
}

中序遍历

void InOrder(int root, char data[]){
	if(data[root]!='\0'){
		InOrder(2*root,data);
		cout<<data[root] ;			
		 InOrder(2*root+1,data);	
	}
	return;
}

后序遍历

void PostOrder(int root, char data[]){
	if(data[root]!='\0'){
		 PostOrder(2*root,data);
		 PostOrder(2*root+1,data);
		cout<<data[root] ;			
	}
	return;
}

创建二叉树

void create(char preorder[],char inorder[],int start_p, int end_p,int start_i,int end_i, char data[],int root){
	if(start_p>end_p)
		return ;
	else{
		int k;
		for(int i=start_i;i<=end_i;i++){
			if(inorder[i]==preorder[start_p]){
				k=i;
				break;
			}
		}
		data[root]=preorder[start_p];
		create(preorder,inorder,start_p+1,start_p+k-start_i,start_i,k-1,data, 2*root);
		create(preorder,inorder,start_p+k-start_i+1,end_p,k+1,end_i,data,2*root+1);
	}
	return ;
}

Main函数实现

int main(){   
    char * data;
	int total=1;
	char preorder[100],inorder[100];
	cin>>preorder>>inorder;
	int length=0;
	while(preorder[length]!='\0')
		length++;
	data=new char[pow(2,length+1)];
	memset(data,'\0',pow(2,length+1));
	create(preorder,inorder,0,length-1,0,length-1,data,1);
	order(1,data);
	return 0;
}

二叉链表

基本思想：令二叉树的每个结点对应一个链表结点，链表结点除了存放与二叉树结点有关的数据信息外，还要设置指示左右孩子的指针。

数据域，存放该结点的数据信息；
lchild：左指针域，存放指向左孩子的指针；
rchild：右指针域，存放指向右孩子的指针。

template <class T>
struct BiNode
{
    T data;
    BiNode<T> *lchild, *rchild;
};

二叉链表存储结构的声明

template <class T>
class BiTree
{    
  public:
       BiTree(); 
        ~BiTree( );            
        void PreOrder(){PreOrder(root);} 
        void InOrder() {InOrder(root);} 
        void PostOrder() {PostOrder(root);} 
        void LevelOrder(){LeverOrder(root)};
  private:
        BiNode<T> *root; 
        BiNode<T> * Creat( ); 
        void Release(BiNode<T> *root);
        void PreOrder(BiNode<T> *root); 
        void InOrder(BiNode<T> *root); 
        void PostOrder(BiNode<T> *root); 
        void LevelOrder(BiNode<T> *root);
 };

前序遍历——递归

template   <class T>
void   BiTree::PreOrder(BiNode<T> *root) 
{
        if (root ==NULL)  return;     
        else {
            cout<<root->data;         
            PreOrder(           );    
            PreOrder(           );    
        }
 }

前序遍历——非递归

template <class T>
void BiTree::PreOrder(BiNode<T> *root) {
  SeqStack<BiNode<T> *>  s;
     while (root!=NULL | | !s.empty()) {
         while (root!= NULL)  {
             cout<<root->data;
             s.push（root）;
             root=root->lchild;  
         }
         if (!s.empty()) { 
             root=s.pop();
             root=root->rchild;  
         }
     }
}

中序遍历——递归

template <class T>
void BiTree::InOrder (BiNode<T> *root)
{
         if (root==NULL) return;     
         else {
               InOrder(root->lchild); 
               cout<<root->data; 
               InOrder(root->rchild);
         }
}

中序遍历——非递归

template <class T>
void BiTree::InOrderwithoutD (BiNode<T> *root)
	 {
     	stack< BiNode<T> * > aStack;
     	while(!aStack.empty()||root) {
     	while(root){
  aStack.push(root);
  root=root->lchild; 	 
}
  	  if(!aStack.empty()){
		      root=aStack.top();				
		      aStack.pop(); 
                 cout<<root->data;
                 root=root->rchild; 
	   }
  }
  }

后序遍历——递归

template <class T>
void BiTree::PostOrder(BiNode<T> *root)
{ 
    if (root==NULL) return; 
    else {
         PostOrder(root->lchild); 
         PostOrder(root->rchild); 
         cout<<root->data;          
    }
}

后序遍历——非递归

void tree::T_print(bnode *bt){
    stack<bnode*> s;
    bnode *cur， *pre=NULL;
    if (root==NULL) return;
    s.push(bt);
    while (!s.empty())    {
        cur=s.top();
        if ((cur->Lchild==NULL&&cur->Rchild==NULL)    ||(pre!=NULL&&(pre==cur->Lchild||pre==cur->Rchild)))
        {
            cout<<cur->data;            s.pop();            pre=cur;
        }
        else
        {
            if (cur->Rchild!=NULL)            s.push(cur->Rchild);
            if (cur->Lchild!=NULL)            s.push(cur->Lchild);
        }
    }
}

二叉树的建立

按扩展前序遍历序列输入结点的值
如果输入结点值为“#”,则建立一棵空的子树
否则，根结点申请空间，将输入值写入数据域中
以相同方法的创建根结点的左子树
以相同的方法创建根结点的右子树
递归方法

template <class T>
BiTree ::BiTree(){ 
      root=creat()；
}

template <class T>
BiNode<T> * BiTree ::Creat(){
     BiNode<T> *root; char ch;
    cin>>ch;
    if (ch=='# ')     root=NULL; 
    else {
        root=new BiNode<T>; 
        root->data=ch;
        root->lchild=creat(); 
        root->rchild= creat(); 
    }  
  return root
}

类的声明

template <class T>
class BiTree{
public:
       BiTree(); 
        ~BiTree( );            
        void PreOrder(){PreOrder(root);} 
        void InOrder() {InOrder(root);} 
        void PostOrder() {PostOrder(root);} 
        void LevelOrder();
  private:
        BiNode<T> *root; 
        void Creat(BiNode<T> *& root); 
        void Release(BiNode<T> *root);
        void PreOrder(BiNode<T> *root); 
        void InOrder(BiNode<T> *root); 
        void PostOrder(BiNode<T> *root); 
        void LevelOrder(BiNode<T> *root);
};

template<class T>
BiTree<T>::BiTree( )
{
	Creat(root);
}

template <class T>
void BiTree<T>::Creat(BiNode<T> * &root  )
{
	    T ch;
	    cout<<"请输入创建一棵二叉树的结点数据"<<endl;
	    cin>>ch;
         if (ch=="#") root = NULL;
         else{ 
	           root = new BiNode<T>;       //生成一个结点
                root->data=ch;
               Creat(root->lchild );    //递归建立左子树
               Creat(root->rchild);    //递归建立右子树
    } 
}

template<class T>
void BiTree<T>::~BiTree(BiNode<T>* root){
  if (root != NULL){                  
      Release(root->lchild);   //释放左子树
      Release(root->rchild);   //释放右子树
      delete root;
  }  
}