数据结构类型定义及基本操作汇总(二)-- 二叉树及其遍历

二叉树部分比较多,单列一章,包括二叉树的三种存储结构(顺序,链式,广义表)和先序中序后序的递规以及非递规算法, 应该对大家有些帮助:

//二叉树

//顺序存储结构
//normal
#define Maxsize 10;
typedef struct{
    ElemType data;
    int lchild;
    int rchild;
    }BitTNode;

typedef BitTNode SqBiTree[Maxsize];

SqBiTree bt;

//special
#define Maxsize 11;//add one null node

//以下为链式存储结构

//标准形式
typedef struct BiNode{
    ElemType data;
    struct BiNode *lchild;
    struct BiNode *rchild;
}BiNode,*BiTree;

BiTree p;

//广义表形式
typedef struct BiNode{
    ElemType data;
    struct BiNode *lchild;
    struct BiNode *rchild;
    struct BiNode *parent;
}BiNode,*BiTree;
   
BiTree p;

//递规算法，不考虑异常
 //（1）先序遍历递归算法
void PreOrder(BTree BT) {
     if (BT) { Visit(BT);
     PreOrder(BT->Lchild);
     PreOrder(BT->Rchild);
}

//（2）中序遍历递归算法
void InOrder(BTree BT) {
     if (BT) {
        InOrder(BT->Lchild);
        Visit(BT);
        InOrder(BT->Rchild);
      }
   }

//（3）后序遍历递归算法
void PostOrder(BTree BT) {
    if (BT) {
       PostOrder(BT->Lchild);
       PostOrder(BT->Rchild);
       Visit(BT);
      }
}

//非递规算法
//1.先序遍历非递归算法 
  #define   maxsize   100 
  typedef   struct 
  { 
          Bitree   Elem[maxsize]; 
          int   top; 
  }SqStack; 
  
  void   PreOrderUnrec(Bitree   t) 
  { 
          SqStack   s; 
          StackInit(s); 
          p=t; 
          
          while   (p!=null   ||   !StackEmpty(s)) 
          { 
                  while   (p!=null)                           //遍历左子树 
                  { 
                          visite(p->data); 
                          push(s,p); 
                          p=p->lchild;               
                  }//endwhile 
                  
                  if   (!StackEmpty(s))                   //通过下一次循环中的内嵌while实现右子树遍历 
                  { 
                          p=pop(s); 
                          p=p->rchild;                 
                  }//endif 
                                  
          }//endwhile   
          
  }//PreOrderUnrec 
  
  //2.中序遍历非递归算法 
  #define   maxsize   100 
  typedef   struct 
  { 
          Bitree   Elem[maxsize]; 
          int   top; 
  }SqStack; 
  
  void   InOrderUnrec(Bitree   t) 
  { 
          SqStack   s; 
          StackInit(s); 
          p=t; 
          while   (p!=null   ||   !StackEmpty(s)) 
          { 
                  while   (p!=null)                           //遍历左子树 
                  { 
                          push(s,p); 
                          p=p->lchild; 
                  }//endwhile 
                  
                  if   (!StackEmpty(s)) 
                  { 
                          p=pop(s); 
                          visite(p->data);                 //访问根结点 
                          p=p->rchild;                         //通过下一次循环实现右子树遍历 
                  }//endif       
          
          }//endwhile 
  
  }//InOrderUnrec 
  
  
  //3.后序遍历非递归算法 
  #define   maxsize   100 
  typedef   enum{L,R}   tagtype; 
  typedef   struct   
  { 
          Bitree   ptr; 
          tagtype   tag; 
  }stacknode; 
  
  typedef   struct 
  { 
          stacknode   Elem[maxsize]; 
          int   top; 
  }SqStack; 
  
  void   PostOrderUnrec(Bitree   t) 
  { 
          SqStack   s; 
          stacknode   x; 
          StackInit(s); 
          p=t; 
          
          do   
          { 
                  while   (p!=null)                 //遍历左子树 
                  { 
                          x.ptr   =   p;   
                          x.tag   =   L;                   //标记为左子树 
                          push(s,x); 
                          p=p->lchild; 
                  } 
          
                  while   (!StackEmpty(s)   &&   s.Elem[s.top].tag==R)     
                  { 
                          x   =   pop(s); 
                          p   =   x.ptr; 
                          visite(p->data);       //tag为R，表示右子树访问完毕，故访问根结点               
                  } 
                  
                  if   (!StackEmpty(s)) 
                  { 
                          s.Elem[s.top].tag   =R;           //遍历右子树 
                          p=s.Elem[s.top].ptr->rchild;                 
                  }         
          }while   (!StackEmpty(s)); 
  }//PostOrderUnrec