二叉树的广度遍历和深度遍历（）

图的深度优先搜索法是树的先根遍历的推广，它的基本思想是：从图G的某个顶点v0出发，访问v0，然后选择一个与v0相邻且没被访问过的顶点vi访问，再从vi出发选择一个与vi相邻且未被访问的顶点vj进行访问，依次继续。如果当前被访问过的顶点的所有邻接顶点都已被访问，则退回到已被访问的顶点序列中最后一个拥有未被访问的相邻顶点的顶点w，从w出发按同样的方法向前遍历，直到图中所有顶点都被访问。

图的广度优先搜索是树的按层次遍历的推广，它的基本思想是：首先访问初始点vi，并将其标记为已访问过，接着访问vi的所有未被访问过的邻接点vi1,vi2, …, vi t，并均标记已访问过，然后再按照vi1,vi2, …, vi t的次序，访问每一个顶点的所有未被访问过的邻接点，并均标记为已访问过，依次类推，直到图中所有和初始点vi有路径相通的顶点都被访问过为止。

二叉树的深度优先遍历的非递归的通用做法是采用栈，广度优先遍历的非递归的通用做法是采用队列。

[cpp]  view plain copy

1. #include <stdlib.h>  
2. #include <stdio.h>  
3. #include <math.h>  
4.   
5. /* 函数结果状态代码 */  
6. #define TRUE 1  
7. #define FALSE 0  
8. #define OK 1  
9. #define ERROR 0  
10. #define INFEASIBLE -1  
11. #define OVERFLOW  3  
12. #define MAXSIZE 100 /* 存储空间初始分配量 */  
13.   
14. typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */  
15. typedef char ElemType;   
16.   
17. typedef struct BiTNode {  
18.     ElemType data;  
19.     struct BiTNode *lchild, *rchild; /* 左右孩子指针 */  
20. } BiTNode, *BiTree;  
21.   
22. /* 链栈结构 */  
23. typedef struct StackNode  
24. {  
25.     BiTNode data;  
26.     struct StackNode *next;  
27. }StackNode,*LinkStackPtr;  
28.   
29. typedef struct  
30. {  
31.     LinkStackPtr top;  
32.     int count;  
33. }LinkStack;  
34.   
35. /*队列结构*/  
36. typedef struct QNode {  
37.     BiTNode data;  
38.     struct QNode *next;  
39. } QNode, *QueuePtr;  
40.   
41. typedef struct {  
42.     QueuePtr front, rear; /* 队头、队尾指针 */  
43. } LinkQueue;  
44.   
45. /* 链队列 的基本操作*/  
46. void InitQueue(LinkQueue *Q)  
47. {  
48.     /* 构造一个空队列Q */  
49.     (*Q).front = (*Q).rear = (QueuePtr)malloc(100*sizeof(QNode));  
50.     if(!(*Q).front)  
51.         exit(OVERFLOW);  
52.     (*Q).front->next = NULL;  
53. }  
54. void DestroyQueue(LinkQueue *Q)  
55. {  
56.     /* 销毁队列Q(无论空否均可) */  
57.     while((*Q).front) {  
58.         (*Q).rear = (*Q).front->next;  
59.         free((*Q).front);  
60.         (*Q).front = (*Q).rear;  
61.     }  
62. }  
63. Status QueueEmpty(LinkQueue Q)  
64. {  
65.     /* 若Q为空队列，则返回TRUE，否则返回FALSE */  
66.     if(Q.front->next == NULL)  
67.         return TRUE;  
68.     else  
69.         return FALSE;  
70. }  
71. Status GetHead_Q(LinkQueue Q, BiTNode *e) /* 避免与bo2-6.c重名 */  
72. {  
73.     /* 若队列不空，则用e返回Q的队头元素，并返回OK，否则返回ERROR */  
74.     QueuePtr p;  
75.     if(Q.front == Q.rear)  
76.         return ERROR;  
77.     p = Q.front->next;  
78.     *e = p->data;  
79.     return OK;  
80. }  
81. void EnQueue(LinkQueue *Q, BiTNode e)  
82. {  
83.     /* 插入元素e为Q的新的队尾元素 */  
84.     QueuePtr p = (QueuePtr)malloc(sizeof(QNode));  
85.     if(!p) /* 存储分配失败 */  
86.         exit(OVERFLOW);  
87.     p->data =e;  
88.     p->next = NULL;  
89.     (*Q).rear->next = p;  
90.     (*Q).rear = p;  
91. }  
92. Status DeQueue(LinkQueue *Q, BiTNode *e)  
93. {  
94.     /* 若队列不空，删除Q的队头元素，用e返回其值，并返回OK，否则返回ERROR */  
95.     QueuePtr p;  
96.     if((*Q).front == (*Q).rear)  
97.         return ERROR;  
98.     p = (*Q).front->next;  
99.     *e = p->data;  
100.     (*Q).front->next = p->next;  
101.     if((*Q).rear == p)  
102.         (*Q).rear = (*Q).front;  
103.     free(p);  
104.     return OK;  
105. }  
106. //#####################################################//  
107.   
108. /* 链栈的基本操作*/  
109. /*  构造一个空栈S */  
110. Status InitStack(LinkStack *S)  
111. {   
112.     S->top = (LinkStackPtr)malloc(sizeof(StackNode));  
113.     if(!S->top)  
114.             return ERROR;  
115.     S->top=NULL;  
116.     S->count=0;  
117.     return OK;  
118. }  
119.   
120. /* 把S置为空栈 */  
121. Status ClearStack(LinkStack *S)  
122. {   
123.     LinkStackPtr p,q;  
124.     p=S->top;  
125.     while(p)  
126.     {    
127.         q=p;  
128.         p=p->next;  
129.         free(q);  
130.     }   
131.     S->count=0;  
132.     return OK;  
133. }  
134.   
135. /* 若栈S为空栈，则返回TRUE，否则返回FALSE */  
136. Status StackEmpty(LinkStack S)  
137. {   
138.     if (S.count==0)  
139.         return TRUE;  
140.     else  
141.         return FALSE;  
142. }  
143.   
144. /* 返回S的元素个数，即栈的长度 */  
145. int StackLength(LinkStack S)  
146. {   
147.     return S.count;  
148. }  
149.   
150. /* 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR */  
151. Status GetTop(LinkStack S, BiTNode *e)  
152. {  
153.     if (S.top==NULL)  
154.         return ERROR;  
155.     else  
156.         *e=S.top->data;  
157.     return OK;  
158. }  
159.   
160. /* 插入元素e为新的栈顶元素 */  
161. Status Push(LinkStack *S, BiTNode e)  
162. {  
163.     LinkStackPtr s=(LinkStackPtr)malloc(sizeof(StackNode));   
164.     s->data=e;   
165.     s->next=S->top;   /* 把当前的栈顶元素赋值给新结点的直接后继*/  
166.     S->top=s;         /* 将新的结点s赋值给栈顶指针*/  
167.     S->count++;  
168.     return OK;  
169. }  
170.   
171. /* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */  
172. Status Pop(LinkStack *S, BiTNode *e)  
173. {   
174.     LinkStackPtr p;  
175.     if(StackEmpty(*S))  
176.         return ERROR;  
177.     *e=S->top->data;  
178.     p=S->top;                /* 将栈顶结点赋值给p */  
179.     S->top=S->top->next;    /* 使得栈顶指针下移一位，指向后一结点*/  
180.     free(p);                /* 释放结点p */          
181.     S->count--;  
182.     return OK;  
183. }  
184.   
185. /* 用于构造二叉树********************************** */  
186. int count=1;  
187. typedef char String[100]; /*  0号单元存放串的长度 */  
188. String str;  
189.   
190. Status StrAssign(String T,char *chars)  
191. {   
192.     int i;  
193.     if(strlen(chars)>MAXSIZE)  
194.         return ERROR;  
195.     else  
196.     {  
197.         T[0]=strlen(chars);  
198.         for(i=1;i<=T[0];i++)  
199.             T[i]=*(chars+i-1);  
200.         return OK;  
201.     }  
202. }  
203. /* ************************************************ */  
204.   
205. void CreateBiTree(BiTree *T)  
206. {  
207.     /* 按先序次序输入二叉树中结点的值(此处字符型)*/  
208.     /* 构造二叉链表表示的二叉树T。 */  
209.     ElemType ch;  
210.     ch=str[count++];  
211.     if(ch == '#') /* 空 */  
212.         *T = NULL;  
213.     else {  
214.         *T = (BiTree)malloc(sizeof(BiTNode)); /* 生成根结点 */  
215.         if(!*T)  
216.             exit(OVERFLOW);  
217.         (*T)->data = ch;  
218.         CreateBiTree(&(*T)->lchild); /* 构造左子树 */  
219.         CreateBiTree(&(*T)->rchild); /* 构造右子树 */  
220.     }  
221. }  
222.   
223. void InitBiTree(BiTree *T)  
224. {  
225.     /* 操作结果：构造空二叉树T */  
226.     *T = NULL;  
227. }  
228.   
229. void DestroyBiTree(BiTree *T)  
230. {  
231.     /* 初始条件：二叉树T存在。操作结果：销毁二叉树T */  
232.     if(*T) { /* 非空树 */  
233.         if((*T)->lchild) /* 有左孩子 */  
234.             DestroyBiTree(&(*T)->lchild); /* 销毁左孩子子树 */  
235.         if((*T)->rchild) /* 有右孩子 */  
236.             DestroyBiTree(&(*T)->rchild); /* 销毁右孩子子树 */  
237.         free(*T); /* 释放根结点 */  
238.         *T = NULL; /* 空指针赋0 */  
239.     }  
240. }  
241.   
242. /*广度优先遍历，层序*/  
243. void BFSTree(BiTree T)  
244. {  
245.     LinkQueue Q;  
246.     BiTNode e;  
247.     InitQueue(&Q);  
248.     EnQueue(&Q,*T);  
249.     printf("BFSTree: ");  
250.     while(!QueueEmpty( Q)){  
251.         DeQueue(&Q, &e);  
252.         printf("%c",e.data);  
253.         if(T->lchild != NULL)  
254.         {  
255.             EnQueue(&Q, *(T->lchild));  
256.         }  
257.         if(T->rchild != NULL)  
258.         {  
259.             EnQueue(&Q, *(T->rchild));  
260.         }  
261.         GetHead_Q(Q,  &e);  
262.         T = &e;       
263.     }  
264.     printf("\n");  
265.     DestroyQueue(&Q);  
266. }  
267.   
268. /*深度优先遍历，前序*/  
269. void DFSTree(BiTree T)  
270. {  
271.     LinkStack S;  
272.     BiTNode e;  
273.     InitStack(&S);  
274.     Push(&S, *T);  
275.     printf("DFSTree: ");  
276.     while(!StackEmpty(S)){  
277.         Pop(&S, &e);  
278.         printf("%c",e.data);  
279.         if(T->rchild != NULL)  
280.         {  
281.             Push(&S, *(T->rchild));  
282.         }  
283.         if(T->lchild != NULL)  
284.         {  
285.             Push(&S, *(T->lchild));  
286.         }     
287.         GetTop(S, &e);  
288.         T = &e;   
289.     }  
290.     printf("\n");  
291.     ClearStack(&S);  
292. }  
293.   
294.   
295. int main(void)  
296. {  
297.     BiTree t;  
298.   
299.     InitBiTree(&t);  
300.     StrAssign(str,"abd##e##cf##g##");  
301.   
302.     CreateBiTree(&t);  
303.     BFSTree(t);  
304.     DFSTree(t);  
305.     DestroyBiTree(&t);  
306. }  

转自：http://blog.youkuaiyun.com/xingfudage1986/article/details/6834901

。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

#include"iostream.h"
template <class T>
struct BiNode
{
 T data;
 BiNode<T>*lchild, * rchild;
};
template <class T>
class BiTree
{
 private:
  BiNode <T>*root;
  void creat(BiNode<T>*&r);
  void Release(BiNode<T>*r);
  void Preorder(BiNode<T>*r);
  void Inorder(BiNode<T>*r);
  void Postorder(BiNode<T>*r);
  void Levelorder(BiNode<T>*r);
 public:
  BiTree()
  {
   root=NULL;creat(root);
  }
  ~BiTree()
  {
   Release(root);
  }
  void Pre()
  {
   Preorder(root);
  }
  void In()
  {
   Inorder(root);
  }
  void Post()
  {
   Postorder(root);
  }
  void Level()
  {
   Levelorder(root);
  }
};
template<class T>
void BiTree<T>::Levelorder (BiNode<T>*r)//层序遍历
{
 BiNode<T>*Q[100];
 int front,rear;
    BiNode<T>* q;
 front=rear=0;
 if(r==NULL)return;
 Q[++rear]=r;
 while(front!=rear)
 {
  q=Q[++front];
  cout<<q->data;
  if(q->lchild!=NULL)
   Q[++rear]=q->lchild;
  if(q->rchild!=NULL)
   Q[++rear]=q->rchild;
 }
}
template<class T>
void BiTree<T>::Preorder (BiNode<T>*r)//前序遍历
{
 if(r==NULL) return;
 else
 {
  cout<<r->data;
  Preorder(r->lchild);
  Preorder(r->rchild);
 }
}
template<class T>
void BiTree<T>::Postorder (BiNode<T>*r)//后序遍历
{
 if(r==NULL) return;
 else
 {
  Postorder(r->lchild);
  Postorder(r->rchild);
  cout<<r->data;
 }
}
template<class T>
void BiTree<T>::Inorder (BiNode<T>*r)//中序遍历
{
 if(r==NULL) return;
 else
 {
  Inorder(r->lchild);
  cout<<r->data;
     Inorder(r->rchild);
 }
}
template<class T>
void BiTree<T>::creat (BiNode<T> *&r)
{
 char ch;
 cin>>ch;
 if(ch=='#')r=NULL;//#表示空节点
 else
 {
  r=new BiNode<T>;
  r->data=ch;
  creat(r->lchild);
  creat(r->rchild);
 }
}
template<class T>
void BiTree<T>::Release (BiNode<T>*r)
{
 if(r!=NULL)
 {
  Release(r->lchild);
     Release(r->rchild);
     delete r;
 }
}
void main()
{
 BiTree<char> au;
   cout<<"输出后序遍历:"<<endl;
   au.Post ();
   cout<<endl;
   cout<<"输出中序遍历:"<<endl;
   au.In ();
   cout<<endl;
   cout<<"输出层序遍历:"<<endl;
   au.Level ();
   cout<<endl;
   cout<<"输出前序遍历:"<<endl;
   au.Pre ();
   cout<<endl;
}

。。。。。。。。。。。。。。。。。

可运行代码：(转自： http://www.cnblogs.com/hicjiajia/archive/2010/08/27/1810055.html)

#include <iostream>
  using namespace std;
 typedef struct node {
         char data;
         struct node *lchild;
         struct node *rchild;
         }BiNode,*BiTree;
 typedef struct node1{
         BiTree data[30];     //默认30个元素 ，这里需要一个辅助堆栈！！！
         int top;
         }Stack;
         
 void createTree(BiTree &T)   //先序递归创建树，这里注意参数的类型，T的类型是 "*&" ,如果是 "**" 代码稍加改动就OK...
 {
      char ch;
      cin.get(ch).get();      //过滤输入流中每次回车产生的回车符
      if (ch==' ') T=NULL;    //这里首先判断是不是空格，如果是，则为该节点赋NULL
      else{
             T=(BiTree)malloc(sizeof(BiNode));
             T->data=ch;
             createTree(T->lchild);
             createTree(T->rchild);
           }
 }
 void initstack(Stack *&st)
 {
      st=(Stack *)malloc(sizeof(Stack));
      st->top=-1;
 }
 bool isempty(Stack *st)
 {
     return st->top==-1;
 }
 bool isfull(Stack *st)
 {
     return st->top==19;
 }
 void push(Stack *st,BiTree T)
 {
      if (!isfull(st))
      st->data[++st->top]=T;     //栈顶指针始终指向堆栈最上面可用的一个元素，因此入栈时候，先要将指针加1,然后再执行入栈操作！
      else cout<<"已满"<<endl;
 }
 BiTree pop(Stack *st)
 {
      if (!isempty(st)) return st->data[st->top--];
 }
 BiTree gettop(Stack *st)
 {
        if (!isempty(st)) return st->data[st->top];  //出栈时，先取出栈顶指针指向的元素，然后再将指针减1，使其指向栈中下一个可用元素！
 }
 void preOrderNoRe(BiTree T)          // 前序遍历
 {
    Stack *st;
    initstack(st);
    BiTree p;
    p=T;
      while (p!=NULL||!isempty(st))
      {
            while (p!=NULL)
            {
                  cout<<p->data<<"  ";
                  push(st,p);
                  p=p->lchild;
            }
            if (!isempty(st))
            {
                        p=pop(st);
                        p=p->rchild;
            }
            
      }
 }
 void inOrderNoRe(BiTree T)       //中序遍历
 {
    Stack *st;
    initstack(st);
    BiTree p;
    p=T;
      while (p!=NULL||!isempty(st))
      {
            while (p!=NULL)
            {
                  push(st,p);
                  p=p->lchild;
            }
            if (!isempty(st))
            {
                        p=pop(st);
                        cout<<p->data<<"  ";
                        p=p->rchild;
            }
            
      }
 }
 void postOrderNoRe(BiTree T)          //后序遍历
 {
      BiTree p;
      Stack *st;
      initstack(st);
      p=T;
      int Tag[20];      //栈，用于标识从左（0）或右（1）返回 
      while (p!=NULL || !isempty(st))
      {
            while (p!=NULL)
            {
                  push(st,p);
                  Tag[st->top]=0;
                  p=p->lchild;
            }
            while (!isempty(st)&&Tag[st->top]==1)
            {
                  p=pop(st);
                  cout<<p->data<<"  ";
            }
            if (!isempty(st))
            {
                             Tag[st->top]=1;   //设置标记右子树已经访问 
                             p=gettop(st);
                             p=p->rchild;
            }
            else break;
      }
 }
 int main()
 {
     cout<<"Enter char one by one                      hicjiajia"<<endl;
     BiNode *T;
     createTree(T);
     cout<<endl;
     
     cout<<"preOrderNoRe:  ";preOrderNoRe(T);cout<<endl;
     cout<<"inOrderNoRe:   ";inOrderNoRe(T);cout<<endl;
     cout<<"postOrderNoRe: ";postOrderNoRe(T);cout<<endl; 
     system("pause");
     return 0;
 }