二叉树

typedef struct _ast ast;typedef struct _ast *past;struct _ast{ int ivalue; char* nodeType; past left; past right;}; //结构的定义past newAstNode() //创建新的节点{ past node = malloc(sizeof(ast)); //分配节点空间 if(node == NULL) { printf("run out of memory. "); exit(0); } memset(node, 0, sizeof(ast)); return node;}past newNum(int value) //为节点赋值{ past var = newAstNode(); var->nodeType = "intValue"; var->ivalue = value; return var; }past newExpr(int oper, past left,past right) //为新建节点赋值的函数{ past var = newAstNode();//-----------------------为节点结构成员赋值var->nodeType = "expr"; var->ivalue = oper; var->left = left; var->right = right; return var;}你参考下吧。

平衡二叉树（AVL）那对图 1 进行下改造，把数据重新节点重新连接下，图 2 如下：图 2 可以看到以下特性：1. 所有左子树的节点都小于其对应的父节点（4，5，6）<（7）；（4）<（5）；（8）< （9）；2. 所有右子树上的节点都大于其对应的父节点（8，9，10）>（7）；（6）>（5）；（10）>（9）；3. 每个节点的平衡因子差值绝对值 <=1；4. 每个节点都符合以上三个特征。满足这样条件的树叫平衡二叉树（AVL）树。问：那再次查找节点 5，需要遍历多少次呢？由于数据是按照顺序组织的，那查找起来非常快，从上往下找：7-5，只需要在左子树上查找，也就是遍历 2 次就找到了 5。假设要找到叶子节点 10，只需要在右子树上查找，那也最多需要 3 次，7-9-10。也就说 AVL 树在查找方面性能很好，最坏的情况是找到一个节点需要消耗的次数也就是树的层数， 复杂度为 O(logN)如果节点非常多呢？假设现在有 31 个节点，用 AVL 树表示如图 3：图 3 是一棵高度为 4 的 AVL 树，有 5 层共 31 个节点，橙色是 ROOT 节点，蓝色是叶子节点。对 AVL 树的查找来看起来已经很完美了，能不能再优化下？比如，能否把这个节点里存放的 KEY 增加？能否减少树的总层数？那减少纵深只能从横向来想办法，这时候可以考虑用多叉树。

1、确定树的根。树根是当前树中所有元素在后序遍历中最后出现的元素。2、求解树的子树。找出根节点在中序遍历中的位置，根左边的所有元素就是左子树，根右边的所有元素就是右子树。若根节点左边或右边为空，则该方向子树为空；若根节点左边和右边都为空，则根节点已经为叶子节点。3、递归求解树。将左子树和右子树分别看成一棵二叉树，重复1、2、3步，直到所有的节点完成定位。举例说明：根据已知求解二叉树中序序列 HLDBEKAFCG后序序列 LHDKEBFGCA1、在后序序列LHDKEBFGCA中最后出现的元素为A，HLDBEK|A|FCG2、在后序序列LHDKEB中最后出现的元素为B，HLD|B|EK|A|FCG3、在后序序列LHD中最后出现的元素为D，HL|D|B|EK|A|FCG4、在后序序列LH中最后出现的元素为H，H|L|D|B|EK|A|FCG5、在后序序列KE中最后出现的元素为E，H|L|D|B|E|K|A|FCG5、在后序序列FGC中最后出现的元素为C，H|L|D|B|E|K|A|F|C|G6、所有元素都已经定位，二叉树求解完成，如下 A / B C / / D E F G / H K L

1973年，布莱克和舒尔斯(Black and Scholes)提出了Black-Scholes期权定价模型，对标的资产的价格服从对数正态分布的期权进行定价。随后，罗斯开始研究标的资产的价格服从非正态分布的期权定价理论。1976年，罗斯和约翰·考科斯(John Cox)在《金融经济学杂志》上发表论文“基于另类随机过程的期权定价”，提出了风险中性定价理论。1979年，罗斯、考科斯和马克·鲁宾斯坦(Mark Rubinstein)在《金融经济学杂志》上发表论文“期权定价：一种简化的方法”，该文提出了一种简单的对离散时间的期权的定价方法，被称为Cox-Ross-Rubinstein二项式期权定价模型。二项式期权定价模型和布莱克-休尔斯期权定价模型，是两种相互补充的方法。二项式期权定价模型推导比较简单，更适合说明期权定价的基本概念。二项式期权定价模型建立在一个基本假设基础上，即在给定的时间间隔内，证券的价格运动有两个可能的方向：上涨或者下跌。虽然这一假设非常简单，但由于可以把一个给定的时间段细分为更小的时间单位，因而二项式期权定价模型适用于处理更为复杂的期权。随着要考虑的价格变动数目的增加，二项式期权定价模型的分布函数就越来越趋向于正态分布，二项式期权定价模型和布莱克-休尔斯期权定价模型相一致。二项式期权定价模型的优点，是简化了期权定价的计算并增加了直观性，因此现在已成为全世界各大证券交易所的主要定价标准之一。一般来说，二项期权定价模型的基本假设是在每一时期股价的变动方向只有两个，即上升或下降。BOPM的定价依据是在期权在第一次买进时，能建立起一个零风险套头交易，或者说可以使用一个证券组合来模拟期权的价值，该证券组合在没有套利机会时应等于买权的价 格；反之，如果存在套利机会，投资者则可以买两种产品种价格便宜者，卖出价格较高者，从而获得无风险收益，当然这种套利机会只会在极短的时间里存在。这一 证券组合的主要功能是给出了买权的定价方法。与期货不同的是，期货的套头交易一旦建立就不用改变，而期权的套头交易则需不断调整，直至期权到期。

二项期权定价模型假设股价波动只有向上和向下两个方向，且假设在整个考察期内，股价每次向上(或向下)波动的概率和幅度不变。模型将考察的存续期分为若干阶段，根据股价的历史波动率模拟出正股在整个存续期内所有可能的发展路径，并对每一路径上的每一节点计算权证行权收益和用贴现法计算出的权证价格。对于美式权证，由于可以提前行权，每一节点上权证的理论价格应为权证行权收益和贴现计算出的权证价格两者较大者。构建二项式期权定价模型编辑1973年，布莱克和舒尔斯(Black and Scholes)提出了Black-Scholes期权定价模型，对标的资产的价格服从对数正态分布的期权进行定价。随后，罗斯开始研究标的资产的价格服从非正态分布的期权定价理论。1976年，罗斯和约翰·考科斯(John Cox)在《金融经济学杂志》上发表论文“基于另类随机过程的期权定价”，提出了风险中性定价理论。1979年，罗斯、考科斯和马克·鲁宾斯坦(Mark Rubinstein)在《金融经济学杂志》上发表论文“期权定价：一种简化的方法”，该文提出了一种简单的对离散时间的期权的定价方法，被称为Cox-Ross-Rubinstein二项式期权定价模型。二项式期权定价模型和布莱克-休尔斯期权定价模型，是两种相互补充的方法。二项式期权定价模型推导比较简单，更适合说明期权定价的基本概念。二项式期权定价模型建立在一个基本假设基础上，即在给定的时间间隔内，证券的价格运动有两个可能的方向：上涨或者下跌。虽然这一假设非常简单，但由于可以把一个给定的时间段细分为更小的时间单位，因而二项式期权定价模型适用于处理更为复杂的期权。随着要考虑的价格变动数目的增加，二项式期权定价模型的分布函数就越来越趋向于正态分布，二项式期权定价模型和布莱克-休尔斯期权定价模型相一致。二项式期权定价模型的优点，是简化了期权定价的计算并增加了直观性，因此现在已成为全世界各大证券交易所的主要定价标准之一。一般来说，二项期权定价模型的基本假设是在每一时期股价的变动方向只有两个，即上升或下降。BOPM的定价依据是在期权在第一次买进时，能建立起一个零风险套头交易，或者说可以使用一个证券组合来模拟期权的价值，该证券组合在没有套利机会时应等于买权的价 格；反之，如果存在套利机会，投资者则可以买两种产品种价格便宜者，卖出价格较高者，从而获得无风险收益，当然这种套利机会只会在极短的时间里存在。这一 证券组合的主要功能是给出了买权的定价方法。与期货不同的是，期货的套头交易一旦建立就不用改变，而期权的套头交易则需不断调整，直至期权到期。二叉树思想编辑1：Black-Scholes方程模型优缺点：优点：对欧式期权，有精确的定价公式；缺点：对美式期权，无精确的定价公式，不可能求出解的表达式，而且数学推导和求解过程在金融界较难接受和掌握。2：思想：假定到期且只有两种可能，而且涨跌幅均为10%的假设都很粗略。修改为：在T分为狠多小的时间间隔Δt，而在每一个Δt，股票价格变化由S到Su或Sd。如果价格上扬概率为p，那么下跌的概率为1-p。3：u,p,d的确定：由Black-Scholes方程告诉我们：可以假定市场为风险中性。即股票预期收益率μ等于无风险利率r，故有：SerΔt = pSu + (1 u2212 p)Sd　（23）即：e^{rDelta t}=pu+(1-p)d=E(S)　（24)又因股票价格变化符合布朗运动，从而 δS N(rSΔt,σS√Δt)（25）=>D(S) = σ2S2δt；利用D(S) = E(S2) u2212 (E(S))2E(S2) = p(Su)2 + (1 u2212 p)(Sd)2=>σ2S2Δt = p(Su)2 + (1 u2212 p)(Sd)2 u2212 [pSu + (1 u2212 p)Sd]2=>σ2Δt = p(u)2 + (1 u2212 p)(d)2 u2212 [pu + (1 u2212 p)d]2　（26）又因为股价的上扬和下跌应满足：ud=1　（27）由（24），（26），（27）可解得：其中：a = erδt。4：结论：在相等的充分小的Δt时段内，无论开始时股票价格如何。由（28）~（31）所确定的u，d和p都是常数。（即只与Δt，σ，r有关，而与S无关）。

期权价值评估二叉树是指什么二叉树期权定价模型是一种金融期权价值的评估方法,包括单期二叉树定价模型、两期二叉树模型、多期二叉树模型.1.单期二叉树定价模型期权价格=(1+r-d)/(u-d)×c/(1+r)+(u-1-r)/(u-d)×c/(1+r)u:上行乘数=1+上升百分比d:下行乘数=1-下降百分比【理解】风险中性原理的应用其中:上行概率=(1+r-d)/(u-d)下行概率=(u-1-r)/(u-d)期权价格=上行概率×Cu/(1+r)+下行概率×Cd/(1+r)2.两期二叉树模型基本原理:由单期模型向两期模型的扩展,不过是单期模型的两次应用.方法:先利用单期定价模型,根据Cuu和Cud计算节点Cu的价值,利用Cud和Cdd计算Cd的价值;然后,再次利用单期定价模型,根据Cu和Cd计算C0的价值.从后向前推进.3.多期二叉树模型原理:从原理上看,与两期模型一样,从后向前逐级推进,只不过多了一个层次.股价上升与下降的百分比的确定:期数增加以后带来的主要问题是股价上升与下降的百分比如何确定问题.期数增加以后,要调整价格变化的升降幅度,以保证年报酬率的标准差不变.把年报酬率标准差和升降百分比联系起来的公式是:u=1+上升百分比=d=1-下降百分比=其中:e-自然常数,约等于2.7183σ-标的资产连续复利报酬率的标准差t-以年表示的时段长度期权估值原理有哪些?期权估值原理有复制原理、风险中性原理.复制原理(构造借款买股票的投资组合,作为期权等价物)(1)基本思想构造一个股票和借款的适当组合,使得无论股价如何变动,投资组合的损益都与期权相同,那么,创建该投资组合的成本就是期权的价值.(2)计算公式期权价值=Co=H×So-借款数额风险中性原理(1)基本思想假设投资者对待风险的态度是中性的,所有证券的期望报酬率都应当是无风险利率.(2)基本公式到期日价值的期望值=上行概率×Cu+下行概率×Cd期权价值=到期日价值的期望值÷(1+持有期无风险利率)=(上行概率×Cu+下行概率×Cd)/(1+r)(3)上行概率的计算期望报酬率(无风险利率)=上行概率×上行时报酬率+下行概率×下行时报酬率假设股票不派发红利,股票价格的上升百分比就是股票投资的报酬率.期望报酬率(无风险利率)=上行概率×股价上升百分比+下行概率×(-股价下降百分比)期权价值评估二叉树是指什么?根据小编老师在上文中针对二叉树期权评估法的相关介绍资料,相信你们对此二叉树的类型都是有所了解的.在上文汇总的资料中小编老师也对此评估计算公式都有介绍,如果你们还有很多其他的会计问题,小编老师都是可以来这里进行免费查询的.

风险中性定价是利用风险中性假设的分析方法进行金融产品的定价，其核心是构造出风险中性概率。无套利和风险中性概率之间存在相互依存的关系，所以风险中性定价原理和无套利均衡定价原理有密切的关系。所谓的风险中性假设是如果对一个问题的分析过程与投资者的风险偏好无关，则可以将问题放到一个假设的风险中性世界里进行分析，所得的结果在真实的世界里也应当成立。利用风险中性假设可以大大简化问题的分析，因为在风险中性的世界里，对所有的资产（不管风险如何）都要求相同的收益率（无风险收益率），而且，所有资产的均衡定价都可以按照风险中性概率算出来未来收益的预期值，在以无风险利率折现得到。最后，将所得的结果放回真实的世界，就获得有真实意义的结果。参见《金融工程原理》

单期二叉树定价模型计算期权价格=（1+r-d）/（u-d）×c/（1+r）+（u-1-r）/（u-d）×c/（1+r）u：上行乘数=1+上升百分比d：下行乘数=1-下降百分比【理解】风险中性原理的应用其中：上行概率=（1+r-d）/（u-d）下行概率=（u-1-r）/（u-d）期权价格=上行概率×Cu/（1+r）+下行概率×Cd/（1+r。

【错误】

【错误】

可参考：期权、期货及其他衍生产品(原书第8版) * 作者： (加)约翰C.赫尔(John C.Hull) * 译者： 王勇 索吾林 * 丛书名： 华章教材经典译丛 * 出版社：机械工业出版社 * ISBN：9787111358213 * 出版日期：2012 年1月第12章二叉树18012.1单步二叉树模型与无套利方法18012.2风险中性定价18312.3两步二叉树18412.4看跌期权实例18612.5美式期权18612.6Delta18712.7选取u和d使二叉树与波动率吻合18812.8二叉树公式18912.9增加二叉树的时间步数19012.10使用DerivaGem软件19012.11对于其他标的资产的期权190小结193推荐阅读193练习题194作业题194附录12A 由二叉树模型推导布莱克斯科尔斯默顿期权定价公式195

风险中性：假设股票基期价格为S(0)，每期上涨幅度为U，下跌幅度为D，无风险收益率为r每年，每期间隔为t，期权行权价格为K，讨论欧式看涨期权，可以做出如下股票价格二叉树： S(0)*U*U / S(0)*U / S(0) S(0)*U*D / S(0)*D S(0)*D*D通过末期股票价格和行权价格K可以计算出末期期权价值f(uu) f(ud) f(dd)根据风险中性假设，股票每期上涨的概率是p=[e^(rt)-d]/(u-d)则f(u)=e^(-rt)*[f(uu)*p+f(ud)*(1-p)] f(d)=e^(-rt)*[f(ud)*p+f(dd)*(1-p)] f(0)=e^(-rt)*[f(u)*p+f(d)*(1-p)]联立：f(0)=e^(-2rt)*[f(uu)*p^2+2f(ud)*p*(1-p)+f(dd)*(1-p)^2]

二叉树图方法用离散的模型模拟资产价格的连续变动，利用均值和方差匹配来确定相关参数，然后从二叉树图的末端开始倒推可以计算出期权价格。

a+b的先序为+ab，中序为a+b，可见先序的第一个节点把中序序列分为左右两部分。所以题中先序序列中的A节点把DBEFAJLC分为两部分，其中A为根节点，DBEF在A的左边，JLC在A的右边；然后画DBEF的树结构，同样参考先序序列为BDEF，B节点为子树的根节点，把DBEF分为两部分，其中D在B的左边，EF在B的右边。直到划分完为止，不懂追问。

参考书答案给的是A，我也在看这道题！(转:额理论上来说所有数据结构都支持子程序的调用。。。这个题的意思应该是子程序调用的时候能看成什么样的数据结构。严格来说是栈——因为递归调用子程序的时候就是先入后出的而且是线性的。虽然子程序也可以这样调用f[i]=f[i-1]+f[i-1]看起来像是树，但是实际上还是深度优先遍历一棵树，本质上是个栈。所以说这个题的题意不清。如果说“能够使用子程序调用的数据结构”就是全选，如果是“子程序调用的时候能看成什么样的数据结构“就是栈。）

#include<stdio.h> #include<stdlib.h> #define TRUE 1 #define FALSE 0 #define MAXNUM 100 typedef int DataType; typedef struct { DataType s[MAXNUM]; int t; }SeqStack,*PSeqStack;//构造一个空栈PSeqStack createEmptyStack_seq() { PSeqStack pastack; pastack=(SeqStack*)malloc(sizeof( SeqStack)); if (pastack==NULL) { printf("空间不够!! "); } else { pastack->t=-1; } return pastack;//返回空栈顶 } //清空栈int isEmptyStack_seq(PSeqStack pastack) { return pastack->t==-1; }//入栈void push_seq(PSeqStack pastack, DataType x) { if (pastack->t >= MAXNUM - 1) printf("上溢! "); else { pastack->t = pastack->t+1; pastack->s[pastack->t]=x; } } //出栈void pop_seq(PSeqStack pastack) { if (pastack->t==-1) { printf("下溢! "); } else { pastack->t = pastack->t-1; } } //返回栈顶元素的值DataType top_seq(PSeqStack pastack) { return pastack->s[pastack->t]; } /*将中缀表达式转换为后缀表达式，顺利转换返回true，若转换过程中发现中缀表达式非法则返回false*/ int infixtoSuffix(const char* infix, char* suffix) { int state_int = FALSE; /*state_int记录状态，等于true表示刚读入的是数字字符，等于false表示刚读入的是运算符， 设置这个变量是为了在每输出一个整数后输出一个空格，以免连续输出的两个整数混在一起。*/ char c, c2; PSeqStack ps = createEmptyStack_seq(); /*构造一个运算符栈*/ int i, j = 0; if(infix[0]=="") { return FALSE; /*不允许出现空表达式*/ } for(i=0; infix[i]!="";i++) { c=infix[i]; switch(c) { case " ": case " ": case " ": if(state_int== TRUE) { suffix[j++]=" ";/*状态从true转换为false时输出一个空格*/ } state_int= FALSE; break; /*遇到空格或制表符忽略*/ case "0": case "1": case "2": case "3": case "4": case "5": case "6": case "7": case "8": case "9": state_int =TRUE; suffix[j++]=c; /*遇到数字输出*/ break; case "(": if(state_int==TRUE) { suffix[j++]=" ";/*状态从true转换为false时输出一个空格*/ } state_int=FALSE; push_seq(ps, c); /*遇到左括号，入栈*/ break; case ")": if(state_int== TRUE) { suffix[j++]=" ";/*状态从true转换为false时输出一个空格*/ } state_int=FALSE; c2 = ")"; while(!isEmptyStack_seq(ps)) { c2=top_seq(ps);/*取栈顶*/ pop_seq(ps); /*出栈*/ if(c2 =="(") { break; } suffix[j++]=c2; } if(c2 !="(") { free(ps); suffix[j++]=""; return FALSE; } break; case "+": case "-": if(state_int == TRUE) { suffix[j++] = " "; } state_int = FALSE; while(!isEmptyStack_seq(ps)) { c2 = top_seq(ps); if(c2 =="+"|| c2 =="-"|| c2 == "*" || c2 == "/") { pop_seq(ps); suffix[j++] = c2; } else if(c2=="(") { break; } } push_seq(ps, c); break; case "*": case "/": if(state_int==TRUE) { suffix[j++] = " "; } state_int = FALSE; while(!isEmptyStack_seq(ps)) { c2 = top_seq(ps); if(c2 == "*" || c2 == "/") { pop_seq(ps); suffix[j++] = c2; } else if(c2=="+"||c2=="-"||c2=="(") { break; } } push_seq(ps, c); break; default: free(ps); suffix[j++] = ""; return FALSE; } } if(state_int == TRUE) { suffix[j++] = " "; } while(!isEmptyStack_seq(ps)) { c2 = top_seq(ps); pop_seq(ps); if(c2 == "(") { free(ps); suffix[j++] = ""; return FALSE; } suffix[j++] = c2; } free(ps); suffix[j++] = ""; return TRUE; } //计算后缀int calculateSuffix(const char * suffix, int * presult) { int state_int = FALSE; PSeqStack ps = createEmptyStack_seq(); int num = 0, num1, num2; int i; char c; for(i = 0; suffix[i] != ""; i++) { c = suffix[i]; switch(c) { case "0": case "1": case "2": case "3": case "4": case "5": case "6": case "7": case "8": case "9": if(state_int == TRUE) { num = num * 10 + c - "0"; } else { num = c - "0"; } state_int = TRUE; break; case " ": case" ": case " ": if (state_int == TRUE) { push_seq(ps, num); state_int = FALSE; } break; case "+": case "-": case "*": case "/": if(state_int == TRUE) { push_seq(ps, num); state_int = FALSE; } if(isEmptyStack_seq(ps)) { free(ps); return FALSE; } num2 = top_seq(ps); pop_seq(ps); if(isEmptyStack_seq(ps)) { free(ps); return FALSE; } num1 = top_seq(ps); pop_seq(ps); if(c == "+") { push_seq(ps, num1 + num2); } if(c == "-") { push_seq(ps, num1 - num2); } if(c == "*") { push_seq(ps, num1 * num2); } if(c == "/") { push_seq(ps, num1 / num2); } break; default: free(ps); return FALSE; } } *presult = top_seq(ps); pop_seq(ps); if(!isEmptyStack_seq(ps)) { free(ps); return FALSE; } free(ps); return TRUE; } void getline(char* line, int limit) { char c; int i=0; while(i<limit-1&&(c = getchar())!=EOF&&c!=" ") { line[i++]=c; } line[i]=""; } //主函数void main() { char c, infix[MAXNUM], suffix[MAXNUM]; int result; int flag = TRUE; while(flag == TRUE) { printf("请输入任意一个整数算术表达式: "); getline(infix, MAXNUM); if(infixtoSuffix(infix, suffix) == TRUE) { printf("所有后缀为:%s ", suffix); } else { printf("无效缀! "); printf(" 继续? (y/n)"); scanf("%c", &c); if(c == "n" || c == "N") { flag = FALSE; } while(getchar() != " "); { printf(" "); } continue; } if(calculateSuffix(suffix, &result) == TRUE) { printf("结果为:%d ", result); } else { printf("非法后缀! "); } printf(" 继续? (y/n)"); scanf("%c", &c); if(c == "n" || c == "N") { flag = FALSE; } while(getchar() != " "); { printf(" "); } } }

红黑树属于平衡二叉树。说它不严格是因为它不是严格控制左、右子树高度或节点数之差小于等于1。但红黑树高度依然是平均log(n)，且最坏情况高度不会超过2log(n)，这有数学证明。所以它算平衡树，只是不严格。不过严格与否并不影响数据结构的复杂度。红黑树多用于系统底层，oi竞赛中基本不用。

1、画出该树 ：如下图左边所示。然后根据树的二叉链表表示法表示存储结构如图右边所示：注意这里的指针域为左边表示第一个孩子*firstchild，右边表示兄弟*nextsibling2、接着进行树与二叉树的转换就可以得到结果了,核心思想：左子树放孩子，右子树放兄弟，则有如图所示的二叉树：

能用C#实现吗

#include<stdio.h>#include<malloc.h>typedefstructCSNode{//孩子-兄弟节点的定义chardata;structCSNode*firstChild;structCSNode*nextSibling;}CSNode,*CSTree;intleafNum=0;//全局变量，存储叶子节点的数量voidcreateCSTree(CSTree&tree){//创建孩子-兄弟二叉树charc=getchar();if(c=="*")tree=NULL;else{tree=(CSTree)malloc(sizeof(CSNode));tree->data=c;createCSTree(tree->firstChild);createCSTree(tree->nextSibling);}}//计算叶子节点的数目，孩子-兄弟二叉树中的叶子节点是指那些没有firstChild的节点voidgetLeafNum(CSTreetree){if(tree){if(!tree->firstChild)leafNum++;getLeafNum(tree->firstChild);getLeafNum(tree->nextSibling);}}intmain(){CSTreecsTree;printf("输入孩子兄弟链表表示的树的结点：");createCSTree(csTree);getLeafNum(csTree);printf("叶子节点的数量为：%d ",leafNum);return0;}例如输入：abc***de**f*g***输出为：叶子节点的数量为：4

/*二叉树的二叉线索存储表示*/typedef enum PointerTag{Link,Thread};//Link==0:指针； Thread==1：线索typedef struct CTNode{ int data; struct CTNode *firstchild; struct CTNode *nextsibling; PointerTag LTag,RTag;}CTNode,*CTree;CTree pre=NULL;void InThreading(CTree p) /*线索化*/{if(p){InThreading(p->firstchild);// 左子树线索化if(!p->firstchild ) /*前驱线索*/{p->LTag =Thread;p->firstchild =pre;}if(!pre->nextsibling ) /*后继线索*/{pre->RTag =Thread;pre->nextsibling =p;}pre=p;//保持pre指向pInThreading(p->nextsibling );//右子树线索化}}CTree InOrderThreading(CTree Thrt,CTree ct){//中序遍历二叉树ct，并将其中序线索化，Thrt指向头结点Thrt=(CTree)malloc(sizeof(CTNode));if(!Thrt)exit(0);Thrt->LTag =Link;//建立头结点Thrt->RTag =Thread;Thrt->nextsibling =Thrt;//右指针回指if(!ct)Thrt->firstchild =Thrt;else{Thrt->firstchild =ct;pre=Thrt;InThreading(ct);//中序遍历进行中序遍历线索化pre->nextsibling =Thrt;//最后一个结点线索化pre->RTag =Thread;(Thrt)->nextsibling =pre;}return Thrt;}int print(int e){//输出结点printf("%3d",e);return 1;}/*中序遍历线索化二叉树*/int InOrderTraverse(CTree ct,int(*visit)(int e))/*中序遍历线索化二叉树*/{//ct指向头结点，头结点的做指针firstchild指向根结点，中序遍历二叉树CTree p;p=ct->firstchild ;//p指向根结点while(p!=ct)//空树或遍历结束时，p==ct{while(p->LTag ==Link)p=p->firstchild ;if(!visit(p->data )) return 0; //打印while(p->RTag ==Thread&&p->nextsibling !=ct){p=p->nextsibling ;visit(p->data); //访问后继结点}p=p->nextsibling ;}return 1;}

1）由于二叉树本就是递归结构，所以可以用递归的思想：二叉树叶子个数等于左子树叶子个数+右子树叶子个数，当遇到孩子节点是空指针的时候就返回1，否则返回该子树的叶节点数。具体实现的话，可以将递归的二叉树后续遍历算法的开头添加一句话，即可。2）后续变量二叉树的非递归算法，只需要记录一个count变量即可，即每次遇到叶子节点，就将count累加。主要思想就是，后续变量二叉树。

***** *****我这有个线索二叉树的例子： ***** *****首先需要定义线索二叉树，定义如下： //线索二叉树结点类型存储结构体TBSTree2.h template<class T> class TBSTree; template<class T> class ITBSTree; template<class T> struct THNode {public: int lflag,rflag;//标志域 THNode<T> *left;//第一个孩子结点指针域 THNode<T> *right;//下一个兄弟结点指针域 T data;//数据域 friend class TBSTree<T>;//线索二叉树类为友元 friend class ITBSTree<T>;//派生类 //构造函数 THNode():left(NULL),right(NULL),lflag(0),rflag(0){ } THNode(int la,int ra,T value,THNode<T> *fc=NULL, THNode<T> *ns=NULL):data(value),left(fc), right(ns){lflag=la;rflag=ra;} //访问指针域的成员函数 THNode<T>* &FirstChild() {return left;} THNode<T>* &NextSibling() {return right;} }; //线索二叉树类 template<class T> class TBSTree {protected: THNode<T> *root;//根结点指针 THNode<T> *curr;//当前结点指针 int nextC; int priorC; public: //构造函数与析构函数 TBSTree(){root=curr=NULL;} TBSTree(THNode<T> *&tree) {root=tree; curr=root; if(tree==NULL) {nextC=1;priorC=1;} else {nextC=0;priorC=0;} } //纯虚函数 virtual void First()=0; virtual void Last()=0; //数据检索与修改成员函数 T &Data(); }; //线索二叉树类的实现 template<class T> T &TBSTree<T>::Data() {if(root==NULL) {cout<<"二叉树空! ";exit(1);} return curr->data; } //由结点构造线索二叉树的类外一般函数 template<class T> THNode<T> *GetTreeNode(T item,THNode<T> *le=NULL, THNode<T> *ri=NULL,int lf=0,int rf=0) {THNode<T> *p=new THNode<T>; p->data=item;p->left=le;p->right=ri; p->lflag=lf;p->rflag=rf; if(p==NULL) {cerr<<"内存分配失败! ";exit(1);} return p; } //创建特定线索二叉树的类外一般函数 template<class T> THNode<T> *MakeCharT(THNode<T> *&root,int num) {THNode<T> *b,*c,*d,*e,*f,*g,*null=NULL; if(num==1) {e=GetTreeNode("R"); f=GetTreeNode("W"); d=GetTreeNode("P",e,f); g=GetTreeNode("Q"); b=GetTreeNode("N",d,g); c=GetTreeNode("O"); root=GetTreeNode("M",b,c); } else { g=GetTreeNode("G"); d=GetTreeNode("D",null,g); b=GetTreeNode("B",d); e=GetTreeNode("E"); f=GetTreeNode("F"); c=GetTreeNode("C",e,f); root=GetTreeNode("A",b,c); } return root; } ***** *****接着是测试程序，代码如下： //线索二叉树类相关操作的测试TBSTree2M.cpp #include<iostream.h> #include<iomanip.h> #include<stdlib.h> #include<conio.h> #include "TBSTree2.h" #include "ITBSTree2.h" void main() {cout<<"TBSTree2M.cpp运行结果: "; THNode<char> *q,*p; q=MakeCharT(q,2); ITBSTree<char> t(q); t.CreatInThread(); cout<<"二叉树的中序正向遍历序列为: "; t.First(); cout<<" 二叉树的中序反向遍历序列为: "; t.Last(); p=MakeCharT(p,1); ITBSTree<char> d(p); d.CreatInThread(); cout<<" 二叉树的中序正向遍历序列为: "; d.First(); cout<<" 二叉树的中序反向遍历序列为: "; d.Last(); cin.get(); } ***** *****以下是程序运行结果，自己试试吧，先跑起来，然后慢慢看懂它： TBSTree2M.cpp运行结果: 二叉树的中序正向遍历序列为: D G B A E C F 二叉树的中序反向遍历序列为: F C E A B G D 二叉树的中序正向遍历序列为: R P W N Q M O 二叉树的中序反向遍历咦？悬赏分没有吗？

如下#define MAX(a,b) ( a > b ? a : b )typedef struct BitNode{BitNode *left;BitNode *right;Element data;}BitNode, *pBitTree;int getBitTreeDeep( pBitTree root ){if( !root )return 0;return ( MAX( getBitTreeDeep( root->left ) , getBitTreeDeep( root->right ) ) + 1 );}

转换如下： A / X X B- C- D | E / X F - G A / B C / E D / F G将树转换为二叉树 　树中每个结点最多只有一个最左边的孩子(长子)和一个右邻的兄弟。按照这种关系很自然地就能将树转换成相应的二叉树：①在所有兄弟结点之间加一连线；②对每个结点，除了保留与其长子的连线外，去掉该结点与其它孩子的连线。 ③调整数的形状为正常二叉树即可

二叉树是采用递归定义的，实现起来代码简洁（也许并不简单）。并且它在具体的计算机科学中有很重要的运用，是一种很重要的数据结构，二叉树有三种遍历和建立的方式。今天先学习一下它的建立和打印。以下代码在Win-Tc1.9.1下编译通过。#include <stdio.h>#define ElemType char//节点声明，数据域、左孩子指针、右孩子指针typedef struct BiTNode{ char data; struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;//先序建立二叉树BiTree CreateBiTree(){ char ch; BiTree T; scanf("%c",&ch); if(ch=="#")T=NULL; else{ T = (BiTree)malloc(sizeof(BiTNode)); T->data = ch; T->lchild = CreateBiTree(); T->rchild = CreateBiTree(); } return T;//返回根节点}//先序遍历二叉树void PreOrderTraverse(BiTree T){ if(T){ printf("%c",T->data); PreOrderTraverse(T->lchild); PreOrderTraverse(T->rchild); }}//中序遍历void InOrderTraverse(BiTree T){ if(T){ PreOrderTraverse(T->lchild); printf("%c",T->data); PreOrderTraverse(T->rchild); }}//后序遍历void PostOrderTraverse(BiTree T){ if(T){ PreOrderTraverse(T->lchild); PreOrderTraverse(T->rchild); printf("%c",T->data); }}void main(){ BiTree T; T = CreateBiTree();//建立 PreOrderTraverse(T);//输出 getch();}

有一定的编码技术就是应用遍历的

是的我看上面这位已说出来了我就跟贴把，要不动那就没办法了

#include <stdio.h>#include <malloc.h>typedef struct node{int data;struct node *lchild,*rchild;}*treetp,tree;treetp create (treetp t,int c);void print1(treetp);void print2(treetp);void print3(treetp);int number=0;void main(){treetp t=0,r;r=create (t,0);printf("前序排列 ：");print1 (r);printf("\n中序排列 ：");print2 (r);printf("\n后序排列 ：");print3 (r);}treetp create(treetp t,int c){treetp p,di;do{scanf("%d",&c);if (t==0){t=(treetp)malloc(sizeof(tree));t->lchild=t->rchild=0;t->data=c;}else{ p=t;while(p!=0){di=p;if(c<(p->data))p=p->lchild;elsep=p->rchild;}if(c<(di->data)){treetp NEWdi=(treetp) malloc(sizeof(tree));NEWdi->lchild=NEWdi->rchild=0;NEWdi->data=c;di->lchild=NEWdi;}else{treetp NEWdi=(treetp) malloc(sizeof(tree));NEWdi->lchild=NEWdi->rchild=0;NEWdi->data=c;di->rchild=NEWdi;}}++number;}while(c!=0);printf("叶子的数量：%d",number);return t;}void print1(treetp t){if (t!=0){printf("%d ",t->data);print1(t->lchild);print1(t->rchild);}}void print2(treetp t){if (t!=0){print2(t->lchild);printf("%d ",t->data);print2(t->rchild);}}void print3(treetp t){if (t!=0){print3(t->lchild);print3(t->rchild);printf("%d ",t->data);}}

#include <stdio.h> #define N 100 typedef struct node { char data; struct node *lchild,*rchild; }BTNode; /*---二叉树的建立---*/ BTNode *createbintree() { BTNode *t; char x; scanf("%c",&x); if (x=="#") t=NULL; else { t=(BTNode *)malloc(sizeof(BTNode)); t->data=x; t->lchild=createbintree(); t->rchild=createbintree(); } return(t); } /*---先序遍历算法---*/ void preorder(BTNode *t) { if(t!=NULL) { printf("%c ",t->data); preorder(t->lchild); preorder(t->rchild); } } /*---中序遍历算法(递归算法)---*/ void inorder(BTNode *t) { if(t!=NULL) { inorder(t->lchild); printf("%c ",t->data); inorder(t->rchild); } } /*---后序遍历算法---*/ void postorder(BTNode *t) { if(t!=NULL) { postorder(t->lchild); postorder(t->rchild); printf("%c ",t->data); } } /*---中序遍历算法(非递归算法)---*/ void inorder1(BTNode *t) { int i=0; BTNode *a[N],*p; if(t==NULL) return; p=t; do { while(p) { a[i++]=p; p=p->lchild; } if(i!=0) { p=a[--i]; printf("%c ",p->data); p=p->rchild; } }while(i!=0 || p); } /*---互换左右孩子算法---*/ void swap(BTNode *t) { BTNode *p; if(t!=NULL || (t->lchild==NULL && t->rchild==NULL)) { p=t->lchild; t->lchild=t->rchild; t->rchild=p; swap(t->lchild); swap(t->rchild); } } /*---选择函数---*/ void select(BTNode *t) { int m,n; printf(" select the algorithm 1. Preorder 2. Inorder(Recursive) 3. Inorder(Non-recursive) 4. Postorder 5. Swap lchild and rchild "); scanf("%d",&m); switch(m) { case 1:preorder(t);break; case 2:inorder(t);break; case 3:inorder1(t);break; case 4:postorder(t);break; case 5:swap(t);preorder(t);break; default:printf("ERROR!! Please select again... ");select(t); } printf(" 1. Continue 2. Exit "); scanf("%d",&n); switch(n) { case 2:break; case 1: default:select(t); } } void main() { BTNode *t; printf("Please input the sequence of the bintree.. PS:a "#" for NULL Example:"AB#C#D##EF##G##"! "); printf(" bintree:"); t=createbintree(); select(t); }

#include<stdio.h>#include<stdlib.h>typedef struct BiT{char data;struct BiT *lchild;struct BiT *rchild;}BiT;BiT* CreateBiTree(BiT *T) { //构造二叉链表表示的二叉树T char ch; scanf("%c",&ch); if (ch=="#") T = NULL; else { T = (BiT *)malloc(sizeof(BiT)); T->data = ch; T->lchild=CreateBiTree(T->lchild); T->rchild=CreateBiTree(T->rchild); } return T;}void PreOrderTraverse(BiT *T) { // 先序遍历二叉树T if (T) { printf("%c",T->data); PreOrderTraverse(T->lchild); PreOrderTraverse(T->rchild); }}void InOrderTraverse(BiT *T) { // 中序遍历二叉树T if (T) { InOrderTraverse(T->lchild); printf("%c",T->data); InOrderTraverse(T->rchild); }}void PostOrderTraverse(BiT *T) { // 后序遍历二叉树T if (T) { PostOrderTraverse(T->lchild); PostOrderTraverse(T->rchild); printf("%c",T->data); }}void main() { printf("先序建树:"); BiT *T=CreateBiTree(T); printf(" 先序遍历:"); PreOrderTraverse(T); printf(" 中序遍历:"); InOrderTraverse(T); printf(" 后序遍历:"); PostOrderTraverse(T); getchar();getchar();}

以前做的。 一、 需求分析 1． 本程序是是利用平衡二叉树实现一个动态查找表，实现动态查找表的三种基本功能：查找、插入和删除。 2． 初始，平衡二叉树为空树，可以按先序输入平衡二叉树，以输入0结束，中间以回车隔开，创建好二叉树后，可以对其查找，再对其插入，输入0结束插入，再可以对其删除，输入0结束，每次插入或删除一个结点后，更新平衡二叉树的显示。 3． 本程序以用户和计算机的对话方式执行，根据计算机终端显示：“提示信息”下，用户可由键盘输入要执行的操作。 4． 测试数据（附后） 二、 概要设计 1． 抽象数据类型动态查找表的定义如下： ADT DynamicSearchTable{ 数据结构D：D是具有相同特性的数据元素的集合。各个数据元素含有类型相同，可惟一标识数据元素的关键字。 数据关系R：数据元素同属一个集合。 基本操作P： InitDSTable(&DT); 操作结果：构造一个空的动态查找表DT。 DestroyDSTable(&DT); 初试条件：动态查找表DT存在。 操作结果: 销毁动态查找表DT。 SearchDSTable(DT,key); 初试条件：动态查找表DT存在，key为和关键字类型相同的给定值。 操作结果: 若DT中存在其关键字等于key的数据元素，则函数值为该元素的值或表中的位置，否则为“空”。 InsertDSTable(&DT,e); 初试条件：动态查找表DT存在，e为待插入的数据元素。 操作结果: 若DT中不存在其关键字等于e. key的数据元素，则插入e到DT。 DeleteDSTable(&DT,key); 初试条件：动态查找表DT存在，key为和关键字类型相同的给定值。 操作结果: 若DT中存在其关键字等于key的数据元素，则删除之。 TraverseDSTable(DT,Visit()); 初试条件：动态查找表DT存在，Visit()是结点操作的应用函数。 操作结果: 按某种次序对DT的每个结点调用函数Visit()一次且至多 一次。一但Visit()失败，则操作失败。 }ADT DynamicSearchTable 2． 本程序包含两个模块： Void main(){ Do{ 接受命令（根据提示输入终点城市和起点城市的序号）； 处理命令； }while(“命令”=“退出”)； } 3．本程序只有两个模块，调用关系简单 主程序模块 平衡二叉树的模块 三、 详细设计 1． 根据题目要求和查找的基本特点，其结点类型 typedef struct BSTnode{ int data; int bf; struct BSTnode *lchild,*rchild; }BSTnode,*bstree; #define LH +1 #define EH 0 #define RH -1 /-----------------------------************对平衡二叉树的操作 bstree InsertAVL(bstree &T, int e)； ////////在平衡二叉树中插入结点。 int FindAVL(bstree p,int e)； ////////查找平衡二叉树中是否有结点e。 bstree DeleteAVL(bstree &T,int e) ////////删除平衡平衡二叉树的结点e，并保持平衡二叉树的性质。 int Preordertraverse(bstree T) ////////按先序遍历平衡二叉树。 /------------------------************平衡二叉树的操作的详细算法 bstree InsertAVL(bstree &T, int e) { bstree p; //插入新结点，树长高置taller为TRUE if(!T) { T=(bstree)malloc(sizeof(BSTnode)); T->data=e; T->lchild=T->rchild=NULL; T->bf=EH; taller=TRUE; } else { //树中存在和e有相同关键字的结点则不再插入 if(e==T->data){ taller=FALSE; return NULL; } //值小于则继续在树的左子树中搜索 if(e < T->data){ //插入到左子树且左子树长高 p=InsertAVL(T->lchild,e); if(p){ T->lchild=p; if(taller) { switch(T->bf){ //检查*T的平衡度 case LH: //原本左子树比右子树高，需要做左平衡处理 T=LeftBalance(T); taller=FALSE; break; case EH: //原本左子树和右子树同高，现因左子树争高而使树增高 T->bf=LH; taller=TRUE; break; case RH: //原本右子树比左子树高，现在左右子树等高 T->bf=EH; taller=FALSE; break; }///////switch(T->bf) }///////if(taller) }/////if(p) }///////if(e < T->data) //继续在*T的右子树中搜索 else{ //插入到右子树且使右子树长高 p=InsertAVL(T->rchild,e); if (p){ T->rchild=p; if(taller) { switch(T->bf){ //检查*T的平衡度 case LH: //原本左子树比右子树高，现在左右子树等高 T->bf=EH; taller=FALSE; break; case EH: //原本左子树和右子树同高，现因右子树增高而使树增高 T->bf=RH; taller=TRUE; break; case RH: //原本右子树比左子树高，需要做右平衡处理 T=RightBalance(T); taller=FALSE; break; }//////switch(T->bf) }/////if(taller) }/////if (p) }//////if(e > T->data) }///////else return T; } int Preordertraverse(bstree T){ if(T){ printf(" %d %d ",T->data,T->bf); Preordertraverse(T->lchild); Preordertraverse(T->rchild); } return 1; } int FindAVL(bstree p,int e){ if(p==NULL)return NULL; else if(e==p->data) return true; else if(e<p->data){ p=p->lchild; return FindAVL(p, e); }////左子树上查找 else { p=p->rchild; return FindAVL( p, e); }////右子树上查找 } bstree DeleteAVL(bstree &T,int e){ //删除后要保证该二叉树还是平衡的 int n,m=0;/////标记 bstree q; if(!T)return NULL; else { if(e==T->data) {////直接删除 n=Delete(T,e); m=n; if(m!=0) { q=T; DeleteAVL(T,m); q->data=m;} } else { if(e<T->data){////在左子树上寻找 DeleteAVL(T->lchild,e); if(shorter){ switch(T->bf){ case LH:T->bf=EH;shorter=true;break; case EH:T->bf=RH;shorter=false;break; case RH:Delete_Rightbalance(T);shorter=true;break; }////switch(T->bf) }/////if(shorter) }/////if(e<T->data) else{ /////////在右子树上寻找 DeleteAVL(T->rchild,e); if(shorter) switch(T->bf){ case LH:Delete_Leftbalance(T);shorter=true;break; case EH:T->bf=LH;shorter=false;break; case RH:T->bf=EH;shorter=true;break; }////////switch(T->bf) }////////在右子数上寻找完 }////////在左右子上完 }///////////删除完 return T; } 2． 主程序和其他伪码算法 void main(){ while(e!=0){ if(e!=0) InsertAVL(T,e); } while(d!=0){ if(d!=0) InsertAVL(T,d); Preordertraverse(T); } c=FindAVL(T,t); if(c==1)printf("有要查找的节点 "); else printf("无要查找的节点 "); do{ DeleteAVL(T,b); Preordertraverse(T); }while(b==1); } ///右旋 bstree R_Rotate(bstree &p){ bstree lc; lc=p->lchild; p->lchild=lc->rchild; lc->rchild=p; p=lc; return p; } ////左旋 bstree L_Rotate(bstree &p){ bstree rc; rc=p->rchild; p->rchild=rc->lchild; rc->lchild=p; p=rc; return p; } /////左平衡处理 bstree LeftBalance(bstree &T){ bstree lc,rd; lc=T->lchild; //lc指向*T的左子树根结点 switch(lc->bf) { //检查*T的左子树平衡度，并做相应的平衡处理 case LH: //新结点插入在*T的左孩子的左子树上，要做单右旋处理 T->bf=lc->bf=EH; T=R_Rotate(T); break; case RH: //新结点插入在*T的左孩子的右子树上，要做双旋处理 rd=lc->rchild; //rd指向*T的左孩子的右子树根 switch(rd->bf){ //修改*T及其左孩子的平衡因子 case LH: T->bf=RH; lc->bf=EH; break; case EH: T->bf=lc->bf=EH; break; case RH: T->bf=EH; lc->bf=LH; break; }//////////switch(rd->bf) rd->bf=EH; T->lchild=L_Rotate(T->lchild); //对*T的左孩子做左旋平衡处理 T=R_Rotate(T); //对*T做右旋处理 }////////switch(lc->bf) return T; } ////右平衡处理 bstree RightBalance(bstree &T) { bstree rc,ld; rc=T->rchild; //rc指向*T的右子树根结点 switch(rc->bf) { //检查*T的右子树平衡度，并做相应的平衡处理 case RH: //新结点插入在*T的右孩子的右子树上，要做单右旋处理 T->bf=rc->bf=EH; T=L_Rotate(T); break; case LH: //新结点插入在*T的右孩子的左子树上，要做双旋处理 ld=rc->lchild; //ld指向*T的右孩子的左子树根 switch(ld->bf){ //修改*T及其右孩子的平衡因子 case LH: T->bf=EH; rc->bf=RH; break; case EH: T->bf=rc->bf=EH; break; case RH: T->bf=LH; rc->bf=EH; break; }///switch(ld->bf) ld->bf=EH; T->rchild=R_Rotate(T->rchild); //对*T的右孩子做右旋平衡处理 T=L_Rotate(T); //对*T做左旋处理 }/////switch(rc->bf) return T; } int Delete(bstree &T,int e){ //删除结点 bstree p,q; e=0; p=T; if(!T->rchild) {//右子数为空需要重接它的左子数 T=T->lchild; free(p); shorter=true; } else if(!T->lchild) {//重接它的右子数 T=T->rchild; free(p); shorter=true; } else{ //左右子数均不空 q=T->lchild; while(q->rchild!=NULL){//转左，然后向右到尽头 q=q->rchild; } e=q->data; } return e; } void Delete_Rightbalance(bstree &T){ ///////////删除在左子树上的，相当于插入在右子树 bstree rc=T->rchild,ld; switch(rc->bf){ case LH://///////双旋 ，先右旋后左旋 ld=rc->lchild; rc->lchild=ld->rchild; ld->rchild=rc; T->rchild=rc->lchild; rc->lchild=T; switch(ld->bf) { case LH:T->bf=EH; rc->bf=RH; break; case EH:T->bf=rc->bf=EH; break; case RH:T->bf=LH; rc->bf=EH; break; } ld->bf=EH; T=rc; shorter=true;break; case EH:///////删除在左子树，相当于插入在右子树，左单旋 T->rchild=rc->lchild; rc->lchild=T; rc->bf=LH; T->bf=RH; T=rc; shorter=EH;break; case RH:///////删除在左子树，相当于插入在右子树，左单旋 T->rchild=rc->lchild; rc->lchild=T; rc->bf=T->bf=EH; T=rc; shorter=true;break; } } void Delete_Leftbalance(bstree &T)/////删除右子树上的，相当于插入在左子树上 { bstree p1,p2; p1=T->lchild; switch(p1->bf) { case LH:T->lchild=p1->rchild;//////右旋 p1->rchild=T; p1->bf=T->bf=EH; T=p1; shorter=true; break; case EH:T->lchild=p1->rchild;///////右旋 p1->rchild=T; p1->bf=RH; T->bf=LH; T=p1; shorter=false; break; case RH:p2=p1->rchild;//////////右双旋 p1->rchild=p2->lchild; p2->lchild=p1; T->lchild=p2->rchild; p2->rchild=T; switch(p2->bf){ case LH:T->bf=RH;p1->bf=EH;break; case EH:T->bf=EH;p1->bf=EH;break; case RH:T->bf=EH;p1->bf=LH;break; } p2->bf=EH; T=p2; shorter=true;break; } } 3． 函数的调用关系图 Main InsertAVL Preordertraverse FindAVL DeleteAVL 四、 调试分析 1． 在开始对平衡二叉树的插入后，再做平衡处理时，特别是在做双向旋转平衡处理后的更新时，费了一些时间； 2． 在做平衡二叉树的删除时，当删除结点左右孩子均在时，开始直接用左子树的最大数代替，然后直接删除结点，结果导致删除了将要删除的结点及其孩子均删除了，后来将要删除的结点用左子树的最大树代替后，对左子树的最大结点做好标记，然后再做对其做删除处理。 3． 本程序算法基本简单，没有多大困难，就是在分析做双旋平衡处理的更新时，开始思路有些混乱，后来就好了； 五、 用户手册 1. 本程序的运行环境为DOS操作系统，执行文件为Balanced Tree.exe。 2. 进入演示程序后，按广度遍历输入平衡二叉树，中间以回车键隔开，输入0为结束；再输入要插入的结点，输入0结束，再输入要查找的结点，最后可以输入要删除的结点，输入0结束 六、 测试结果 先按广度遍历创建平衡二叉树（亦可一个一个的插入二叉树的结点）（50 20 60 10 30 55 70 5 15 25 58 90） ，输入0结束，然后可插入结点（39），其会显示插入后的二叉树，输入0，不再插入；输入要查找结点（6），输入要删除的结点（20），其显示如下： 七、 附录 Balance Tree.cpp

T* getTheOne(T* t){ if (t == NULL) return NULL; T leftchild = t->left; while (leftchild != NULL) { t = leftchild; leftchild = t->left; } return t;}所谓"后序序列的第一个节点"，就是一直取左子树，直到某个节点没有左子树为止。

二叉树的定义是递归的。用递归就可以实现了。建立二叉树,前，中，后遍历： bitree_node* creat_bitree(bitree_node *r) { ch=getchar(); if(ch=="#") return NULL; else { r=new bitree_node; r->data=ch; r->lchild=creat_bitree(r->lchild); r->rchild=creat_bitree(r->rchild); } return r; } void preorder(bitree_node *r) { bitree_node* p=r; if(p==NULL) return; else { cout<<p->data; preorder(p->lchild); preorder(p->rchild); } } void inorder(bitree_node *r) { bitree_node* p=r; if(p==NULL) return; else { inorder(p->lchild); cout<<p->data; inorder(p->rchild); } } void postorder(bitree_node *r) { bitree_node* p=r; if(p==NULL) return; else { postorder(p->lchild); postorder(p->rchild); cout<<p->data; } }

CreateBiTree ( BiTree T ) 改成CreateBiTree ( BiTree &T )不要以为指针传递就等于能改变参数值.指针传递改变的只是它指向的内存空间的值,而不是指针变量本身的值.你现在要改变的是T本身的值,必须用引用传递,或者二级指针.

记录下节点的深度，比如根节点深度1，第二层2，第三层3.。。判断是否非空，第一层访问根节点，第二层左右子树，这都好说。第三层开始访问完左边两个节点后，指针向上两层，找到根节点，再下去右节点，依次访问第N曾就向上回N-1层，慢慢走个遍，看看里面是不是可以有递归算法

比对着书上的写，书上不是有好几个例子吗，前序 中序 后序遍历 ，用递归或者普通方法都可以

文件 main.cpp 代码如下： #include<malloc.h> // malloc()等 #include<stdio.h> // 标准输入输出头文件，包括EOF(=^Z或F6)，NULL等 #include<stdlib.h> // atoi()，exit() #include<math.h> // 数学函数头文件，包括floor()，ceil()，abs()等#define ClearBiTree DestroyBiTree // 清空二叉树和销毁二叉树的操作一样typedef struct BiTNode { int data; // 结点的值 BiTNode *lchild,*rchild; // 左右孩子指针 }BiTNode,*BiTree;int Nil=0; // 设整型以0为空void visit(int e) { printf("%d ",e); // 以整型格式输出 } void InitBiTree(BiTree &T) { // 操作结果：构造空二叉树T T=NULL; } void CreateBiTree(BiTree &T) { // 算法6.4：按先序次序输入二叉树中结点的值(可为字符型或整型，在主程中定义)， // 构造二叉链表表示的二叉树T。变量Nil表示空(子)树。修改 int number; scanf("%d",&number); // 输入结点的值 if(number==Nil) // 结点的值为空 T=NULL; else // 结点的值不为空 { T=(BiTree)malloc(sizeof(BiTNode)); // 生成根结点 if(!T) exit(OVERFLOW); T->data=number; // 将值赋给T所指结点 CreateBiTree(T->lchild); // 递归构造左子树 CreateBiTree(T->rchild); // 递归构造右子树 } } void DestroyBiTree(BiTree &T) { // 初始条件：二叉树T存在。操作结果：销毁二叉树T if(T) // 非空树 { DestroyBiTree(T->lchild); // 递归销毁左子树，如无左子树，则不执行任何操作 DestroyBiTree(T->rchild); // 递归销毁右子树，如无右子树，则不执行任何操作 free(T); // 释放根结点 T=NULL; // 空指针赋0 } } void PreOrderTraverse(BiTree T,void(*Visit)(int)) { // 初始条件：二叉树T存在，Visit是对结点操作的应用函数。修改算法6.1 // 操作结果：先序递归遍历T，对每个结点调用函数Visit一次且仅一次 if(T) // T不空 { Visit(T->data); // 先访问根结点 PreOrderTraverse(T->lchild,Visit); // 再先序遍历左子树 PreOrderTraverse(T->rchild,Visit); // 最后先序遍历右子树 } } void InOrderTraverse(BiTree T,void(*Visit)(int)) { // 初始条件：二叉树T存在，Visit是对结点操作的应用函数 // 操作结果：中序递归遍历T，对每个结点调用函数Visit一次且仅一次 if(T) { InOrderTraverse(T->lchild,Visit); // 先中序遍历左子树 Visit(T->data); // 再访问根结点 InOrderTraverse(T->rchild,Visit); // 最后中序遍历右子树 } } void PostOrderTraverse(BiTree T,void(*Visit)(int)) { // 初始条件：二叉树T存在，Visit是对结点操作的应用函数 // 操作结果：后序递归遍历T，对每个结点调用函数Visit一次且仅一次 if(T) // T不空 { PostOrderTraverse(T->lchild,Visit); // 先后序遍历左子树 PostOrderTraverse(T->rchild,Visit); // 再后序遍历右子树 Visit(T->data); // 最后访问根结点 } } void main() { BiTree T; InitBiTree(T); // 初始化二叉树T printf("按先序次序输入二叉树中结点的值,输入0表示节点为空，输入范例：1 2 0 0 3 0 0 "); CreateBiTree(T); // 建立二叉树T printf("先序递归遍历二叉树： "); PreOrderTraverse(T,visit); // 先序递归遍历二叉树T printf(" 中序递归遍历二叉树： "); InOrderTraverse(T,visit); // 中序递归遍历二叉树T printf(" 后序递归遍历二叉树： "); PostOrderTraverse(T,visit); // 后序递归遍历二叉树T }这样可以么？

二叉树是采用递归定义的，实现起来代码简洁（也许并不简单）。并且它在具体的计算机科学中有很重要的运用，是一种很重要的数据结构，二叉树有三种遍历和建立的方式。今天先学习一下它的建立和打印。以下代码在Win-Tc1.9.1下编译通过。#include <stdio.h>#define ElemType char//节点声明，数据域、左孩子指针、右孩子指针typedef struct BiTNode{char data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;//先序建立二叉树BiTree CreateBiTree(){char ch;BiTree T;scanf("%c",&ch);if(ch=="#")T=NULL;else{T = (BiTree)malloc(sizeof(BiTNode));T->data = ch;T->lchild = CreateBiTree();T->rchild = CreateBiTree();}return T;//返回根节点}//先序遍历二叉树void PreOrderTraverse(BiTree T){if(T){printf("%c",T->data);PreOrderTraverse(T->lchild);PreOrderTraverse(T->rchild);}}//中序遍历void InOrderTraverse(BiTree T){if(T){PreOrderTraverse(T->lchild);printf("%c",T->data);PreOrderTraverse(T->rchild);}}//后序遍历void PostOrderTraverse(BiTree T){if(T){PreOrderTraverse(T->lchild);PreOrderTraverse(T->rchild);printf("%c",T->data);}}void main(){BiTree T;T = CreateBiTree();//建立PreOrderTraverse(T);//输出getch();}先序输入 如 abc##d##e## (#表示空) 输出 cbdae#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -2#include "cstdlib"#include "malloc.h"typedef int Status;typedef char TElemType;#include <stdio.h>#include <iostream>using namespace std;typedef struct BiTNode { // 结点结构 TElemType data; struct BiTNode *lchild, *rchild; // 左右孩子指针} BiTNode, *BiTree;Status CreateBiTree(BiTree &T){//构造二叉树 TElemType ch; scanf("%c",&ch); if(ch=="#") T=NULL; else{ if(!(T=(BiTree)malloc(sizeof(BiTNode)))) exit(OVERFLOW); T->data=ch; CreateBiTree(T->lchild); CreateBiTree(T->rchild); } return OK;}//CreateBiTreeStatus Visit(char Data){ printf("%c",Data); return OK;}Status InOrderTraval(BiTree pTree){ if(pTree) { if(InOrderTraval(pTree->lchild)) { if(Visit(pTree->data)) { if(InOrderTraval(pTree->rchild)) { return OK; } } return ERROR; } return ERROR; } else { return OK; }}Status v(char a){ printf("%c",a); return OK;}void main(){ BiTree A,b; printf("先序输入，空用 ＃ 表示： "); CreateBiTree(A); b=A; printf("中序输出： "); InOrderTraval(b); }

#include<iostream.h>#include<malloc.h>#define FALSE 0#define TRUE 1#define OK 1#define maxsize 100typedef int status;typedef int elemtype;typedef struct binode{ elemtype data; struct binode *lchild,*rchild;}binode,*bitree;status treecreated=FALSE;status createbitree(bitree *t);status preordertraverse(bitree t); //前序status inordertraverse(bitree t); //中序status postordertraverse(bitree t); //后序void main(){ int choice=0; status leave=FALSE,flag; binode *bt; cout<<"===========二叉树演示程序==============="<<endl; do { cout<<"1：创建一个二叉树，按先序遍历结果输入，空用0表示 "<<endl; cout<<"2：先序遍历二叉树，递归方式遍历二叉树 "<<endl; cout<<"3：中序遍历二叉树，递归方式遍历二叉树"<<endl; cout<<"4：后序遍历二叉树，递归方式遍历二叉树"<<endl; cout<<"0：退出"<<endl; cout<<"-------请输入你的选择:"<<endl; cin>>choice; switch(choice) { case 1: if(treecreated) { cout<<"sorry,the tree has been already created!"<<endl; break; } cout<<"请输入代表树的数字："<<endl; flag=createbitree(&bt); if(flag==OK) { cout<<"你已经建立了一棵树了！"<<endl; treecreated=TRUE; } break; case 2: if(!treecreated) { cout<<"sorry,you must create a tree for further steps!"<<endl; break; } cout<<"先序遍历顺序:"<<endl; preordertraverse(bt); cout<<endl; break; case 3: if(!treecreated) { cout<<"sorry,you must create a tree for further steps!"<<endl; break; } cout<<"中序遍历顺序:"<<endl; inordertraverse(bt); cout<<endl; break; case 4: if(!treecreated) { cout<<"sorry,you must create a tree for further steps!"<<endl; break; } cout<<"后序遍历顺序:"<<endl; postordertraverse(bt); cout<<endl; break; case 0: leave=TRUE; break; } }while(!leave); cout<<"thank for using, bye-bye!"<<endl;}//递归方法实现创建status createbitree(bitree *t){ int ch=0; cin>>ch; if(ch==0) (*t)=NULL; else { (*t)=(bitree)malloc(sizeof(binode)); (*t)->data=ch; createbitree(&(*t)->lchild); createbitree(&(*t)->rchild); } return OK;}//递归方法实现先序遍历status preordertraverse(bitree t){ if(t) { cout<<t->data<<" "; preordertraverse(t->lchild); preordertraverse(t->rchild); return OK; } else return FALSE;}//递归方法实现中序遍历status inordertraverse(bitree t){ if(t!=NULL) { inordertraverse(t->lchild); cout<<t->data<<" "; inordertraverse(t->rchild); return OK; } else return FALSE;}//递归方法实现后序遍历status postordertraverse(bitree t){ if(t) { postordertraverse(t->lchild); postordertraverse(t->rchild); cout<<t->data<<" "; return OK; } else return FALSE;}

二叉树的基本操作 C语言实现/*程序实现内容1．采用二叉树链表作为存储结构，建立二叉树；2．对二叉树分别按先、中、后序以及按层次遍历，输出相应的访问序列；3．计算二叉树的深度，统计所有叶子结点总数及树中包含的结点总数。*/#include"stdio.h"#include"string.h"#include"malloc.h"#define Max 20 //结点的最大个数typedef struct node{char data;struct node *lchild,*rchild;}BinTNode; //自定义二叉树的结点类型typedef BinTNode *BinTree; //定义二叉树的指针int NodeNum,leaf; //NodeNum为结点数，leaf为叶子数//基于先序遍历算法创建二叉树//要求输入先序序列，其中加入虚结点“#”以示空指针的位置BinTree CreatBinTree(void){BinTree T;char ch;if((ch=getchar())=="#")return(NULL); //读入#，返回空指针else{T=(BinTNode *)malloc(sizeof(BinTNode));//生成结点T->data=ch;T->lchild=CreatBinTree(); //构造左子树T->rchild=CreatBinTree(); //构造右子树return(T);}}//DLR 先序遍历void Preorder(BinTree T){if(T) {printf("%c",T->data); //访问结点Preorder(T->lchild); //先序遍历左子树Preorder(T->rchild); //先序遍历右子树}}//LDR 中序遍历void Inorder(BinTree T){if(T) {Inorder(T->lchild); //中序遍历左子树printf("%c",T->data); //访问结点Inorder(T->rchild); //中序遍历右子树}}//LRD 后序遍历void Postorder(BinTree T){if(T) {Postorder(T->lchild); //后序遍历左子树Postorder(T->rchild); //后序遍历右子树printf("%c",T->data); //访问结点}}//采用后序遍历求二叉树的深度、结点数及叶子数的递归算法int TreeDepth(BinTree T){int hl,hr,max;if(T){hl=TreeDepth(T->lchild); //求左深度hr=TreeDepth(T->rchild); //求右深度max=hl>hr? hl:hr; //取左右深度的最大值NodeNum=NodeNum+1; //求结点数if(hl==0&&hr==0) leaf=leaf+1; //若左右深度为0，即为叶子。return(max+1);}else return(0);}//利用“先进先出”（FIFO）队列，按层次遍历二叉树void Levelorder(BinTree T){int front=0,rear=1;BinTNode *cq[Max],*p; //定义结点的指针数组cqcq[1]=T; //根入队while(front!=rear){front=(front+1)%NodeNum;p=cq[front]; //出队printf("%c",p->data); //出队，输出结点的值if(p->lchild!=NULL){rear=(rear+1)%NodeNum;cq[rear]=p->lchild; //左子树入队}if(p->rchild!=NULL){rear=(rear+1)%NodeNum;cq[rear]=p->rchild; //右子树入队}}}//主函数main(){BinTree root;int i,depth;printf(" ");printf("Creat Bin_Tree; Input preorder:"); //输入完全二叉树的先序序列，// 用#代表虚结点，如ABD###CE##F##root=CreatBinTree(); //创建二叉树，返回根结点do { //从菜单中选择遍历方式，输入序号。printf(" ********** select ************ ");printf(" 1: Preorder Traversal ");printf(" 2: Iorder Traversal ");printf(" 3: Postorder traversal ");printf(" 4: PostTreeDepth,Node number,Leaf number ");printf(" 5: Level Depth "); //按层次遍历之前，先选择4，求出该树的结点数。printf(" 0: Exit ");printf(" ******************************* ");scanf("%d",&i); //输入菜单序号（0-5）switch (i){case 1: printf("Print Bin_tree Preorder: ");Preorder(root); //先序遍历break;case 2: printf("Print Bin_Tree Inorder: ");Inorder(root); //中序遍历break;case 3: printf("Print Bin_Tree Postorder: ");Postorder(root); //后序遍历break;case 4: depth=TreeDepth(root); //求树的深度及叶子数printf("BinTree Depth=%d BinTree Node number=%d",depth,NodeNum);printf(" BinTree Leaf number=%d",leaf);break;case 5: printf("LevePrint Bin_Tree: ");Levelorder(root); //按层次遍历break;default: exit (1);}printf(" ");} while(i!=0);

您问也要说明白啊？是什么汇编？X86的？51的？96的？还是别的，十六位？八位？32位？

/* 我的QQ号为540397154，有什么疑问的话发邮件给我。 作者:佳之星勇:本人真实姓名:ss cel 你用五笔打ss cel 就知道了我的姓名 现居住在长沙*/#include<iostream>using namespace std;typedef struct BiTNode{ char data; struct BiTNode *lchild,*rchild;}BiTNode;typedef BiTNode *BiTree;//定义结点类型//建立二叉树void CreateBiTree(BiTree &T){ char ch; if((ch=getchar())==" ")//这个代表空格，可换别的字符 T=NULL; //建立空二叉树 else { T=(BiTNode *)malloc(sizeof(BiTNode)); //生成一个新结点 T->data=ch; CreateBiTree(T->lchild); //生成左子树 CreateBiTree(T->rchild); //生成右子树 }}void PreOrder(BiTree T)//先序{ if(T!=NULL) { cout<<T->data; PreOrder(T->lchild); PreOrder(T->rchild); }}void InOrder(BiTree T)//中序{ if(T!=NULL) { InOrder(T->lchild); cout<<T->data; InOrder(T->rchild); }}void PostOrder(BiTree T)//后序{ if(T!=NULL) { PostOrder(T->lchild); PostOrder(T->rchild); cout<<T->data; }}int Depth(BiTree T)/* 深度 */ { if(T==NULL) return(0); else return 1+(Depth(T->lchild)>Depth(T->rchild)? Depth(T->lchild):Depth(T->rchild)); }void main()//主函数{ BiTree Ta; CreateBiTree(Ta); cout<<"先序遍历:"<<endl; PreOrder(Ta); cout<<endl<<"中序遍历:"<<endl; InOrder(Ta); cout<<endl<<"后序遍历:"<<endl; PostOrder(Ta); cout<<endl<<"深度为"; cout<<Depth(Ta)<<endl;}/*你输入如下：ABD**EG*J***C*FHK**L**IM***（其中*代表空格，输入时*代表空格）*/

#include "iostream.h" #include "stdlib.h" #include "stdio.h" typedef char ElemType;//定义二叉树结点值的类型为字符型 const int MaxLength=10;//结点个数不超过10个 typedef struct BTNode{ ElemType data; struct BTNode *lchild,*rchild; }BTNode,* BiTree; void CreateBiTree(BiTree &T){//按先序次序输入，构造二叉链表表示的二叉树T，空格表示空树 // if(T) return; char ch; ch=getchar(); //不能用cin来输入，在cin中不能识别空格。 if(ch==" ") T=NULL; else{ if(!(T=(BTNode *)malloc(sizeof(BTNode)))) cout<<"malloc fail!"; T->data=ch; CreateBiTree(T->lchild); CreateBiTree(T->rchild); } } void PreOrderTraverse(BiTree T){//先序遍历 if(T){ cout<<T->data<<" "; PreOrderTraverse(T->lchild); PreOrderTraverse(T->rchild); } } void InOrderTraverse(BiTree T){//中序遍历 if(T){ InOrderTraverse(T->lchild); cout<<T->data<<" "; InOrderTraverse(T->rchild); } } void PostOrderTraverse(BiTree T){//后序遍历 if(T){ PostOrderTraverse(T->lchild); PostOrderTraverse(T->rchild); cout<<T->data<<" "; } } void LevelOrderTraverse(BiTree T){//层序遍历 BiTree Q[MaxLength]; int front=0,rear=0; BiTree p; if(T){ //根结点入队 Q[rear]=T; rear=(rear+1)%MaxLength; } while(front!=rear){ p=Q[front]; //队头元素出队 front=(front+1)%MaxLength; cout<<p->data<<" "; if(p->lchild){ //左孩子不为空，入队 Q[rear]=p->lchild; rear=(rear+1)%MaxLength; } if(p->rchild){ //右孩子不为空，入队 Q[rear]=p->rchild; rear=(rear+1)%MaxLength; } } } //非递归的先序遍历算法 void NRPreOrder(BiTree bt) { BiTree stack[MaxLength],p; int top; if (bt!=NULL){ top=0;p=bt; while(p!=NULL||top>0) { while(p!=NULL) { cout<<p->data; stack[top]=p; top++; p=p->lchild; } if (top>0) { top--; p=stack[top]; p=p->rchild; } } } } //非递归的中序遍历算法 void NRInOrder(BiTree bt) { BiTree stack[MaxLength],p; int top; if (bt!=NULL){ top=0;p=bt; while(p!=NULL||top>0) { while(p!=NULL) { stack[top]=p; top++; p=p->lchild; } if (top>0) { top--; p=stack[top];cout<<p->data; p=p->rchild; } } } } //非递归的后序遍历算法 /*bt是要遍历树的根指针，后序遍历要求在遍历完左右子树后，再访问根。 需要判断根结点的左右子树是否均遍历过。 可采用标记法，结点入栈时，配一个标志tag一同入栈 (1：遍历左子树前的现场保护，2：遍历右子树前的现场保护)。 首先将bt和tag(为1)入栈，遍历左子树； 返回后，修改栈顶tag为2，遍历右子树；最后访问根结点。*/ typedef struct { BiTree ptr; int tag; }stacknode; void NRPostOrder(BiTree bt) { stacknode s[MaxLength],x; BiTree p=bt; int top; if(bt!=NULL){ top=0;p=bt; do { while (p!=NULL) //遍历左子树 { s[top].ptr = p; s[top].tag = 1; //标记为左子树 top++; p=p->lchild; } while (top>0 && s[top-1].tag==2) { x = s[--top]; p = x.ptr; cout<<p->data; //tag为R，表示右子树访问完毕，故访问根结点 } if (top>0) { s[top-1].tag =2; //遍历右子树 p=s[top-1].ptr->rchild; } }while (top>0);} }//PostOrderUnrec int BTDepth(BiTree T){//求二叉树的深度 if(!T) return 0; else{ int h1=BTDepth(T->lchild); int h2=BTDepth(T->rchild); if(h1>h2) return h1+1; else return h2+1; } } int Leaf(BiTree T){//求二叉树的叶子数 if(!T) return 0; else if(!T->lchild&&!T->rchild) return 1; else return(Leaf(T->lchild)+Leaf(T->rchild)); } int NodeCount(BiTree T){//求二叉树的结点总数 if(!T) return 0; else return NodeCount(T->lchild)+NodeCount(T->rchild)+1; } void main(){ BiTree T; T=NULL; int select; //cout<<"请按先序次序输入各结点的值，以空格表示空树(输入时可连续输入):"<<endl; // CreateBiTree(T); while(1){ cout<<" 请选择要执行的操作: "; cout<<"1.创建二叉树 "; cout<<"2.二叉树的递归遍历算法（前、中、后） "; cout<<"3.二叉树的层次遍历算法 "; cout<<"4.求二叉树的深度 "; cout<<"5.求二叉树的叶子结点 "; cout<<"6.求二叉树的结点总数 "; cout<<"7.二叉树的非递归遍历算法（前、中、后） "; //此项可选做 cout<<"0.退出 "; cin>>select; switch(select){ case 0:return; case 1: cout<<"请按先序次序输入各结点的值，以空格表示空树(输入时可连续输入):"<<endl; CreateBiTree(T); break; case 2: if(!T) cout<<"未建立树，请先建树！"; else{ cout<<" 先序遍历: "; PreOrderTraverse(T); cout<<" 中序遍历: "; InOrderTraverse(T); cout<<" 后序遍历: "; PostOrderTraverse(T); } break; case 3: cout<<" 层序遍历: "; LevelOrderTraverse(T); break; case 4: cout<<"二叉树的深度为: "; cout<<BTDepth(T); break; case 5: cout<<" 叶子节点数: "; cout<<Leaf(T); break; case 6: cout<<"总节点数: "; cout<<NodeCount(T); break; case 7: if(!T) cout<<"未建立树，请先建树！"; else{ cout<<" 先序遍历: "; NRPreOrder(T); cout<<" 中序遍历: "; NRInOrder(T); cout<<" 后序遍历: "; NRPostOrder(T); } break; default: cout<<"请确认选择项: "; }//end switch }//end while }参考资料：找来的，你看看吧！

ch=getchar(); 改成cin >> ch 就应该可以了原因是前一次输入的回车还存放在键盘缓存区里

给你一个完整的例子吧。学习一下#include <stdio.h>#include <malloc.h>#include <stdlib.h>#define OK 1#define ERROR 0#define OVERFLOW -2#define MAX(a,b) (a>b?a:b)typedef char TElemType;typedef int Status;//二叉树的二叉链表存储结构typedef struct BiTNode{ TElemType data; struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;//先序遍历生成二叉树Status CreatBiTree(BiTree &T){ TElemType ch,temp; printf("输入一个元素: "); scanf("%c",&ch); temp=getchar(); //结束回车 if(ch==" ") T=NULL; //输入空格表示结点为空树 else{ if(!(T=(BiTree)malloc(sizeof(BiTNode)))) exit(OVERFLOW); T->data=ch; //生成根结点 CreatBiTree(T->lchild); //构造左子树 CreatBiTree(T->rchild); //构造右子树 } return OK;}//打印元素Status PrintElem(TElemType e){ printf("%c ",e); return OK;}//先序遍历二叉树Status PreOrderTraverse(BiTree T,Status (* Visit)(TElemType e)){ if(T){ //二叉树不为空时 if(Visit(T->data)) //访问根结点 if(PreOrderTraverse(T->lchild,Visit)) //先序遍历左子树 if(PreOrderTraverse(T->rchild,Visit)) return OK; //先序遍历右子树 return ERROR; } else return OK;}//中序遍历二叉树Status InOrderTraverse(BiTree T,Status (* Visit)(TElemType e)){ if(T){ if(InOrderTraverse(T->lchild,Visit)) if(Visit(T->data)) if(InOrderTraverse(T->rchild,Visit)) return OK; else return ERROR; } return OK;}//后序遍历二叉树Status PostOrderTraverse(BiTree T,Status (* Visit)(TElemType e)){ if(T){ if(PostOrderTraverse(T->lchild,Visit)) if(PostOrderTraverse(T->rchild,Visit)) if(Visit(T->data)) return OK; else return ERROR; } return OK;}//求二叉树的深度int BiTreeDepth(BiTree T){ if(!T) return 0; //二叉树为空树时 int Dl=0,Dr=0; if(T->lchild) Dl=BiTreeDepth(T->lchild); //求左子树深度 if(T->rchild) Dr=BiTreeDepth(T->rchild); //求右子树深度 return MAX(Dl,Dr)+1;} //主函数void main(){ BiTree T; Status (* Visit)(TElemType); Visit=PrintElem; CreatBiTree(T); printf(" 先序遍历:"); PreOrderTraverse(T,Visit); printf(" 中序遍历:"); InOrderTraverse(T,Visit); printf(" 后序遍历:"); PostOrderTraverse(T,Visit); printf(" 二叉树深度为%d",BiTreeDepth(T)); printf(" 程序结束. ");}

把Visit往下移一行就行了。也就是先遍历lchild，再Visit，最后遍历rchild。

TreeNode * RightSibling(TreeNode *T, TreeNode *e){ TreeNode *ret = NULL; if (T == NULL) //子树为空，返回空表示未找到 return ret; if (T->left == e) //若左结点为e，则返回右结点 return T->right; ret = RightSibling(T->left, e); //在左子树中找，若找到返回 if (ret != NULL) return ret; return RightSibling(T->right, e); //返回右子树中的查找结果}

Black-Scholes期权定价模型虽然有许多优点， 但是它的推导过程难以为人们所接受。在1979年， 罗斯等人使用一种比较浅显的方法设计出一种期权的定价模型， 称为二项式模型(Binomial Model)或二叉树法(Binomial tree)。 二项期权定价模型由考克斯（J.C.Cox）、罗斯（S.A.Ross）、鲁宾斯坦（M.Rubinstein）和夏普（Sharpe）等人提出的一种期权定价模型，主要用于计算美式期权的价值。其优点在于比较直观简单，不需要太多数学知识就可以加以应用。

root=creat(root,0);if(n==0) t=p;if(n==1) bt->lchild=p;if(n==2) bt->rchild=p;知道原因了吧？没执行到 bt->lchild=p;

#include<iostream>#include<stdlib.h>#include<stdio.h>staticintn=0;typedefstructtree{structtree*left;intdate;structtree*right;}treenode,*b_tree;///////插入节点/////////////////////b_treeinsert(b_treeroot,intnode){b_treenewnode;b_treecurrentnode;b_treeparentnode;newnode=(b_tree)malloc(sizeof(treenode));newnode->date=node;newnode->right=NULL;newnode->left=NULL;if(root==NULL)returnnewnode;else{currentnode=root;while(currentnode!=NULL){parentnode=currentnode;if(currentnode->date>node)currentnode=currentnode->left;elsecurrentnode=currentnode->right;}if(parentnode->date>node)parentnode->left=newnode;elseparentnode->right=newnode;}returnroot;}//////建立树///////////////////b_treecreat(int*date,intlen){b_treeroot=NULL;inti;for(i=0;i<len;i++)root=insert(root,date[i]);returnroot;}//////前序打印第K个数////////////////voidprint3(b_treeroot,intk){if(root!=NULL){n++;if(n==k)printf("%d",root->date);print3(root->left,k);print3(root->right,k);}}//////前序打印////////////////voidprint(b_treeroot){if(root!=NULL){printf("%d->",root->date);print(root->left);print(root->right);}}///////测试函数//////////////////voidmain(){b_treeroot=NULL;inti,index;intvalue;intnodelist[20];cout<<"输入树的节点，输入0结束";index=0;cin>>value;while(value!=0){nodelist[index]=value;index=index+1;cin>>value;}root=creat(nodelist,index);printf("前序打印");print(root);printf("打印问位置数");cin>>i;printf("前序打印第K个数");print3(root,i);}

#include#include#includestaticintn=0;typedefstructtree{structtree*left;intdate;structtree*right;}treenode,*b_tree;///////插入节点/////////////////////b_treeinsert(b_treeroot,intnode){b_treenewnode;b_treecurrentnode;b_treeparentnode;newnode=(b_tree)malloc(sizeof(treenode));newnode->date=node;newnode->right=NULL;newnode->left=NULL;if(root==NULL)returnnewnode;else{currentnode=root;while(currentnode!=NULL){parentnode=currentnode;if(currentnode->date>node)currentnode=currentnode->left;elsecurrentnode=currentnode->right;}if(parentnode->date>node)parentnode->left=newnode;elseparentnode->right=newnode;}returnroot;}//////建立树///////////////////b_treecreat(int*date,intlen){b_treeroot=NULL;inti;for(i=0;idate);print3(root->left,k);print3(root->right,k);}}//////前序打印////////////////voidprint(b_treeroot){if(root!=NULL){printf("%d->",root->date);print(root->left);print(root->right);}}///////测试函数//////////////////voidmain(){b_treeroot=NULL;inti,index;intvalue;intnodelist[20];cout<<"输入树的节点，输入0结束 ";index=0;cin>>value;while(value!=0){nodelist[index]=value;index=index+1;cin>>value;}root=creat(nodelist,index);printf(" 前序打印 ");print(root);printf(" 打印问位置数 ");cin>>i;printf(" 前序打印第K个数 ");print3(root,i);}

int level(struct node *t,struct node *p) { return t ? _level(t, p, 1) : 0;}int __level(struct node *cur, struct node *goal, int depth) { if (cur == NULL) return 0; if (cur == goal) return depth; int l = __level(cur->left, goal, depth + 1); if (l > 0) return l; int r = __level(cur->right, goal, depth + 1); if (r > 0) return r; return -1}

// bzl.cpp : 定义控制台应用程序的入口点。//#include "stdafx.h"#include "math.h"typedef struct Bnode{ char data; struct Bnode *lchild,*rchild;}Bnode; int i=0; char *s="abc de g f ";void preorder(Bnode *);void visite(Bnode *);void createTree(Bnode * &p){ if(s[i]!=" "){ p=new Bnode; p->data=s[i]; i++; createTree(p->lchild); createTree(p->rchild); } else { p=NULL;i++; }}int high(Bnode *T){ int r_lever,l_lever; if(T==NULL) return 0; else{ r_lever=high(T->lchild)+1; l_lever=high(T->rchild)+1; if(a>b) return r_lever; else return l_lever; }}int _tmain(int argc, _TCHAR* argv[]){ int lever; Bnode *p; createTree(p); lever=high(p); printf("二叉树的深度为：%d",lever); printf(" "); return 0;}