• 登录 | 注册
  • 收藏成功

    确定

    收藏失败，请重新收藏

    确定

    *标题
    标题不能为空

    网址
    标签
    位置

    个人主页 - 我的知识
    同时保存至：
    选择知识图谱

    • 选择知识图谱

    新建？

    公开
    取消收藏

  • 分享资讯 传PPT/文档 提问题 写博客 传资源 创建项目 创建代码片

  • 设置昵称编辑自我介绍，让更多人了解你
    帐号设置退出

  • 社区
    博客
    论坛
    下载
    知识库
    技术问答
    极客头条
    英雄会
    服务
    JOB
    学院
    CODE
    活动
    CSTO
    C币兑换
    俱乐部
    CTO俱乐部
    高校俱乐部

落日小屋

Stay Hungry, Stay Foolish

  • 目录视图
  • 摘要视图
  • 订阅
CSDN日报20170322——《关于软件研发的一些体会总结》    同步博客至 CSDN ，让更多开发者看到你的文章    看微博技术大咖解析互联网应用架构实战

[置顶] 算法之二叉树各种遍历

标签： 算法
2013-03-07 04:51 125748人阅读 评论(38) 收藏 举报

本文章已收录于：
分类：
算法（53）

作者同类文章X

版权声明：本文为博主原创文章，未经博主允许不得转载。

树形结构是一类重要的非线性数据结构，其中以树和二叉树最为常用。

二叉树是每个结点最多有两个子树的有序树。通常子树的根被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用作二叉查找树和二叉堆或是二叉排序树。二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有2的 i -1次方个结点；深度为k的二叉树至多有2^(k) -1个结点；对任何一棵二叉树T，如果其终端结点数(即叶子结点数)为n0，度为2的结点数为n2，则n0 = n2 + 1。

二叉树的链式存储结构是一类重要的数据结构，其形式定义如下：

[cpp] view plaincopy print?
  1. //二叉树结点
  2. typedef struct BiTNode{
  3. //数据
  4. char data;
  5. //左右孩子指针
  6. struct BiTNode *lchild,*rchild;
  7. }BiTNode,*BiTree;

//二叉树结点
typedef struct BiTNode{//数据char data;//左右孩子指针struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

二叉树的创建：

通过读入一个字符串，建立二叉树的算法如下：

[cpp] view plaincopy print?
  1. //按先序序列创建二叉树
  2. int CreateBiTree(BiTree &T){
  3. char data;
  4. //按先序次序输入二叉树中结点的值（一个字符），‘#’表示空树
  5. scanf("%c",&data);
  6. if(data == '#'){
  7. T = NULL;
  8. }
  9. else{
  10. T = (BiTree)malloc(sizeof(BiTNode));
  11. //生成根结点
  12. T->data = data;
  13. //构造左子树
  14. CreateBiTree(T->lchild);
  15. //构造右子树
  16. CreateBiTree(T->rchild);
  17. }
  18. return 0;
  19. }

//按先序序列创建二叉树
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;
}

二叉树的遍历：

遍历是对树的一种最基本的运算，所谓遍历二叉树，就是按一定的规则和顺序走遍二叉树的所有结点，使每一个结点都被访问一次，而且只被访问一次。由于二叉树是非线性结构，因此，树的遍历实质上是将二叉树的各个结点转换成为一个线性序列来表示。

递归算法：

[cpp] view plaincopy print?
  1. //输出
  2. void Visit(BiTree T){
  3. if(T->data != '#'){
  4. printf("%c ",T->data);
  5. }
  6. }
  7. //先序遍历
  8. void PreOrder(BiTree T){
  9. if(T != NULL){
  10. //访问根节点
  11. Visit(T);
  12. //访问左子结点
  13. PreOrder(T->lchild);
  14. //访问右子结点
  15. PreOrder(T->rchild);
  16. }
  17. }
  18. //中序遍历
  19. void InOrder(BiTree T){
  20. if(T != NULL){
  21. //访问左子结点
  22. InOrder(T->lchild);
  23. //访问根节点
  24. Visit(T);
  25. //访问右子结点
  26. InOrder(T->rchild);
  27. }
  28. }
  29. //后序遍历
  30. void PostOrder(BiTree T){
  31. if(T != NULL){
  32. //访问左子结点
  33. PostOrder(T->lchild);
  34. //访问右子结点
  35. PostOrder(T->rchild);
  36. //访问根节点
  37. Visit(T);
  38. }
  39. }

//输出
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);}
}

非递归算法：

<1>先序遍历：

【思路】：访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。

[cpp] view plaincopy print?
  1. /* 先序遍历(非递归)
  2. 思路：访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。
  3. */
  4. void PreOrder2(BiTree T){
  5. stack<BiTree> stack;
  6. //p是遍历指针
  7. BiTree p = T;
  8. //栈不空或者p不空时循环
  9. while(p || !stack.empty()){
  10. if(p != NULL){
  11. //存入栈中
  12. stack.push(p);
  13. //访问根节点
  14. printf("%c ",p->data);
  15. //遍历左子树
  16. p = p->lchild;
  17. }
  18. else{
  19. //退栈
  20. p = stack.top();
  21. stack.pop();
  22. //访问右子树
  23. p = p->rchild;
  24. }
  25. }//while
  26. }

/* 先序遍历(非递归)思路：访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。
*/
void PreOrder2(BiTree T){stack<BiTree> stack;//p是遍历指针BiTree p = T;//栈不空或者p不空时循环while(p || !stack.empty()){if(p != NULL){//存入栈中stack.push(p);//访问根节点printf("%c ",p->data);//遍历左子树p = p->lchild;}else{//退栈p = stack.top();stack.pop();//访问右子树p = p->rchild;}}//while
}

<2>中序遍历

【思路】：T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。
         先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。

[cpp] view plaincopy print?
  1. void InOrder2(BiTree T){
  2. stack<BiTree> stack;
  3. //p是遍历指针
  4. BiTree p = T;
  5. //栈不空或者p不空时循环
  6. while(p || !stack.empty()){
  7. if(p != NULL){
  8. //存入栈中
  9. stack.push(p);
  10. //遍历左子树
  11. p = p->lchild;
  12. }
  13. else{
  14. //退栈，访问根节点
  15. p = stack.top();
  16. printf("%c ",p->data);
  17. stack.pop();
  18. //访问右子树
  19. p = p->rchild;
  20. }
  21. }//while
  22. }

void InOrder2(BiTree T){stack<BiTree> stack;//p是遍历指针BiTree p = T;//栈不空或者p不空时循环while(p || !stack.empty()){if(p != NULL){//存入栈中stack.push(p);//遍历左子树p = p->lchild;}else{//退栈，访问根节点p = stack.top();printf("%c ",p->data);stack.pop();//访问右子树p = p->rchild;}}//while
}

<3>后序遍历

【思路】：T是要遍历树的根指针，后序遍历要求在遍历完左右子树后，再访问根。需要判断根结点的左右子树是否均遍历过。

[cpp] view plaincopy print?
  1. //后序遍历(非递归)
  2. typedef struct BiTNodePost{
  3. BiTree biTree;
  4. char tag;
  5. }BiTNodePost,*BiTreePost;
  6. void PostOrder2(BiTree T){
  7. stack<BiTreePost> stack;
  8. //p是遍历指针
  9. BiTree p = T;
  10. BiTreePost BT;
  11. //栈不空或者p不空时循环
  12. while(p != NULL || !stack.empty()){
  13. //遍历左子树
  14. while(p != NULL){
  15. BT = (BiTreePost)malloc(sizeof(BiTNodePost));
  16. BT->biTree = p;
  17. //访问过左子树
  18. BT->tag = 'L';
  19. stack.push(BT);
  20. p = p->lchild;
  21. }
  22. //左右子树访问完毕访问根节点
  23. while(!stack.empty() && (stack.top())->tag == 'R'){
  24. BT = stack.top();
  25. //退栈
  26. stack.pop();
  27. BT->biTree;
  28. printf("%c ",BT->biTree->data);
  29. }
  30. //遍历右子树
  31. if(!stack.empty()){
  32. BT = stack.top();
  33. //访问过右子树
  34. BT->tag = 'R';
  35. p = BT->biTree;
  36. p = p->rchild;
  37. }
  38. }//while
  39. }

//后序遍历(非递归)
typedef struct BiTNodePost{BiTree biTree;char tag;
}BiTNodePost,*BiTreePost;void PostOrder2(BiTree T){stack<BiTreePost> stack;//p是遍历指针BiTree p = T;BiTreePost BT;//栈不空或者p不空时循环while(p != NULL || !stack.empty()){//遍历左子树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();BT->biTree;printf("%c ",BT->biTree->data);}//遍历右子树if(!stack.empty()){BT = stack.top();//访问过右子树BT->tag = 'R';p = BT->biTree;p = p->rchild;}}//while
}

<4>层次遍历

【思路】：按从顶向下，从左至右的顺序来逐层访问每个节点，层次遍历的过程中需要用队列。

[cpp] view plaincopy print?
  1. //层次遍历
  2. void LevelOrder(BiTree T){
  3. BiTree p = T;
  4. //队列
  5. queue<BiTree> queue;
  6. //根节点入队
  7. queue.push(p);
  8. //队列不空循环
  9. while(!queue.empty()){
  10. //对头元素出队
  11. p = queue.front();
  12. //访问p指向的结点
  13. printf("%c ",p->data);
  14. //退出队列
  15. queue.pop();
  16. //左子树不空，将左子树入队
  17. if(p->lchild != NULL){
  18. queue.push(p->lchild);
  19. }
  20. //右子树不空，将右子树入队
  21. if(p->rchild != NULL){
  22. queue.push(p->rchild);
  23. }
  24. }
  25. }

//层次遍历
void LevelOrder(BiTree T){BiTree p = T;//队列queue<BiTree> queue;//根节点入队queue.push(p);//队列不空循环while(!queue.empty()){//对头元素出队p = queue.front();//访问p指向的结点printf("%c ",p->data);//退出队列queue.pop();//左子树不空，将左子树入队if(p->lchild != NULL){queue.push(p->lchild);}//右子树不空，将右子树入队if(p->rchild != NULL){queue.push(p->rchild);}}
}

测试用例：

输入：

ABC##DE#G##F###

输出：

代码：

[cpp] view plaincopy print?
  1. #include<iostream>
  2. #include<stack>
  3. #include<queue>
  4. using namespace std;
  5. //二叉树结点
  6. typedef struct BiTNode{
  7. //数据
  8. char data;
  9. //左右孩子指针
  10. struct BiTNode *lchild,*rchild;
  11. }BiTNode,*BiTree;
  12. //按先序序列创建二叉树
  13. int CreateBiTree(BiTree &T){
  14. char data;
  15. //按先序次序输入二叉树中结点的值（一个字符），‘#’表示空树
  16. scanf("%c",&data);
  17. if(data == '#'){
  18. T = NULL;
  19. }
  20. else{
  21. T = (BiTree)malloc(sizeof(BiTNode));
  22. //生成根结点
  23. T->data = data;
  24. //构造左子树
  25. CreateBiTree(T->lchild);
  26. //构造右子树
  27. CreateBiTree(T->rchild);
  28. }
  29. return 0;
  30. }
  31. //输出
  32. void Visit(BiTree T){
  33. if(T->data != '#'){
  34. printf("%c ",T->data);
  35. }
  36. }
  37. //先序遍历
  38. void PreOrder(BiTree T){
  39. if(T != NULL){
  40. //访问根节点
  41. Visit(T);
  42. //访问左子结点
  43. PreOrder(T->lchild);
  44. //访问右子结点
  45. PreOrder(T->rchild);
  46. }
  47. }
  48. //中序遍历
  49. void InOrder(BiTree T){
  50. if(T != NULL){
  51. //访问左子结点
  52. InOrder(T->lchild);
  53. //访问根节点
  54. Visit(T);
  55. //访问右子结点
  56. InOrder(T->rchild);
  57. }
  58. }
  59. //后序遍历
  60. void PostOrder(BiTree T){
  61. if(T != NULL){
  62. //访问左子结点
  63. PostOrder(T->lchild);
  64. //访问右子结点
  65. PostOrder(T->rchild);
  66. //访问根节点
  67. Visit(T);
  68. }
  69. }
  70. /* 先序遍历(非递归)
  71. 思路：访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。
  72. */
  73. void PreOrder2(BiTree T){
  74. stack<BiTree> stack;
  75. //p是遍历指针
  76. BiTree p = T;
  77. //栈不空或者p不空时循环
  78. while(p || !stack.empty()){
  79. if(p != NULL){
  80. //存入栈中
  81. stack.push(p);
  82. //访问根节点
  83. printf("%c ",p->data);
  84. //遍历左子树
  85. p = p->lchild;
  86. }
  87. else{
  88. //退栈
  89. p = stack.top();
  90. stack.pop();
  91. //访问右子树
  92. p = p->rchild;
  93. }
  94. }//while
  95. }
  96. /* 中序遍历(非递归)
  97. 思路：T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。
  98. 先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。
  99. */
  100. void InOrder2(BiTree T){
  101. stack<BiTree> stack;
  102. //p是遍历指针
  103. BiTree p = T;
  104. //栈不空或者p不空时循环
  105. while(p || !stack.empty()){
  106. if(p != NULL){
  107. //存入栈中
  108. stack.push(p);
  109. //遍历左子树
  110. p = p->lchild;
  111. }
  112. else{
  113. //退栈，访问根节点
  114. p = stack.top();
  115. printf("%c ",p->data);
  116. stack.pop();
  117. //访问右子树
  118. p = p->rchild;
  119. }
  120. }//while
  121. }
  122. //后序遍历(非递归)
  123. typedef struct BiTNodePost{
  124. BiTree biTree;
  125. char tag;
  126. }BiTNodePost,*BiTreePost;
  127. void PostOrder2(BiTree T){
  128. stack<BiTreePost> stack;
  129. //p是遍历指针
  130. BiTree p = T;
  131. BiTreePost BT;
  132. //栈不空或者p不空时循环
  133. while(p != NULL || !stack.empty()){
  134. //遍历左子树
  135. while(p != NULL){
  136. BT = (BiTreePost)malloc(sizeof(BiTNodePost));
  137. BT->biTree = p;
  138. //访问过左子树
  139. BT->tag = 'L';
  140. stack.push(BT);
  141. p = p->lchild;
  142. }
  143. //左右子树访问完毕访问根节点
  144. while(!stack.empty() && (stack.top())->tag == 'R'){
  145. BT = stack.top();
  146. //退栈
  147. stack.pop();
  148. printf("%c ",BT->biTree->data);
  149. }
  150. //遍历右子树
  151. if(!stack.empty()){
  152. BT = stack.top();
  153. //访问过右子树
  154. BT->tag = 'R';
  155. p = BT->biTree;
  156. p = p->rchild;
  157. }
  158. }//while
  159. }
  160. //层次遍历
  161. void LevelOrder(BiTree T){
  162. BiTree p = T;
  163. //队列
  164. queue<BiTree> queue;
  165. //根节点入队
  166. queue.push(p);
  167. //队列不空循环
  168. while(!queue.empty()){
  169. //对头元素出队
  170. p = queue.front();
  171. //访问p指向的结点
  172. printf("%c ",p->data);
  173. //退出队列
  174. queue.pop();
  175. //左子树不空，将左子树入队
  176. if(p->lchild != NULL){
  177. queue.push(p->lchild);
  178. }
  179. //右子树不空，将右子树入队
  180. if(p->rchild != NULL){
  181. queue.push(p->rchild);
  182. }
  183. }
  184. }
  185. int main()
  186. {
  187. BiTree T;
  188. CreateBiTree(T);
  189. printf("先序遍历：\n");
  190. PreOrder(T);
  191. printf("\n");
  192. printf("先序遍历(非递归)：\n");
  193. PreOrder2(T);
  194. printf("\n");
  195. printf("中序遍历：\n");
  196. InOrder(T);
  197. printf("\n");
  198. printf("中序遍历(非递归)：\n");
  199. InOrder2(T);
  200. printf("\n");
  201. printf("后序遍历：\n");
  202. PostOrder(T);
  203. printf("\n");
  204. printf("后序遍历(非递归)：\n");
  205. PostOrder2(T);
  206. printf("\n");
  207. printf("层次遍历：\n");
  208. LevelOrder(T);
  209. printf("\n");
  210. return 0;
  211. }

#include<iostream>
#include<stack>
#include<queue>
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);}
}
/* 先序遍历(非递归)思路：访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。
*/
void PreOrder2(BiTree T){stack<BiTree> stack;//p是遍历指针BiTree p = T;//栈不空或者p不空时循环while(p || !stack.empty()){if(p != NULL){//存入栈中stack.push(p);//访问根节点printf("%c ",p->data);//遍历左子树p = p->lchild;}else{//退栈p = stack.top();stack.pop();//访问右子树p = p->rchild;}}//while
}
/* 中序遍历(非递归)思路：T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。
*/
void InOrder2(BiTree T){stack<BiTree> stack;//p是遍历指针BiTree p = T;//栈不空或者p不空时循环while(p || !stack.empty()){if(p != NULL){//存入栈中stack.push(p);//遍历左子树p = p->lchild;}else{//退栈，访问根节点p = stack.top();printf("%c ",p->data);stack.pop();//访问右子树p = p->rchild;}}//while
}//后序遍历(非递归)
typedef struct BiTNodePost{BiTree biTree;char tag;
}BiTNodePost,*BiTreePost;void PostOrder2(BiTree T){stack<BiTreePost> stack;//p是遍历指针BiTree p = T;BiTreePost BT;//栈不空或者p不空时循环while(p != NULL || !stack.empty()){//遍历左子树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;}}//while
}
//层次遍历
void LevelOrder(BiTree T){BiTree p = T;//队列queue<BiTree> queue;//根节点入队queue.push(p);//队列不空循环while(!queue.empty()){//对头元素出队p = queue.front();//访问p指向的结点printf("%c ",p->data);//退出队列queue.pop();//左子树不空，将左子树入队if(p->lchild != NULL){queue.push(p->lchild);}//右子树不空，将右子树入队if(p->rchild != NULL){queue.push(p->rchild);}}
}
int main()
{BiTree T;CreateBiTree(T);printf("先序遍历：\n");PreOrder(T);printf("\n");printf("先序遍历(非递归)：\n");PreOrder2(T);printf("\n");printf("中序遍历：\n");InOrder(T);printf("\n");printf("中序遍历(非递归)：\n");InOrder2(T);printf("\n");printf("后序遍历：\n");PostOrder(T);printf("\n");printf("后序遍历(非递归)：\n");PostOrder2(T);printf("\n");printf("层次遍历：\n");LevelOrder(T);printf("\n");return 0;
}

新版：点击打开链接

顶
66
踩
3
  • 上一篇JSP之JDBC操作Sql Server数据库
  • 下一篇题目1184：二叉树遍历

我的同类文章

算法（53）
http://blog.csdn.net

  • •算法：字符串消除问题的数学证明2013-11-03阅读1944
  • •算法之素数筛法2013-03-20阅读4425
  • •算法之优先级队列2013-03-16阅读2768
  • •算法之中缀表达式和后缀表达式2013-03-11阅读1426
  • •算法之堆排序2013-02-25阅读1084
  • •算法之最长递增子序列，最长公共子序列2013-03-25阅读3072
  • •浅谈大数的进制转换2013-03-19阅读4972
  • •ACM进阶之路2013-03-12阅读2147
  • •算法之二叉树中序前序序列(或后序)求解树2013-03-08阅读11810
  • •算法之快速排序2013-02-22阅读1021

更多文章

参考知识库

软件测试知识库

4118关注|310收录

算法与数据结构知识库

14665关注|2320收录

更多资料请参考：

猜你在找

数据结构基础系列(3)：栈和队列
数据结构基础系列(6)：树和二叉树
C语言系列之 数据结构栈的运用
数据结构和算法
数据结构与算法在实战项目中的应用
算法系列之二二叉树各种遍历
数据结构与算法 之二叉树二非递归遍历算法
SDUTOJ 2136--数据结构实验之二叉树的建立与遍历
数据结构实验之二叉树五层序遍历
数据结构实验之二叉树五层序遍历
关闭
查看评论
34楼 qq_36693849 2016-11-13 10:28发表 [回复] [引用] [举报]
如何增加一个判断功能 即判断键盘输入的二叉树是否合法
33楼 赵尽朝 2016-10-30 21:36发表 [回复] [引用] [举报]
代码很清晰，非常感谢楼主。
32楼 赵尽朝 2016-10-30 20:58发表 [回复] [引用] [举报]
前序遍历和后序遍历中叶子节点的顺序是一致的吗？
31楼 AnXT 2016-08-25 21:57发表 [回复] [引用] [举报]
因为你输入的时候每敲一个数字后面跟了一个回车吧？scanf函数会把回车符返回输入流中，下次就从剩余的那个回车符开始读，但是回车符是读不进去的，所以就一直停在那里了，加一个小函数就行了void eatline()
{
while (getchar()!='\n')
{
getchar();
}
}
30楼 烟花散尽13141 2016-08-25 11:09发表 [回复] [引用] [举报]
东西很不错，和我的一个观点，大家也可以看看我的，在我的博客里
29楼 二叉树 2016-07-12 11:06发表 [回复] [引用] [举报]
代码写的不错，就是非递归的后序遍历是不是有内存泄露？另外加一个销毁二叉树的函数就更好了
28楼 07H_JH 2016-06-20 22:24发表 [回复] [引用] [举报]
博主是西电的吧
27楼 07H_JH 2016-06-20 22:23发表 [回复] [引用] [举报]
博主是西电的吗
26楼 大杰瑞_TEL 2016-06-08 10:09发表 [回复] [引用] [举报]
[cpp] view plaincopyprint?
  1. //输出
  2. void Visit(BiTree T){
  3. if(T->data != '#'){
  4. printf("%c ",T->data);
  5. }
  6. }
//输出
void Visit(BiTree T){  if(T->data != '#'){  printf("%c ",T->data);  }
}

您好，这段代码T->data好像应该永远等于不了‘#’，因为当时创建树，判断新建树节点T输入#值的时候，T就指向了NULL；
不知是否存在这个问题。

25楼 尼晓健 2016-04-13 17:21发表 [回复] [引用] [举报]
建议楼主将二叉树的构建采用的是中序遍历构造的，这点说一下，不然容易让人对于二叉树的构建理解不了。
24楼 mnbvcxz_lkjhgfdsa 2015-12-25 11:24发表 [回复] [引用] [举报]
#include<iostream>
#include<stack>
#include<queue>
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 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);
}
}
新手不懂为什么会这么多错误
23楼 happy的涵 2015-11-26 19:01发表 [回复] [引用] [举报]
写的很棒，受益匪浅
22楼 K_9527 2015-11-25 19:48发表 [回复] [引用] [举报]
博主你好，我对程序中的创建函数有些疑问，想问下int CreateBiTree(BiTree &T)中的符号“&”是表示引用还是表示取地址？
我的想法是将T的地址传进函数，这样才可以去改变T的值。
21楼 ww_hahha 2015-10-23 11:26发表 [回复] [引用] [举报]
谢谢，学习了！
20楼 str_yyn 2015-10-01 23:09发表 [回复] [引用] [举报]
大赞
19楼 ziyuxuan7177 2015-07-08 22:19发表 [回复] [引用] [举报]
试了一下
一直处于输入状态
18楼 txdzdlxx 2015-04-22 20:32发表 [回复] [引用] [举报]
gooooooooooooooooooooooooood
17楼 wang1shuang2cheng3 2015-04-21 14:13发表 [回复] [引用] [举报]
ths
16楼 Nitpicking 2015-04-13 21:38发表 [回复] [引用] [举报]
楼主，不知您代码跑通了么？ 为什么我非要把scanf("%c",&data); 改成 cin>>data；才能跑通？否则一直处于输入状态。。。。有人和我一样的么？
还有，楼主写博客是怎么把代码写的那么漂亮的？

Re: baidu_32784641 2015-11-13 15:44发表 [回复] [引用] [举报]
回复Nitpicking：我就是这个问题，请问怎么解决啊？
Re: sjf0115 2015-07-11 14:43发表 [回复] [引用] [举报]
回复Nitpicking：很长时间了，应该能跑通的。
15楼 独孤_子喻 2015-03-30 12:09发表 [回复] [引用] [举报]
清楚明了。 感谢。
14楼 Gave_Ge 2015-02-14 21:15发表 [回复] [引用] [举报]
楼猪。。。。BT->biTree=NULL;少写了个NULL;快醒醒。。。。都陷入死循环了呢;
13楼 qq_24027947 2014-12-13 10:59发表 [回复] [引用] [举报]
赞
12楼 qq_23590961 2014-11-20 15:18发表 [回复] [引用] [举报]
好东西啊，顶起来
11楼 huzi741 2014-10-20 17:48发表 [回复] [引用] [举报]
代码很清晰，非常感谢楼主。
10楼 long_Xu_Oracle 2014-10-20 10:27发表 [回复] [引用] [举报]
写的非常好，非常详细，感谢楼主分享
9楼 李大学heart 2014-10-18 16:15发表 [回复] [引用] [举报]
写的非常好，想问下啊int CreateBiTree(BiTree &T)与int CreateBiTree(BiTree T) 之间的区别是什么

Re: Gave_Ge 2015-02-12 09:43发表 [回复] [引用] [举报]
回复qq_17672863：这里应该是必须要引用吧，因为你需要返回一个BiTree级别的。。所以必须用**或者&*;
8楼 jdkwky 2014-10-13 22:28发表 [回复] [引用] [举报]
学习加收藏，谢谢博主了
7楼 浸在咫尺 2014-09-03 10:26发表 [回复] [引用] [举报]
必须得顶！！
6楼 SmileLing~ 2014-08-14 15:15发表 [回复] [引用] [举报]
值得学习学习
5楼 yulinxx 2014-07-21 23:12发表 [回复] [引用] [举报]
非常不错 . 逻辑清晰 有图有码 转之~~~~
4楼 曦花 2014-06-28 14:05发表 [回复] [引用] [举报]
while(!stack.empty() && (stack.top())->tag == 'R'){
BT = stack.top();
//退栈
stack.pop();
BT->biTree; -----笔误还是？？
printf("%c ",BT->biTree->data);
}

在非递归的后序遍历中，
while循环里的第二个while循环里，
BT->biTree; 这是什么意思？为什么单独一行？
笔误还是？？

Re: sjf0115 2015-07-11 14:44发表 [回复] [引用] [举报]
回复wangyunxiaoyu：可能是多加了一行。。。。。。你去掉试试
3楼 未提交的遗漏者 2014-05-07 22:43发表 [回复] [引用] [举报]
注释太好了，对理解非常有帮助
2楼 edgargwj 2014-04-17 14:18发表 [回复] [引用] [举报]
感谢博主
1楼 andrewcarmack 2014-03-23 12:11发表 [回复] [引用] [举报]
代码写的很好；非常清晰明了！给32个赞
您还没有登录,请[登录]或[注册]
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场

核心技术类目
全部主题HadoopAWS移动游戏JavaAndroidiOSSwift智能硬件DockerOpenStackVPNSparkERPIE10EclipseCRMJavaScript数据库UbuntuNFCWAPjQueryBIHTML5SpringApache.NETAPIHTMLSDKIISFedoraXMLLBSUnitySplashtopUMLcomponentsWindows MobileRailsQEMUKDECassandraCloudStackFTCcoremailOPhone CouchBase云计算iOS6Rackspace Web AppSpringSideMaemoCompuware大数据aptechPerlTornadoRubyHibernateThinkPHPHBasePureSolrAngularCloud FoundryRedisScalaDjangoBootstrap

  • 个人资料

  • sjf0115
    • 访问：2337606次
    • 积分：26778
    • 等级：
      积分：26778
    • 排名：第185名
    • 原创：496篇
    • 转载：223篇
    • 译文：0篇
    • 评论：550条
  • 文章搜索
  • 博客专栏
  • Android进阶2

    文章：16篇

    阅读：139387
    Android菜鸟分享

    文章：44篇

    阅读：385265
  • 友情链接
  • 九度OJ
    杭电OJ
    POJ
    天勤OJ
    好友博客：SunnyYoona
  • 文章分类
  • Java系列(2)
  • Android(55)
  • Android进阶(38)
  • Android总结(3)
  • Android进阶2(23)
  • Android开发技巧(7)
  • OJ(70)
  • 算法(54)
  • 九度&天勤OJ(198)
  • Linux(3)
  • 剑指Offer(18)
  • Mysql(0)
  • Hadoop(1)
  • 文章存档
    • 2016年12月(2)
    • 2016年01月(1)
    • 2015年11月(1)
    • 2014年04月(2)
    • 2014年03月(2)
    • 2014年02月(1)
    • 2013年12月(1)
    • 2013年11月(2)
    • 2013年10月(1)
    • 2013年07月(3)
    • 2013年05月(9)
    • 2013年04月(18)
    • 2013年03月(76)
    • 2013年02月(111)
    • 2013年01月(37)
    • 2012年09月(1)
    • 2012年07月(3)
    • 2012年06月(17)
    • 2012年05月(26)
    • 2012年04月(9)
    • 2012年03月(54)
    • 2012年02月(108)
    • 2012年01月(40)
    • 2011年12月(74)
    • 2011年11月(78)
    • 2011年10月(41)
    • 2010年08月(1)
      展开
  • 阅读排行
  • 算法之二叉树各种遍历(125704)
  • Android得到控件在屏幕中的坐标(81831)
  • Android进阶2之Activity之间数据交流（onActivityResult的用法）(43524)
  • Java课程设计之学习成绩管理系统(26990)
  • JVM内存的设置（解决eclipse下out of memory问题）(26596)
  • Android进阶2之 阴影制作（Shadow）(26430)
  • Android学习笔记之滑动翻页（屏幕切换）(24759)
  • android图片特效处理之模糊效果(23515)
  • Android学习笔记之ProgressDialog(21887)
  • Android学习笔记之RatingBar(21710)
  • 评论排行
  • 算法之二叉树各种遍历(38)
  • 计算机复试上机题解题报告(24)
  • Java课程设计之学习成绩管理系统(14)
  • Android学习笔记进阶之在图片上涂鸦(能清屏)(13)
  • Android进阶2之Activity之间数据交流（onActivityResult的用法）(12)
  • Android得到控件在屏幕中的坐标(11)
  • Android进阶2之Http访问网络资源（获取网络图片）(11)
  • 编程之美读书笔记（3） 统计在从1到n的正整数中1出现的次数(10)
  • Android学习笔记之百度地图（周边检索poiSearchNearBy跳转页面并输出搜索结果）(9)
  • android图像处理（3）浮雕效果(9)
  • 最新评论
  • 九度1165 字符串匹配

    haohaohaoxu:试下下面的测试用例5Aaba2BabABBa2bab3AvsSdfaV2SdfAssdfavsdf2...

  • 九度OJ 题目1193：矩阵转置

    ofandof:不是不让使用数组吗？

  • Android得到控件在屏幕中的坐标

    silingcanggui:这个解决大问题了，多谢

  • 九度OJ 题目1206：字符串连接

    Fore_ver:按照题目要求，需要无冗余接受连接两个字符串，同时将这两个字符串无冗余的连接起来。通过数组实现的话，满...

  • 九度OJ 题目1206：字符串连接

    Fore_ver:按照题目要求，需要无冗余接受连接两个字符串，同时将这两个字符串无冗余的连接起来。通过数组实现的话，满...

  • Android学习笔记之图像颜色处理（ColorMatrix）

    zhc_LR:不错，用到了。

  • android图片特效处理之怀旧效果

    Simon347670037:为什么不用颜色矩阵？

  • Android学习笔记进阶16之BitmapShader

    Sugar先生:橙光

  • Android学习笔记进阶之在图片上涂鸦(能清屏)

    qq_34137716:@liangzi7:你看报的什么错，百度一下，就会发现啊，android系统本身是不允许在代码中对r...

  • 算法之素数筛法

    Lhj0616:谢谢分享

公司简介|招贤纳士|广告服务|联系方式|版权声明|法律顾问|问题报告|合作伙伴|论坛反馈
网站客服杂志客服微博客服webmaster@csdn.net400-600-2320|北京创新乐知信息技术有限公司 版权所有|江苏知之为计算机有限公司|江苏乐知网络技术有限公司
京 ICP 证 09002463 号|Copyright © 1999-2016, CSDN.NET, All Rights Reserved 
您有0条新通知

收藏助手

提问

您的问题将会被发布在“技术问答”频道×

该问题已存在，请勿重复提问
插入链接
本地上传网络图片
插入图片

||||||

000:0
推荐标签：
我要悬赏 币

取消发布

可能存在类似的问题：
我想提一个新问题

保存代码片

整理和分享保存的代码片，请访问代码笔记

  • *标题
  • *描述
  • 标签
    算法x
取消确定

算法之二叉树各种遍历相关推荐

  1. 深度优先遍历算法-03二叉树路径遍历问题

    二叉树路径遍历 简述 比较基础的一个DFS的题目,但是确实很多难题的模板.LeetCode很多二叉树的题本质上就是这个路径遍历. 本题为了输出路径,使用DFS的经典结构栈完成. 问题描述 给定一个二叉 ...

  2. 算法(2)-二叉树的遍历（递归/迭代）python实现

    二叉树的遍历 1.深度优先DFS 1.1 DFS 递归解法 1.1.1先序遍历 1.1.2中序遍历 1.1.3后序遍历 1.2 DFS迭代解法 1.2.1先序遍历 1.2.2中序遍历 1.2.3后序遍 ...

  3. 二叉树层次遍历算法 python_二叉树的遍历详解：前、中、后、层次遍历(Python实现)...

    二叉树的遍历详解:前.中.后.层次遍历(Python实现) 二叉树是一种常见的数据结构,而它的常见遍历方法有前序遍历.中序遍历.后续遍历.层次遍历--掌握这几种遍历方法是很有必要的. 假设我们二叉树节 ...

  4. 数据结构与算法之二叉树广度遍历、深度遍历总结

    什么是树,它是和链表一样都是一种抽象数据类型(ADT),包括数据结构和对数据的操作. 树是一种二维平面的数据结构结构,它也是由节点组成的,只是它的后继节点不止一个,而链表的后继节点只有一个. 树具有以 ...

  5. 【数据结构与算法】二叉树深度遍历

    leetcode:力扣本题链接 leetcode所有深度遍历链接 !!!后文有动画演示一定要结合动画理解!!! 遍历顺序取决于中间节点所在的位置,假如中间节点在最后,那么就是后序遍历. 在非递归算法中 ...

  6. PTA数据结构与算法题目集 6-9 二叉树的遍历

    PTA数据结构与算法题目集(中文) 6-9 二叉树的遍历 void InorderTraversal( BinTree BT ){if(BT==NULL)return;if(BT->Left){ ...

  7. 【swjtu】数据结构实验6_二叉树的遍历算法

    实验内容及要求: 编写程序,用先序递归遍历法建立二叉树的二叉链表存储结构,然后输出其先序.中序.后序以及层次遍历结点访问次序.其中层次遍历的实现需使用循环队列.二叉树结点数据类型建议选用字符类型. 实 ...

  8. 重拾算法(3)——用458329个测试用例全面测试二叉树和线索二叉树的遍历算法

    重拾算法(3)--用458329个测试用例全面测试二叉树和线索二叉树的遍历算法 在"上一篇"和"上上一篇"中,我给出了二叉树和线索二叉树的遍历算法.给出算法容易 ...

  9. 常考数据结构与算法:求二叉树的层序遍历

    题目描述 给定一个二叉树,返回该二叉树层序遍历的结果,(从左到右,一层一层地遍历) 例如: 给定的二叉树是{3,9,20,#,#,15,7}, 该二叉树层序遍历的结果是 [ [3], [9,20], ...

  10. Algorithm：树相关算法(BBT/BST/B树/R树)简介(二叉查找树、二叉查找树的插入节点、二叉查找树的删除、二叉树的遍历、平衡二叉树)C 语言实现

    Algorithm:树相关算法(BBT/BST/B树/R树)简介(二叉查找树.二叉查找树的插入节点.二叉查找树的删除.二叉树的遍历.平衡二叉树)C++语言实现 目录 树的基础知识 1.二叉树的遍-前序 ...

最新文章

  1. IIS7 如何设置默认首页
  2. HttpURLConnection 中Cookie 使用
  3. tomcat中关于websocket的性能优化配置
  4. OpenMP 多核编程(转载)
  5. 少女为什么会身上香香的？
  6. java数组深拷贝和浅拷贝_java中的深拷贝与浅拷贝（值类型 vs 引用类型）
  7. nginx配置多个server_Nginx基本属性配置详解
  8. php5.3升级5.4,centos php 5.3升级到 php5.4版本
  9. 再分享一个竞品分析报告
  10. NSAttributedString
  11. array在java_在Java中的ArrayLists之间进行转换
  12. 如何给计算机安装驱动程序,电脑系统怎么安装驱动程序
  13. 一文搞懂无刷电机和有刷电机
  14. 3D游戏建模学习路线
  15. 修复IE默认主页——注册表篇
  16. UbuntuNAT内网穿透实现远程访问
  17. linux yum使用管理详细使用转载的
  18. 仿ofo单车做一个轮播效果
  19. ai 如何导出html格式,Adobe Illustrator导出SVG的设置方法
  20. loadrunner入门教程(10)--代理录制

热门文章

  1. 深度学习与计算机视觉教程(1) | 引言与知识基础（CV通关指南·完结）
  2. 微信公众号唤起微信支付
  3. 实现了一个跨平台的 YUV 文件图片查看器
  4. 刘润5分钟商学院读书笔记之：企业能量模型
  5. Qt信号与槽机制原理
  6. 自抗扰控制器七－二阶 LADRC-PLL 结构设计
  7. 单例模式中的饿汉和懒汉模式
  8. android的wifi开发,android开发教程之wifi开发示例
  9. linux C语言获取鼠标的绝对坐标/位置
  10. 计算机硕士工资一览表 (时间有点久远了)