user-0 提问: 二叉树递归和非递归遍历

回复:
user: user-1
content: #include <iostream> #include<string.h> #include<stack> #include <stdio.h> #include <stdio.h> #include <stdlib.h> using namespace std;  typedef struct node {     char data;     struct node *lchild,*rchild; }BinTree;  typedef struct node1 {     BinTree *btnode;     bool isFirst; }BTNode;   void creatBinTree(char *s,BinTree *&root)  //创建二叉树，s为形如A(B,C(D,E))形式的字符串  {     int i;     bool isRight=false;     stack<BinTree*> s1;          //存放结点      stack<char> s2;              //存放分隔符     BinTree *p,*temp;     root->data=s[0];     root->lchild=NULL;     root->rchild=NULL;     s1.push(root);     i=1;     while(i<strlen(s))     {         if(s[i]=='(')         {             s2.push(s[i]);             isRight=false;         }             else if(s[i]==',')             {             isRight=true;         }         else if(s[i]==')')         {             s1.pop();             s2.pop();         }         else if(isalpha(s[i]))         {             p=(BinTree *)malloc(sizeof(BinTree));             p->data=s[i];             p->lchild=NULL;             p->rchild=NULL;             temp=s1.top();             if(isRight==true)                 {                 temp->rchild=p;                 cout<<temp->data<<"的右孩子是"<<s[i]<<endl;             }             else             {                 temp->lchild=p;                 cout<<temp->data<<"的左孩子是"<<s[i]<<endl;             }             if(s[i+1]=='(')                 s1.push(p);         }         i++;     }     }  void display(BinTree *root)        //显示树形结构  {     if(root!=NULL)     {         cout<<root->data;         if(root->lchild!=NULL)         {             cout<<'(';             display(root->lchild);         }         if(root->rchild!=NULL)         {             cout<<',';             display(root->rchild);             cout<<')';         }     } }  void preOrder1(BinTree *root)     //递归前序遍历  {     if(root!=NULL)     {         cout<<root->data<<" ";         preOrder1(root->lchild);         preOrder1(root->rchild);     } }  void inOrder1(BinTree *root)      //递归中序遍历 {     if(root!=NULL)     {         inOrder1(root->lchild);         cout<<root->data<<" ";         inOrder1(root->rchild);     } }   void postOrder1(BinTree *root)    //递归后序遍历 {     if(root!=NULL)     {         postOrder1(root->lchild);         postOrder1(root->rchild);         cout<<root->data<<" ";     }     }   void preOrder2(BinTree *root)     //非递归前序遍历  {     stack<BinTree*> s;     BinTree *p=root;     while(p!=NULL||!s.empty())     {         while(p!=NULL)         {             cout<<p->data<<" ";             s.push(p);             p=p->lchild;         }         if(!s.empty())         {             p=s.top();             s.pop();             p=p->rchild;         }     } }  void inOrder2(BinTree *root)      //非递归中序遍历 {     stack<BinTree*> s;     BinTree *p=root;     while(p!=NULL||!s.empty())     {         while(p!=NULL)         {             s.push(p);             p=p->lchild;         }         if(!s.empty())         {             p=s.top();             cout<<p->data<<" ";             s.pop();             p=p->rchild;         }     }     }   void postOrder2(BinTree *root)    //非递归后序遍历 {     stack<BTNode*> s;     BinTree *p=root;     BTNode *temp;     while(p!=NULL||!s.empty())     {         while(p!=NULL)              //沿左子树一直往下搜索，直至出现没有左子树的结点           {             BTNode *btn=(BTNode *)malloc(sizeof(BTNode));             btn->btnode=p;             btn->isFirst=true;             s.push(btn);             p=p->lchild;         }         if(!s.empty())         {             temp=s.top();             s.pop();             if(temp->isFirst==true)     //表示是第一次出现在栈顶               {                 temp->isFirst=false;                 s.push(temp);                 p=temp->btnode->rchild;                 }             else                        //第二次出现在栈顶               {                 cout<<temp->btnode->data<<" ";                 p=NULL;             }         }     }     }   void postOrder3(BinTree *root)     //非递归后序遍历 {     stack<BinTree*> s;     BinTree *cur;                      //当前结点      BinTree *pre=NULL;                 //前一次访问的结点      s.push(root);     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);         }     }     }   int main(int argc, char *argv[]) {     char s[100];     while(scanf("%s",s)==1)     {         BinTree *root=(BinTree *)malloc(sizeof(BinTree));         creatBinTree(s,root);         display(root);         cout<<endl;         preOrder2(root);         cout<<endl;          inOrder2(root);         cout<<endl;         postOrder2(root);         cout<<endl;         postOrder3(root);         cout<<endl;     }     return 0; }

user: user-2
content: 仅供参考：#include <iostream> #include <stack> #include <queue> #include <locale.h> using namespace std; typedef struct BiTNode {//二叉树结点     char data;                      //数据     struct BiTNode *lchild,*rchild; //左右孩子指针 } BiTNode,*BiTree; int CreateBiTree(BiTree &T) {//按先序序列创建二叉树     char data;     scanf("%c",&data);//按先序次序输入二叉树中结点的值（一个字符），‘#’表示空树     if (data == '#') {         T = NULL;     } else {         T = (BiTree)malloc(sizeof(BiTNode));         T->data = data;         //生成根结点         CreateBiTree(T->lchild);//构造左子树         CreateBiTree(T->rchild);//构造右子树     }     return 0; } void Visit(BiTree T) {//输出     if (T->data != '#') {         printf("%c ",T->data);     } } void PreOrder(BiTree T) {//先序遍历     if (T != NULL) {         Visit(T);               //访问根节点         PreOrder(T->lchild);    //访问左子结点         PreOrder(T->rchild);    //访问右子结点     } } void InOrder(BiTree T) {//中序遍历     if (T != NULL) {         InOrder(T->lchild);     //访问左子结点         Visit(T);               //访问根节点         InOrder(T->rchild);     //访问右子结点     } } void PostOrder(BiTree T) {//后序遍历     if (T != NULL) {         PostOrder(T->lchild);   //访问左子结点         PostOrder(T->rchild);   //访问右子结点         Visit(T);               //访问根节点     } } void PreOrder2(BiTree T) {//先序遍历(非递归) //访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。     stack<BiTree> stack;     BiTree p = T;//p是遍历指针     while (p || !stack.empty()) {   //栈不空或者p不空时循环         if (p != NULL) {             stack.push(p);          //存入栈中             printf("%c ",p->data);  //访问根节点             p = p->lchild;          //遍历左子树         } else {             p = stack.top();        //退栈             stack.pop();             p = p->rchild;          //访问右子树         }     } } void InOrder2(BiTree T) {//中序遍历(非递归) //T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。 //先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。     stack<BiTree> stack;     BiTree p = T;//p是遍历指针     while (p || !stack.empty()) {   //栈不空或者p不空时循环         if (p != NULL) {             stack.push(p);          //存入栈中             p = p->lchild;          //遍历左子树         } else {             p = stack.top();        //退栈，访问根节点             printf("%c ",p->data);             stack.pop();             p = p->rchild;          //访问右子树         }     } }  typedef struct BiTNodePost{     BiTree biTree;     char tag; } BiTNodePost,*BiTreePost; void PostOrder2(BiTree T) {//后序遍历(非递归)     stack<BiTreePost> stack;     BiTree p = T;//p是遍历指针     BiTreePost BT;     while (p != NULL || !stack.empty()) {//栈不空或者p不空时循环         while (p != NULL) {//遍历左子树             BT = (BiTreePost)malloc(sizeof(BiTNodePost));             BT->biTree = p;             BT->tag = 'L';//访问过左子树             stack.push(BT);             p = p->lchild;         }         while (!stack.empty() && (stack.top())->tag == 'R') {//左右子树访问完毕访问根节点             BT = stack.top();             stack.pop();//退栈             printf("%c ",BT->biTree->data);         }         if (!stack.empty()) {//遍历右子树             BT = stack.top();             BT->tag = 'R';//访问过右子树             p = BT->biTree;             p = p->rchild;         }     } }  void LevelOrder(BiTree T) {//层次遍历     if (T == NULL) return;     BiTree p = T;     queue<BiTree> queue;//队列     queue.push(p);//根节点入队     while (!queue.empty()) {    //队列不空循环         p = queue.front();      //对头元素出队         printf("%c ",p->data);  //访问p指向的结点         queue.pop();            //退出队列         if (p->lchild != NULL) {//左子树不空，将左子树入队             queue.push(p->lchild);         }         if (p->rchild != NULL) {//右子树不空，将右子树入队             queue.push(p->rchild);         }     } } int main() {     BiTree T;      setlocale(LC_ALL,"chs");     CreateBiTree(T);      printf("先序遍历        ：");PreOrder  (T);printf("\n");     printf("先序遍历(非递归)：");PreOrder2 (T);printf("\n");                                                printf("\n");     printf("中序遍历        ：");InOrder   (T);printf("\n");     printf("中序遍历(非递归)：");InOrder2  (T);printf("\n");                                                printf("\n");     printf("后序遍历        ：");PostOrder (T);printf("\n");     printf("后序遍历(非递归)：");PostOrder2(T);printf("\n");                                                printf("\n");     printf("层次遍历        ：");LevelOrder(T);printf("\n");      return 0; } //ABC##DE#G##F### //先序遍历        ：A B C D E G F //先序遍历(非递归)：A B C D E G F // //中序遍历        ：C B E G D F A //中序遍历(非递归)：C B E G D F A // //后序遍历        ：C G E F D B A //后序遍历(非递归)：C G E F D B A // //层次遍历        ：A B C D E F G //  ///       A ///      / ///     B ///    / \ ///   C   D ///      / \ ///     E   F ///      \ ///       G

user: user-3
content: typedef struct BiTNode{     char data; struct BiTNode *lchild, *rchild; }BiTNode;    /*少个分号*/ typedef BiTNode* BiTree;    /*少个分号*/

user: user-3
content: typedef struct BiTNode{     char data; struct BiTNode *lchild, *rchild; }BiTNode;    /*少个分号*/ typedef BiTNode* BiTree    /*少个分号*/ typedef不像宏定义，不需要分号。typedef是一条完整的语句，因此需要末尾的分号