1. #include<stdio.h> 
  2. #include<string.h> 
  3. #include<stdlib.h> 
  4. #define MAXSIZE 100 
  5. /*******************************************************************************/ 
  6. typedef char ElemType; 
  7. typedef struct BTNode{ 
  8.     ElemType data; 
  9.     struct BTNode *lchild; 
  10.     struct BTNode *rchild; 
  11. }BTNode,*pBTNode; 
  12. /*******************************************************************************/ 
  13. typedef struct BTStack{//定义栈用来处理树的遍历  
  14.     pBTNode data[MAXSIZE];//存储的是指向树结点的指针  
  15.     int top; 
  16.     int tag[MAXSIZE]; 
  17. }BTStack,*pBTStack; 
  18. void initBTStack(pBTStack pBTS){ 
  19.     pBTS->top = -1; 
  20. bool push(pBTStack pBTS,pBTNode pBTN){ 
  21.     if(pBTS->top == MAXSIZE-1){ 
  22.         puts("The stack is full."); 
  23.         return false
  24.     } 
  25.     else
  26.         pBTS->data[++(pBTS->top)] = pBTN; 
  27.         return true
  28.     } 
  29. pBTNode pop(pBTStack pBTS){ 
  30.     if(pBTS->top == -1){ 
  31.         puts("The stack is empty"); 
  32.         return NULL; 
  33.     } 
  34.     else
  35.         return pBTS->data[(pBTS->top)--]; 
  36.     } 
  37. /*******************************************************************************/ 
  38. typedef struct SqQueue{//定义一个循环队列来解决树的层次遍历  
  39.     pBTNode data[MAXSIZE];//存储的是指向树结点的指针  
  40.     int front; 
  41.     int rear; 
  42. }SqQueue,*pSqQueue; 
  43. void initSqQueue(pSqQueue pSQ){ 
  44.     pSQ->front = 0; 
  45.     pSQ->rear = 0; 
  46. int lengthSqQueue(pSqQueue pSQ){ 
  47.     return (MAXSIZE-pSQ->front+pSQ->rear)%MAXSIZE; 
  48. bool EnQueue(pSqQueue pSQ,pBTNode pBTN){ 
  49.     if((pSQ->rear+1)%MAXSIZE == pSQ->front){ 
  50.         puts("The Queue is full"); 
  51.         return false
  52.     } 
  53.     else
  54.         pSQ->data[pSQ->rear] = pBTN; 
  55.         pSQ->rear = (pSQ->rear+1)%MAXSIZE; 
  56.         return true
  57.     } 
  58. pBTNode DeQueue(pSqQueue pSQ){ 
  59.     if(pSQ->rear == pSQ->front){ 
  60.         puts("The Queue is empty"); 
  61.         return NULL; 
  62.     } 
  63.     else
  64.         pBTNode temp = (pBTNode)malloc(sizeof(BTNode));//临时指针指向要出栈的内容  
  65.         temp = pSQ->data[pSQ->front]; 
  66.         pSQ->front = (pSQ->front+1)%MAXSIZE; 
  67.         return temp; 
  68.     } 
  69. /*******************************************************************************/ 
  70. void PreOrderTraverse(pBTNode pBTN){//非递归前序遍历  
  71.     if(pBTN == NULL){ 
  72.         return
  73.     }else
  74.         BTStack BTS; 
  75.         pBTStack pBTS = &BTS; 
  76.         initBTStack(pBTS); 
  77.         while(pBTN || (pBTS->top!=-1)){//如果指针不空或者栈不空  
  78.             while(pBTN){//如果指针不空  
  79.                 printf("%c ",pBTN->data);//打印  
  80.                 push(pBTS,pBTN);//入栈  
  81.                 pBTN = pBTN->lchild; 
  82.             } 
  83.             pBTN = pop(pBTS);//出栈  
  84.             pBTN = pBTN->rchild;//转向右孩子方向搜索  
  85.         } 
  86.     } 
  87. void PreOrderTraverseR(pBTNode pBTN){//递归前序遍历  
  88.     if(pBTN==NULL){ 
  89.         return
  90.     } 
  91.     else
  92.         printf("%c ",pBTN->data); 
  93.         PreOrderTraverseR(pBTN->lchild); 
  94.         PreOrderTraverseR(pBTN->rchild); 
  95.     } 
  96. /*******************************************************************************/ 
  97. void InOrderTraverse(pBTNode pBTN){//非递归中序遍历  
  98.     if(pBTN==NULL){ 
  99.         return
  100.     } 
  101.     else
  102.         BTStack BTS; 
  103.         pBTStack pBTS = &BTS; 
  104.         initBTStack(pBTS); 
  105.          
  106.         while(pBTN || (pBTS->top!=-1)){ 
  107.             while(pBTN){ 
  108.                 push(pBTS,pBTN);//入栈  
  109.                 pBTN = pBTN->lchild; 
  110.             } 
  111.             pBTN = pop(pBTS);//出栈  
  112.             printf("%c ",pBTN->data);//打印  
  113.             pBTN = pBTN->rchild;//转向孩子方向  
  114.         } 
  115.     } 
  116. void InOrderTraverseR(pBTNode pBTN){//递归中序遍历  
  117.     if(pBTN==NULL){ 
  118.         return ; 
  119.     } 
  120.     else
  121.         InOrderTraverseR(pBTN->lchild); 
  122.         printf("%c ",pBTN->data); 
  123.         InOrderTraverseR(pBTN->rchild); 
  124.     } 
  125. /*******************************************************************************/ 
  126. void PostOrderTraverse(pBTNode pBTN){//非递归后序遍历  
  127.     if(pBTN==NULL){ 
  128.         return
  129.     } 
  130.     BTStack BTS; 
  131.     pBTStack pBTS = &BTS; 
  132.     initBTStack(pBTS); 
  133.      
  134.     while(pBTN || (pBTS->top!=-1)){ 
  135.         while(pBTN){ 
  136.             push(pBTS,pBTN); 
  137.             pBTS->tag[pBTS->top] = 0;//第一次入栈时,标识位为0  
  138.             pBTN = pBTN->lchild; 
  139.         } 
  140.         if(pBTS->tag[pBTS->top]==0){ 
  141.             pBTS->tag[pBTS->top] = 1;//第一次访问完成后,标志位为1  
  142.             pBTN = pBTS->data[pBTS->top]; 
  143.             pBTN = pBTN->rchild;//转向右孩子方向  
  144.         } 
  145.         else
  146.             while(pBTS->tag[pBTS->top]==1){//持续出栈  
  147.                 pBTN = pop(pBTS); 
  148.                 printf("%c ",pBTN->data); 
  149.             } 
  150.             pBTN = NULL;//出栈后就没用了,要丢弃  
  151.         } 
  152.     } 
  153. void PostOrderTraverseR(pBTNode pBTN){//递归后序遍历  
  154.     if(pBTN==NULL){ 
  155.         return ; 
  156.     } 
  157.     else
  158.         PostOrderTraverseR(pBTN->lchild); 
  159.         PostOrderTraverseR(pBTN->rchild); 
  160.         printf("%c ",pBTN->data); 
  161.     } 
  162. /*******************************************************************************/ 
  163. void LevelOrderTraverse(pBTNode pBTN){//层次遍历  
  164.     if(pBTN==NULL){ 
  165.         return ; 
  166.     } 
  167.     else
  168.         SqQueue SQ; 
  169.         pSqQueue pSQ = &SQ; 
  170.         initSqQueue(pSQ); 
  171.         EnQueue(pSQ,pBTN);//根结点先入队  
  172.         while(pSQ->front!=pSQ->rear){// 队不为空  
  173.             pBTN = DeQueue(pSQ);//出队  
  174.             printf("%c ",pBTN->data);//打印  
  175.             if(pBTN->lchild){//左孩子入队  
  176.                 EnQueue(pSQ,pBTN->lchild); 
  177.             } 
  178.             if(pBTN->rchild){//右孩子入队  
  179.                 EnQueue(pSQ,pBTN->rchild); 
  180.             } 
  181.         } 
  182.     } 
  183. /*******************************************************************************/ 
  184. void createBTree(pBTNode *ppBTN){//前序建立二叉树 ,传递的是指向树结点的指针的指针  
  185.     ElemType ch; 
  186.     scanf("%c",&ch); 
  187.     if(ch == '#'){//变为扩展二叉树  
  188.         *ppBTN = NULL; 
  189.     } 
  190.     else
  191.         (*ppBTN) = (pBTNode)malloc(sizeof(BTNode));//分配空间  
  192.         (*ppBTN)->data = ch;// 
  193.         createBTree(&((*ppBTN)->lchild));//处理左孩子  
  194.         createBTree(&((*ppBTN)->rchild));//处理右孩子  
  195.     } 
  196.  
  197. /*******************************************************************************/ 
  198. pBTNode searchTree(pBTNode pBTN,ElemType e){//搜索结点  
  199.      if(pBTN == NULL){ 
  200.          return NULL; 
  201.      } 
  202.      else if(pBTN->data == e){ 
  203.          return pBTN; 
  204.      } 
  205.      else
  206.          pBTNode temp = searchTree(pBTN->lchild,e);//临时指针存储搜索左孩子的结果  
  207.          if(temp == NULL){//如果没有搜索到就返回右孩子的搜索结果  
  208.              return searchTree(pBTN->rchild,e);// 
  209.          } 
  210.          else
  211.              return temp;// 搜索到了就返回左孩子的搜索结果  
  212.          } 
  213.      } 
  214. /*******************************************************************************/ 
  215. int countTree(pBTNode pBTN){//统计树的结点  
  216.     if(pBTN == NULL){ 
  217.         return 0; 
  218.     } 
  219.     else
  220.         return countTree(pBTN->lchild)+countTree(pBTN->rchild)+1;//递归  
  221.     } 
  222. /*******************************************************************************/ 
  223. int isEqual(pBTNode pBTN1,pBTNode pBTN2){//判断是否相等  
  224.     if(pBTN1 == NULL && pBTN2 == NULL){ 
  225.         return 1; 
  226.     } 
  227.     else if(pBTN1 && pBTN2 && pBTN1->data == pBTN2->data){//层层判断  
  228.              if(isEqual(pBTN1->lchild,pBTN2->lchild)){ 
  229.                  if(isEqual(pBTN1->rchild,pBTN2->rchild)){ 
  230.                      return 1; 
  231.                  } 
  232.              } 
  233.     } 
  234.     return 0; 
  235. /*******************************************************************************/ 
  236. int depthTree(pBTNode pBTN){//求树的深度  
  237.     int h,left,right; 
  238.     if(pBTN == NULL){ 
  239.         return 0; 
  240.     } 
  241.     else
  242.         left = depthTree(pBTN->lchild); 
  243.         right = depthTree(pBTN->rchild); 
  244.         h = (left>right)?(left+1):(right+1);//树的深度是左孩子和右孩子树深度的最大值+1  
  245.     } 
  246.     return h; 
  247. /*******************************************************************************/ 
  248. int main(void){//测试代码  
  249.     pBTNode pHead; 
  250.     createBTree(&pHead); 
  251.      
  252.     /*PreOrderTraverse(pHead);//测试遍历  
  253.     puts(""); 
  254.     PreOrderTraverseR(pHead); 
  255.     puts(""); 
  256.     InOrderTraverse(pHead); 
  257.     puts(""); 
  258.     InOrderTraverseR(pHead); 
  259.     puts(""); 
  260.     PostOrderTraverse(pHead); 
  261.     puts(""); 
  262.     PostOrderTraverseR(pHead); 
  263.     puts(""); 
  264.     LevelOrderTraverse(pHead); 
  265.     puts("");*/ 
  266.      
  267.     /*pBTNode search;//测试搜索  
  268.     search = searchTree(pHead,'Z'); 
  269.     if(search){ 
  270.         printf("%c",search->data); 
  271.     } 
  272.     else{ 
  273.         puts("No that one"); 
  274.     }*/ 
  275.      
  276.     /*printf("%d",countTree(pHead));*//测试统计结点数  
  277.      
  278.     /*puts("Done");//测试是否两棵树相等  
  279.     while(getchar()!='\n') 
  280.         continue; 
  281.     pBTNode pHead1; 
  282.     createBTree(&pHead1); 
  283.     puts("Done"); 
  284.    printf("%d",isEqual(pHead1,pHead));*/ 
  285.      
  286.     /*printf("%d",depthTree(pHead));*//测试树的深度  
  287.      
  288.     while(getchar()!='\n'
  289.         continue
  290.     getchar(); 
  291.     return 0;