输出用先序遍历创建的二叉树是否为完全二叉树的判定结果

1000(ms)
10000(kb)
2553 / 5268
利用先序递归遍历算法创建二叉树并判断该二叉树是否为完全二叉树。完全二叉树只能是同深度的满二叉树缺少最后一层倒数连续个叶子结点。先序递归遍历建立二叉树的方法为:按照先序递归遍历的思想将对二叉树结点的抽象访问具体化为根据接收的数据决定是否产生该结点从而实现创建该二叉树的二叉链表存储结构。约定二叉树结点数据为单个大写英文字符。当接收的数据是字符"#"时表示该结点不需要创建,否则创建该结点。最后判断创建完成的二叉树度是否为完全二叉树。需要注意输入数据序列中的"#"字符和非"#"字符的序列及个数关系,这会最终决定创建的二叉树的形态。

输入

  1. 输入为接受键盘输入的由大写英文字符和"#"字符构成的一个字符串(用于创建对应的二叉树)。

输出

  1. 对应的二叉树是否为完全二叉树的判断结果。若是输出"Y",否则输出"N"

样例输入

  1. A##
  2. ABC####
  3. AB##C##
  4. ABCD###EF##G###
  5. A##B##
  6. ABC##D##EG###

样例输出

  1. Y
  2. N
  3. Y
  4. N
  5. Y
  1. #include<iostream>
  2. #include<algorithm>
  3. #include<cstring>
  4. #include<cstdlib>
  5. #include<cstdio>
  6. typedef char Datetype;
  7. using namespace std;
  8. Datetype value;
  9. int x;
  10.  
  11. typedef struct link{
  12. Datetype date;
  13. struct link *lchild;
  14. struct link *rchild;
  15. }tree;
  16.  
  17. typedef struct queue{
  18. tree *data;
  19. struct queue *next;
  20. }que;
  21.  
  22. typedef struct {
  23. que *front;
  24. que *rear;
  25. }lin;
  26.  
  27. void Initqueue(lin *&L)
  28. {
  29. L=(lin *)malloc(sizeof(lin));
  30. L->front=L->rear=NULL;
  31. }
  32.  
  33. void destroyed(lin *&L)
  34. {
  35. que *p=NULL,*r=NULL;
  36. p=L->front;
  37. while(p!=NULL)
  38. {
  39. r=p;
  40. p=p->next;
  41. free(r);
  42. }
  43. free(L);
  44. }
  45.  
  46. bool pop(lin *&L, tree *&e)
  47. {
  48. que *p;
  49. if(L->rear==NULL)
  50. return false;
  51. p=L->front;
  52. if(L->rear==L->front)
  53. L->front=L->rear=NULL;
  54. else
  55. L->front=p->next;
  56. e=p->data;
  57. free(p);
  58. return true;
  59. }
  60.  
  61. int empty(lin *&L)
  62. {
  63. return (L->rear==NULL);
  64. }
  65.  
  66. void push(lin *&L,tree *e)
  67. {
  68. que *p;
  69. p = (que *)malloc(sizeof(que));
  70. p->data=e;
  71. p->next=NULL;
  72. if(L->rear==NULL)
  73. {
  74. L->front=p;
  75. L->rear=p;
  76. }
  77. else
  78. {
  79. L->rear->next=p;
  80. L->rear=p;
  81. }
  82. }
  83.  
  84. void creattree(tree *&L) //先序建立二叉树
  85. {
  86. char c;
  87. cin>>c;
  88. if(c=='#')
  89. L=NULL;
  90. else
  91. {
  92. L = (tree *)malloc(sizeof(tree)) ;
  93. L->date=c;
  94. creattree(L->lchild);
  95. creattree(L->rchild);
  96. }
  97. }
  98.  
  99. void find(tree *L) //找树的棵树
  100. {
  101. if(L!=NULL)
  102. {
  103. x++;
  104. find(L->rchild);
  105. }
  106. }
  107.  
  108. void destroytree(tree *&L) //销毁树
  109. {
  110. if(L!=NULL)
  111. {
  112. destroytree(L->lchild);
  113. destroytree(L->rchild);
  114. free(L);
  115. }
  116. }
  117.  
  118. int deep(tree *L) //深度
  119. {
  120. int ldep,rdep,max;
  121. if(L!=NULL)
  122. {
  123. ldep=deep(L->lchild);
  124. rdep=deep(L->rchild);
  125. max=ldep>rdep?ldep+:rdep+;
  126. return max;
  127. }
  128. else
  129. return ;
  130. }
  131.  
  132. void finddegree(tree *&L, int n) //找最大度数
  133. {
  134. if(L!=NULL)
  135. {
  136. if(x<n)
  137. x=n;
  138. finddegree(L->lchild,n);
  139. finddegree(L->rchild,n+);
  140. }
  141.  
  142. }
  143.  
  144. void run(tree *L) //层次遍历
  145. {
  146. tree *p=L;
  147. lin *qu;
  148. Initqueue(qu);
  149. if(L!=NULL)
  150. push(qu,p);
  151. while(!empty(qu))
  152. {
  153. pop(qu,p);
  154. cout<<p->date;
  155. if(p->lchild!=NULL)
  156. push(qu,p->lchild);
  157. if(p->rchild!=NULL)
  158. push(qu,p->rchild);
  159. }
  160. destroyed(qu);
  161. }
  162.  
  163. void displayhou(tree *&L) //后序输出
  164. {
  165. if(L!=NULL)
  166. {
  167. displayhou(L->lchild);
  168. displayhou(L->rchild);
  169. cout<<L->date;
  170. }
  171. }
  172.  
  173. void displaypre(tree *&L) //先序输出
  174. {
  175. if(L!=NULL)
  176. {
  177. cout<<L->date;
  178. displaypre(L->lchild);
  179. displaypre(L->rchild);
  180. }
  181. }
  182.  
  183. void creatinpre(tree *&L ,char *in,char *pre,int x)//根据中先序确定后序
  184. {
  185. int k=;
  186. char *p;
  187. if(x<=)
  188. {
  189. L=NULL;
  190. return ;
  191. }
  192. L=(tree *)malloc(sizeof(tree));
  193. L->date = *pre;
  194. for(p=in ; p<in+x; p++)
  195. {
  196. if(*p==*pre)
  197. break;
  198. }
  199. k=p-in;
  200. creatinpre(L->lchild,in,pre+,k);
  201. creatinpre(L->rchild,p+,pre+k+,x-k-);
  202. }
  203.  
  204. void creatinhou(tree *&L ,char *in,char *pre,int x) //根据中后序确定先序
  205. {
  206. int k=;
  207. char *p;
  208. if(x<=)
  209. {
  210. L=NULL;
  211. return ;
  212. }
  213. L=(tree *)malloc(sizeof(tree));
  214. L->date = *pre;
  215. for(p=in ; p>in-x; p--)
  216. {
  217. if(*p==*pre)
  218. break;
  219. }
  220. k=in-p;
  221. creatinhou(L->rchild,in,pre-,k);
  222. creatinhou(L->lchild,p-,pre-k-,x-k-);
  223. }
  224.  
  225. void findson(tree *&L) //找指定节点的儿子
  226. {
  227. if(L!=NULL)
  228. {
  229. if(L->date==x)
  230. {
  231. if(L->lchild==NULL)
  232. cout<<"L:#";
  233. else
  234. cout<<"L:"<<L->lchild->date;
  235. if(L->rchild==NULL)
  236. cout<<",R:#";
  237. else
  238. cout<<",R:"<<L->rchild->date;
  239. return ;
  240. }
  241. findson(L->lchild);
  242. findson(L->rchild);
  243. }
  244. }
  245.  
  246. void finddad(tree *&L) //找指定节点的父亲节点
  247. {
  248. if(L!=NULL)
  249. {
  250. if(L->lchild!=NULL&&L->lchild->date==x||L->rchild!=NULL&&L->rchild->date==x)
  251. {
  252. cout<<L->date;
  253. return ;
  254. }
  255.  
  256. finddad(L->lchild);
  257. finddad(L->rchild);
  258. }
  259. }
  260.  
  261. int find_the_one_degree(tree *&L) //找寻某指定节点的度
  262. {
  263. if(L!=NULL)
  264. {
  265. if(L->date==value)
  266. {
  267. if(L->lchild!=NULL&&L->rchild==NULL||L->lchild==NULL&&L->rchild!=NULL)
  268. return ;
  269. else if(L->lchild==NULL&&L->rchild==NULL)
  270. return ;
  271. else
  272. return ;
  273. }
  274. find_the_one_degree(L->lchild);
  275. find_the_one_degree(L->rchild);
  276. }
  277. }
  278.  
  279. void exchange(tree *&L) //交换左右儿子的值
  280. {
  281. if(L!=NULL)
  282. {
  283. tree *p;
  284. p=L->lchild;
  285. L->lchild=L->rchild;
  286. L->rchild=p;
  287. exchange(L->lchild);
  288. exchange(L->rchild);
  289. }
  290. }
  291.  
  292. void displayin(tree *&L) //中序输出
  293. {
  294. if(L!=NULL)
  295. {
  296. displayin(L->lchild);
  297. cout<<L->date;
  298. displayin(L->rchild);
  299. }
  300. }
  301.  
  302. bool banlancetree(tree *&L) //平衡树
  303. {
  304. if(L==NULL)
  305. return true;
  306. int left=deep(L->lchild);
  307. int right=deep(L->rchild);
  308. int gas=left-right;
  309. if(gas>||gas<-)
  310. return false;
  311. return banlancetree(L->lchild)&&banlancetree(L->rchild);
  312. }
  313.  
  314. bool perfecttree(tree *&L,int deepth) //完全二叉树的判定
  315. {
  316. if(L==NULL)
  317. return true;
  318. if(L->rchild!=NULL&&L->lchild==NULL)
  319. return false;
  320. if(x-deepth>&&L->rchild==NULL)
  321. return false;
  322. return perfecttree(L->lchild,deepth+)&&perfecttree(L->rchild,deepth+);
  323. }
  324.  
  325. int main()
  326. {
  327. tree *L = NULL;
  328. creattree(L);
  329. x=deep(L);
  330. if(perfecttree(L,))
  331. cout<<"Y";
  332. else
  333. cout<<"N";
  334. destroytree(L);
  335. return ;
  336. }

swust oj 987的更多相关文章

  1. [Swust OJ 404]--最小代价树(动态规划)

    题目链接:http://acm.swust.edu.cn/problem/code/745255/ Time limit(ms): 1000 Memory limit(kb): 65535   Des ...

  2. [Swust OJ 649]--NBA Finals(dp,后台略(hen)坑)

    题目链接:http://acm.swust.edu.cn/problem/649/ Time limit(ms): 1000 Memory limit(kb): 65535 Consider two ...

  3. SWUST OJ NBA Finals(0649)

    NBA Finals(0649) Time limit(ms): 1000 Memory limit(kb): 65535 Submission: 404 Accepted: 128   Descri ...

  4. [Swust OJ 1023]--Escape(带点其他状态的BFS)

    解题思路:http://acm.swust.edu.cn/problem/1023/ Time limit(ms): 5000 Memory limit(kb): 65535     Descript ...

  5. [Swust OJ 1125]--又见GCD(数论,素数表存贮因子)

    题目链接:http://acm.swust.edu.cn/problem/1125/ Time limit(ms): 1000 Memory limit(kb): 65535   Descriptio ...

  6. [Swust OJ 1126]--神奇的矩阵(BFS,预处理,打表)

    题目链接:http://acm.swust.edu.cn/problem/1126/ Time limit(ms): 1000 Memory limit(kb): 65535 上一周里,患有XX症的哈 ...

  7. [Swust OJ 1026]--Egg pain's hzf

      题目链接:http://acm.swust.edu.cn/problem/1026/     Time limit(ms): 3000 Memory limit(kb): 65535   hzf ...

  8. [Swust OJ 1139]--Coin-row problem

    题目链接:  http://acm.swust.edu.cn/contest/0226/problem/1139/ There is a row of n coins whose values are ...

  9. [Swust OJ 385]--自动写诗

    题目链接:http://acm.swust.edu.cn/problem/0385/ Time limit(ms): 5000 Memory limit(kb): 65535    Descripti ...

随机推荐

  1. C# IIS站点管理--Microsoft.Web.Administration.dll

    Microsoft中提供了管理IIS7及以上版本一个非常强大的API - Microsoft.Web.Administration.dll,利用该API可以让我们很方便的以编程的方式管理和设定IIS的 ...

  2. web文件下载

    web页面实现文件下载的几种方法 今天碰到文件下载的一些问题,本着知其然也要知其所以然的精神,站在巨人的肩膀上深入学习和测试了一下,抛砖引玉,现在总结结论如下: 1)标准URL下载方式可以通过在web ...

  3. face++ php

    总流程是先上传文件,保存到后台,获取返回来的face_token保存下来,然后拿face_token添加到faceSet里面去,搜索的时候结果会返回faceSet里面的face_token 1.dem ...

  4. JS学习过程中碰到的小问题

    使用循环语句查找通讯录 //Setup var contacts = [ { "firstName": "Akira", "lastName" ...

  5. sortable.js 拖拽排序及配置项说明

    // 拖动排序 $(function() { /*排序*/ //排序 // Simple list ]; new Sortable(list, { group: "name", a ...

  6. 解决 DBMS_AW_EXP: BIN$*****==$0 not AW$

    在Oracle 11.2.0.4 版本的数据库中,使用数据泵导出数据时,有可能会遇到这样的提示: 示例1 Connected to: Oracle Database 11g Enterprise Ed ...

  7. L1-049 天梯赛座位分配​​​​​​​

    L1-049 天梯赛座位分配 (20 分) 天梯赛每年有大量参赛队员,要保证同一所学校的所有队员都不能相邻,分配座位就成为一件比较麻烦的事情.为此我们制定如下策略:假设某赛场有 N 所学校参赛,第 i ...

  8. 【玩转开源】基于Docker搭建Bug管理系统 MantisBT

    环境Ubuntu18.04 + Docker 1. Docker Hub 链接:https://hub.docker.com/r/vimagick/mantisbt 这里直接使用docker命令的方式 ...

  9. Win7共享文件夹简单?这个共享问题可以难倒90%的人

    信息化社会,没有哪个公司不用电脑办公了.一个办公室里面的同事相互之间利用系统的共享功能,共享一些文件和软件已经是司空见惯的了,这个不需要多么复杂的操作.我们使用最多的windows7操作系统就能很方便 ...

  10. app:利用HBuilder打包webpack项目

    1.安装HBuilder 2.将你的项目在HBuilder中打开 3.控制台 打包编译 npm run build 4.新建一个app项目,将项目编译生成的dist文件夹 ,复制到app项目中 5.双 ...