cutacross的解释cutacross的解释是什么

遍历的单词有：traverse。遍历的单词有：traverse。注音是：ㄅ一ㄢ_ㄌ一_。结构是：遍(半包围结构)历(半包围结构)。拼音是：biànlì。遍历的具体解释是什么呢，我们通过以下几个方面为您介绍：一、词语解释【点此查看计划详细内容】普遍游历。二、引证解释⒈普遍游历。引宋陆游《舟中晓赋》诗：“高_健席从今始，遍_三湘与五湖。”清戴名世《＜齐讴集＞自序》：“自燕_济，游於渤海之滨，遍_齐鲁之境。”郭沫若《海涛集·神泉》：“随着北伐军由广东出发，经过了八省的遍历，现在又差不多孤影悄然地回到了广东。”三、国语词典各处都到过。四、网络解释遍历所谓遍历(Traversal)，是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问题。遍历是二叉树上最重要的运算之一，是二叉树上进行其它运算之基础。当然遍历的概念也适合于多元素集合的情况，如数组。关于遍历的诗词《早秋送台院杨侍御归朝（兄弟四人遍历诸科二人同省）》《泰兴道本上人少时颇留意诗律已而遍历诸方卒》《偶成·非才遍历清华地》关于遍历的诗句圆缺阴晴遍历遍历清华地遍历清华地关于遍历的成语饿殍遍野遍地开花历历可考漫山遍野关于遍历的词语走遍天涯遍地开花横尸遍野漫山遍野饿殍遍野关于遍历的造句1、要获得抽到特定牌的机率，我们需要一个函数来遍历整副牌并估算其余牌以查看是否匹配。2、眼界要阔，遍历名山大川；度量要宏，熟读五经诸史。3、这种情形的一个常见的例子是，运行您的程序的管理员、系统程序或者有特权的服务器正在遍历的是由普通用户控制的文件系统部分。4、妹妹遍历天下，博闻强记，姊姊我又是羡慕，又是佩服，但有时日，我也随妹妹去到处玩玩。5、“遍历假说”的提出为统计紊流试验研究采用时间平均提供了理论依据，也使得试验工作在现实中是可以实现的。点此查看更多关于遍历的详细信息

traverse国内上市时间还没有确定，不过traverse已经在国外上市了，目前可以通过进口的方式购买。traverse是雪佛兰旗下的一款中大型SUV，外观方面采用了雪佛兰的最新家族式设计，前脸上下2层格栅设计既显眼又颇具气场。横向设计的镀铬饰条，配上两侧的LED大灯组，看起来非常威武大气。车身尺寸方面，长宽高分别为：5189/1996/1796mm，轴距达到3071m。车尾采用了大灯搭配银色的饰条贯穿一体式的设计，底部采用了双边单出式的排气孔，非常具有力量感。动力方面，分为2.0T涡轮增压发动机和3.6L自然吸气发动机两种，这两款发动机的最大扭矩分别为353牛米和352牛米。在传动系统方面与之匹配的9at变速箱。附雪佛兰介绍：雪佛兰（Chevrolet）是美国通用汽车公司（General Motors，简称GM）旗下的一个汽车品牌，1911年11月3日创立，创始人为威廉·杜兰特（William C. Durant）和路易斯·雪佛兰（Louis Chevrolet）。百万购车补贴

区别是二者词性不同。traversen.穿过;横贯，横切;横木;[建]横梁vt.通过;横越，横贯;[法]否认，反驳;[木工]横刨vi.横越;来回移动;旋转adj.横贯的;横切的acrossprep.穿过;横穿，横过;与…交叉;在…对面adv.横过，越过;在对面;交叉;斜对面例句辨析：1、I traversed the narrow pedestrian bridge. 我走过狭窄的人行天桥。2、A steep-sided valley traversed by streams. 溪流横贯、两侧山势陡峭的山谷3、We traverse the desert by truck. 我们乘卡车横穿沙漠。across1、She walked across the floor and lay down on the bed.她走过地板躺在了床上。2、She found her clothes lying across the chair. 她发现自己的衣服堆放在椅子上。3、Anyone from the houses across the road could see him.马路对面房子里的任何一个人都能看见他。

transverse [简明英汉词典][5trAnzvE:s]adj.横向的, 横断的traverse [简明英汉词典][5trAvE(:)s]n.横贯, 横断, 横木, 障碍, 否认, 反驳, (建筑)通廊vt.横过, 穿过, 经过, 在...来回移动, 反对, 详细研究vi.横越, 横断, 旋转, 来回移动adj.横断的, 横的

作为一看全尺寸SUV，这款雪佛兰Traverse可以说是看上去力量十足，对于喜欢美式风格SUV的消费者再合适不过了 另外，Traverse还有17、18和20英寸车轮供选择，以及可获得实时交通信息的导航功能，蓝牙免持听筒电话连接等。 该车造型源于08款Malibu，配备四轮独立悬架系统和电子稳定控制系统等。 内部3排座位可容纳8个成年人

很多车主在选购中大型SUV时，更多的可能是考虑大众途昂这款德系车型，不过今天我倒是给大家推荐一款全进口的中大型SUV，霸气车身，5.2米车长，2.6L排量V6发动机，配有9AT变速箱，听着这个数据就兴奋了吧，这就是雪佛兰硬汉Traverse。 说起雪佛兰，可能大家更加熟知的就是科鲁兹了，不过，随着科鲁兹换代宣告失败，雪佛兰已经没有爆款产品用以支撑品牌，在国内一直处于不温不火的状态，就好像目前国内的斯柯达品牌。此时此对雪佛兰来说，急需一款全新的产品进行战略布局，如此以来以全新的思路打造爆款车型是时下雪佛兰迫在眉睫的工作。于是乎，雪佛兰硬汉Traverse在这种氛围下横空出世了。 全新一代雪佛兰Traverse其实早在2017年就在北美市场发布，自发布以来就在美国市场销量节节攀升，目前国内是以平行进口车的形式引进销售，正因为还没有全面国产，因此对于国内消费者来说绝对算是一款新车型。小批量的引进国内销售，其实是厂家试水中国市场以决定后续是否引入国产的一个先期尝试。 当下国人在选车的时候，几乎和美国人民差不多，在资金允许的情况下，绝对是“以大为美”，排量至上，因此想以一个相对优越的价格购买到一辆大尺寸的SUV通常是很多SUV车型爱好者最明显的消费的痛点。而雪佛兰的硬汉Traverse车身尺寸分别为5189*1996*1796mm，并且轴距达到3071mm，如此数据绝对是一款中大型SUV。并且这个尺寸已经超过了奥迪Q7，与目前热度超高的大众途昂的5039*1989*1773mm,2980mm车身数据相当。可以说视觉效果绝对的大气。 说起美式SUV给人们的印象就是大气、霸气、大尺寸、硬朗，而本次的雪佛兰Traverse也是绝对不会让你失望，硕大的进气格栅，大嘴的造型绝对符合当下高端车型的主流设计定位，大灯组虽然比较狭长但是与格栅上半段连为一体后，营造出非常犀利的视觉效果。雾灯区域由粗壮的镀铬饰条进行了点缀，使得本身娇小的两个圆形小雾灯也变得大气。 车身设计上，采用了更多的平直的线条，刚毅的风格从车头一直贯穿到车尾，并且与尾灯相连，D柱同样采用了时下主流的隐藏式设计，银色行李架点缀出这款中大型SUV野性粗犷的风格。如此硕大的尺寸绝对能够满足一家人的出行，并且座椅放倒铺上床垫直接就变身为一台房车。 该车双天窗的设计非常人性化的兼顾到了二三排的乘客视野，其中后两排都设有空调出风口，非常贴心。座椅的舒适度和支撑性也非常到位，2+2+2的座椅布局兼顾了第三排出入便利性及实用性，整体舒适度让人满意。 内饰方面，中控采用了大面积的软性材料覆盖，上下双色的配色加上8英寸的中控屏给人的视觉感受是满满的美式准豪华氛围，倒车影像、CarPlay、Android Auto互联、自动分区空调等等都是标配。 如此强壮的一台中大型SUV必然需要强大的动力系统来支撑，为此Traverse提供有两种动力，分别是3.6L自然吸气V6发动机和2.0T涡轮增压发动机，无论哪个动力匹配的都是通用自家9AT，其中前者最大扭矩360Nm，后者最大扭矩400Nm，更能体现出美式自吸大排量的快感。而2.0T的配置也绝对可以在满足动力需求的同时兼顾了一定的燃油经济性。 虽然雪佛兰Traverse尚未引入国产，不过目前小批量以平行进口车的策略进入国内市场，但是反馈很好，如此先行探路后，厂家后期必然考虑引入国产，铺开走量，一旦国产，其性价比势必比途昂更具优势。就好像目前林肯的航海家还未上市就已经热的发烫了。 往期精彩资讯： 福特蒙迪欧的翻身之作，仅4.4L油耗，全新柴油版旅行车发布 一代撩妹神车落下神坛，7秒破百，迈腾的强敌，如今13万元受冷落 48万辆 汽车 存安全隐患！被紧急召回，涉及22款车型，有你的车吗？

这就是雪佛兰，好不好，标都在那摆着呢

词性不同。traverse是cross的升级版。

日前，雪佛兰官方正式发布了一组Traverse RS车型的官图，新车在外观细节上进行了更加运动化的调整，搭载2.0T汽油发动机，据悉，新车将于2018芝加哥车展正式上市，并将在今年以平行进口车的形式进入中国，未来或命名为探际者。外观方面，新车基本延续此前的普通版车型，仅在细节方面有所调整。前进气格栅采用全黑涂装，此外，品牌LOGO、车窗饰条、车顶行李架也都采用了黑色涂装，看起来更加炫酷。车尾部分，新车将采用双边共两处排气布局，排气口也采用更加动感的圆形设计，右下角设有“RS”标识。动力方面，新车将会搭载一台2.0T四缸汽油发动机，最大功率为195千瓦，峰值扭矩为400牛米，传动方面，与之匹配的将是9速自动变速器。

const说明它是常成员函数

print 应该是函数指针吧。函数的参数可以是函数指针。。参考window程序下的回调函数。

活节点变成他的左孩子节点visit节点访问

户外运动手表

都没什么区别，都是一种方式，你喜欢用那种都可以只有 though不是目标。

特拉弗斯城（Traverse City）是美国密歇根州大特拉弗斯县中的一座城市，是北密歇根地区21个县中最大的城市。它与半岛对面的阿尔皮纳组成下密歇根的两个中心城市。特拉弗斯城自称为“世界樱桃之都”，每年七月的第一个完整的周里举办为期一周的樱桃节。其周边地区除樱桃外还出产葡萄，是美国中西部出产葡萄酒的中心地区。夏季和冬季旅游业是这里的一个重要工业。这里夏季气候温和，湖滨清凉，拥有高级的高尔夫球场、葡萄园以及附近的国家湖畔风景区，冬季则降雪丰富，附近有滑雪场合数千平方公里的森林。这一切均使得特拉弗斯城成为密歇根州继马琪那市后第二大旅游地。

　　 深度优先遍历序列 　　对图进行深度优先遍历时 按访问顶点的先后次序得到的顶点序列称为该图的深度优先遍历序列 或简称为DFS序列 　　( )一个图的DFS序列不一定惟一 　　当从某顶点x出发搜索时 若x的邻接点有多个尚未访问过 则我们可任选一个访问之 　　( )源点和存储结构的内容均已确定的图的DFS序列惟一 　　① 邻接矩阵表示的图确定源点后 DFS序列惟一 　　DFSM算法中 当从v i 出发搜索时 是在邻接矩阵的第i行上从左至右选择下一个未曾访问过的邻接点作为新的出发点 若这样 　　的邻接点多于一个 则选中的总是序号较小的那一个 　　【例】对连通图G 用邻接矩阵表示时 以v 为初始出发点的 DFS遍历过程如下图(a)所示 具体算法的执行过程【 参见动 　　画演示 】 DFS序列是v v v v v v v v 　　 　　②只有给出了邻接表的内容及初始出发点 才能惟一确定其DFS序列 　　邻接表作为给定图的存储结构时 其表示不惟一 因为邻接表上边表里的邻接点域的内容与建表时的输入次序相关 　　因此 只有给出了邻接表的内容及初始出发点 才能惟一确定其DFS序列 　　【例】连通图G 用邻接表表示时 以v 为初始出发点的 DFS算法的执行过程和DFS序列【 参见动画演示 】 　　( )栈在深度优先遍历算法中的作用 　　深度优先遍历过程中 后访问的顶点其邻接点被先访问 故在递归调用过程中使用栈(系统运行时刻栈)来保存已访问的顶点 　　 算法分析 　　对于具有n个顶点和e条边的无向图或有向图 遍历算法DFSTraverse对图中每顶点至多调用一次DFS或DFSM 从DFSTraverse中调用 　　DFS(或DFSM)及DFS(或DFSM)内部递归调用自己的总次数为n 　　当访问某顶点v i 时 DFS(或DFSM)的时间主要耗费在从该顶点出发搜索它的所有邻接点上 用邻接矩阵表示图时 其搜索时间为 　　O(n);用邻接表表示图时 需搜索第i个边表上的所有结点 因此 对所有n个顶点访问 在邻接矩阵上共需检查n 个矩阵元素 　　在邻接表上需将边表中所有O(e)个结点检查一遍 　　所以 DFSTraverse的时间复杂度为O(n ) (调用DFSM)或 (n+e)(调用DFS) lishixinzhi/Article/program/sjjg/201311/23835

都没什么区别，都是一种方式，你喜欢用那种都可以只有 though不是目标。

这款插件可以为不支持3D Shortcuts(快捷键)的应用程序建立Shortcuts，或者为已支持3D Shortcuts的应用程序新增Shortcuts。3D Touch是苹果公司为全新的iPhone6s/6s Plus新增的一项功能，而 iPhone6/6 Plus 以及之前的机型则可以通过越狱安装插件来实现这项功能。今天，我们要说的是一款跟3D Touch有关的插件Traverse。日前，网友skjt为我们介绍了这款Traverse插件，这款插件可以为不支持3D Shortcuts(快捷键)的应用程序建立Shortcuts，或者为已支持3D Shortcuts的应用程序新增Shortcuts，下面我们一起来看看具体的安装和使用教程。1. 前往 BigBoss 源下载安装 Traverse。2. 进入 Traverse 设置界面给目标应用程序添加快捷键，以给微信添加“扫一扫”为例。- 第一项 Title：标题，输入“扫一扫”，这是直接显示在应用程序Shortcuts上的文字，可以充分自定义。- 第二项 Sub-Title：副标题，我们可以输入“扫描二维码/条码等”。这是描述该功能的附加信息，也可以充分自定义。- 第三项 Bunble ID：相当于应用程序本身的“身份证”，我们可以输入“com.tencent.xin”。这是每个应用程序的唯一识别 ID，包含在每个应用程序的 info.plist 文件中，可以在手机端用 iFile 查看，或者在电脑端用 iTools 查看，一般都是反域名形式的字串，这样可以保证每个应用程序的唯一性。我们在 Traverse 中设置 Bundle ID，为哪个应用程序新增快捷键就要填写哪个应用程序的 Bundle ID。值得一提的是，Traverse 插件的最新版本已支持自动添加 Bundle ID，需要在设置中把“Show Add Action”打开。- 第四项 URL Schese：功能代码，我们需要输入“weixin://dl/scan”。这是要实现 Shortcuts 功能的 URL 代码，应用程序的每个功能都对应有一个 URL 代码。网友 skjt 表示，除了在互联网上搜索之外，他并没有找到更好的查询 URL 代码的方式，网友们如果有更好的查询方法，可以留言补充。- 第五项：自定义图标，比如，“Search”就是一个放大镜的图标。至于如何自定义为自己想要的图标，网友们可以自行摸索。经过上述几项操作之后，我们就能成功为微信添加“扫一扫”的快捷功能键，这时候，我们可以返回主屏幕体验一下效果。不过，该网友称，新增快捷功能键之后可能会出现本机号码显示为未知、iMessage 和 Facetime 显示空的情况，因此他建议网友们设置完成之后最好重启或者注销一下。另外，我们还需要注意一点，Bundle ID及URL需要使用英文以及英文标点，并且大小写必须要跟源程序一致。根据网友skjt的描述，我们还可以通过Cloaky 3.0.1-1 这个插件来隐藏现有的应用程序快捷键，并且不需要修改应用程序的任何文件，确保应用程序更新之后不需要进行额外的设置也能隐藏Shortcuts。

全新开拓者是雪佛兰品牌2020年在中国市场的重磅新车，与前辈车型不同，它定位于城市SUV市场，其国产版已经于去年11月8日完成首发；按照计划，国产全新开拓者将于今年3月正式上市。盘点雪佛兰品牌在华产品线，已经拥有创酷、创界、探界者三款SUV，价格区间覆盖10~25万元市场。产品级别上，创酷是小型SUV，创界介于小型SUV与紧凑SUV之间，探界者介于紧凑SUV与中型SUV之间。全新开拓者是雪佛兰品牌在华的旗舰SUV，原型车在美国市场的定位是中型跨界SUV；因为对B柱之后进行改动，让国产全新开拓者在中国市场变身中型SUV，其操作手法和定位与长安福特锐界很像。在美国市场，雪佛兰品牌用于对标丰田汉兰达的大7座中型SUV是TRAVERSE，其3.6L+9AT车型官方售价2.98万美元起，低于丰田汉兰达的3.46万美元起。国产全新开拓者原型车BLAZER的官方售价为2.88万美元起，低于福特锐界的3.11万美元起。国产雪佛兰中型SUV为何选择开拓者而不是TRAVERSE，小猫认为这或是综合品牌认可度、消费者需求和市场定位等因素考虑。以别克和雪佛兰两个品牌在国人心中的定位来看，昂科旗是与丰田汉兰达、大众途昂对标的车型，雪佛兰更多是与现代、起亚等品牌竞争。同时，美国版TRAVERSE仅有3.6L自然吸气发动机提供，开拓者有2.5L、2.0T和3.6L三种发动机提供，也是上汽通用选择后者的原因。车身尺寸和空间方面，虽然国产开拓者不及TRAVERSE，但长宽高也达到4999mm、1953mm、1727mm（1732mm），轴距2863mm，优于合资中型SUV标杆车型丰田汉兰达，基本可以满足消费者对空间的需求。全新开拓者直接竞争对手之一的现代胜达，长宽高分别为4930mm、1910mm、1720mm，轴距2865mm；两款车基本处于同一水平。动力系统方面，国产全新开拓者选择2.0T发动机+9速自动变速箱的组合，相比美版车型没有缩水，已经用在别克昂科旗上，最大功率174kw、最大扭矩350Nn，达到同级别车平均水平；这款发动机能实现四缸性能、四缸经济和两缸经济模式之间的切换，以提升燃油经济性。和昂科旗一样，全新开拓者也会有两驱和四驱车型可选。按照品牌定位来看，同级别的雪佛兰价格要低于别克，昂科旗的起步价格29.99万元，其入门级车型配置比较丰富。除了昂科旗之外，福特锐界、丰田汉兰达的定价也是全新开拓者需要考虑的，两款车的起步价格分别为22.98万元、23.98万元，结合探界者2.0T四驱车型的22.59万元起，小猫预计全新开拓者2.0T车型的起步价格或在22万元左右，以21.99万元的价格起售，高于现代胜达2.0T的20.28万元。配置水平方面，全新开拓者顶配版车型会看齐昂科旗，但入门级车型配置水平或与丰田汉兰达、福特锐界等相当，主要走量车型的价格在25万元左右。展望全新开拓者未来市场走势，小猫对它比较看好。据乘联会公布的销量数据显示，探界者2019年销量为50471辆，虽然未能跻身销量排行榜前三，但也是个不错成绩。即将上市的全新开拓者，虽然原本定位于中型SUV市场且尺寸接近中大型SUV，但主要对标车型是大众途观L、本田冠道、UR-V和高配版本田CR-V、丰田RAV4、日产奇骏等车型。从消费者的角度来看，用买一线日系品牌高配版紧凑SUV的钱买雪佛兰中型SUV，是全新开拓者的卖点，这与现代胜达有些相似。相比同价位的丰田汉兰达，配置更多是全新开拓者的优势。综合产品力、性价比、品牌认可度等多方面因素考虑，小猫认为全新开拓者的月销量超过3000辆不是问题，甚至有望超越探界者的年销5万辆。在文章最后，小猫希望上汽通用能国产TRAVERSE并推出2.0T车型，因为它外观设计、空间表现更符合国内中型SUV目标客户的需求且其价格不贵。2017年广州车展，雪佛兰TRAVERSE已经完成中国首秀，不知道什么时候能与国内消费者见面。本文来源于汽车之家车家号作者，不代表汽车之家的观点立场。

struct node {int data;struct node *next;} ;创建单链表后，最后一个结点的next是NULL，据此来遍历表，获得长度。void get_len( struct node *head ){ struct node *p=head->next ; int len=0; while ( p ) { len++; p=p->next; } head->data=len ; //存储长度到头结点}请采纳答案，支持我一下。

递归与迭代都是基于控制结构：迭代用重复结构，而递归用选择结构。递归与迭代都涉及重复：迭代显式使用重复结构，而递归通过重复函数调用实现重复。递归与迭代都涉及终止测试：迭代在循环条件失败时终止，递归在遇到基本情况时终止。使用计数器控制重复的迭代和递归都逐渐到达终止点：迭代一直修改计数器，直到计数器值使循环条件失败；递归不断产生最初问题的简化副本，直到达到基本情况。迭代和递归过程都可以无限进行：如果循环条件测试永远不变成false，则迭代发生无限循环；如果递归永远无法回推到基本情况，则发生无穷递归。递归函数是通过调用函数自身来完成任务，而且在每次调用自身时减少任务量。而迭代是循环的一种形式，这种循环不是由用户输入而控制，每次迭代步骤都必须将剩余的任务减少；也就是说，循环的每一步都必须执行一个有限的过程，并留下较少的步骤。

强制类型转换.

Status(*Visit)(TElemType) 这个是函数指针作参数，该函数指针代表的函数返回值类型Status 有一个参数，类型是TElemType用这个Status visit(int e)去调用没有问题，外面的格式是PreOrderTraverse(t,visit);但是前面要保证TElemType 是int

遍历的词语解释是：普遍游历。遍历的词语解释是：普遍游历。注音是：ㄅ一ㄢ_ㄌ一_。结构是：遍(半包围结构)历(半包围结构)。拼音是：biànlì。遍历的具体解释是什么呢，我们通过以下几个方面为您介绍：一、引证解释【点此查看计划详细内容】⒈普遍游历。引宋陆游《舟中晓赋》诗：“高_健席从今始，遍_三湘与五湖。”清戴名世《＜齐讴集＞自序》：“自燕_济，游於渤海之滨，遍_齐鲁之境。”郭沫若《海涛集·神泉》：“随着北伐军由广东出发，经过了八省的遍历，现在又差不多孤影悄然地回到了广东。”二、国语词典各处都到过。三、网络解释遍历所谓遍历(Traversal)，是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问题。遍历是二叉树上最重要的运算之一，是二叉树上进行其它运算之基础。当然遍历的概念也适合于多元素集合的情况，如数组。关于遍历的诗词《梅坞·短筇遍历溪山》《访桂·行秋遍历谷之阳》《早秋送台院杨侍御归朝（兄弟四人遍历诸科二人同省）》关于遍历的诗句遍历清华地记南城锦迳名园曾遍历记南城锦径名园曾遍历关于遍历的单词traverse关于遍历的成语历历可考漫山遍野遍地开花饿殍遍野关于遍历的词语横尸遍野遍地开花饿殍遍野漫山遍野走遍天涯关于遍历的造句1、引入了混沌算子，利用混沌变量的特定内在随机性和遍历性来跳出局部最优点，有效地克服了传统遗传算法的“早熟”的缺点。2、这种情形的一个常见的例子是，运行您的程序的管理员、系统程序或者有特权的服务器正在遍历的是由普通用户控制的文件系统部分。3、编写函数输出二叉树的先序、中序、后序遍历。4、眼界要阔，遍历名山大川；度量要宏，熟读五经诸史。5、接着，它遍历本地存储中的所有数据。点此查看更多关于遍历的详细信息

对于国内的车友来说雪佛兰Traverse依然算一辆全新车型，据通用官方消息雪佛兰Traverse中文名将采用“巡领者”一词！外观方面设计雪佛兰Traverse有着美系车共同的特质，稳重敦实的车头，分层设计的进气格栅，锐利深邃的前大灯，看起来非常有攻击力，车侧面，平直的腰线和大尺寸的轮毂设计配上长达5.1米的车身，力量感十足。车尾设计相对来说比较方正稳重，车灯棱角分明，造型犀利，对称式的排气管也给整体增添了一些运动感。18款巡领者3.6L V6 9速四驱 黑、白、银、棕配置：Bose豪华音响系统带10扬声器，8寸高清数码触摸式显示屏，前排电动座椅带加热功能，真皮座椅，三区空调，360度环影带流媒体，电动双天窗，氙气大灯，电动尾门，远程启动，自动启停，redline红黑外观套件，电加热方向盘，座椅通风，第二排座椅带加热功能，驾驶座后视镜及方向盘记忆功能，反光镜电动调节/加热，20寸redline专属黑色轮毂带红色线条，led大灯，脚感电尾，车身镀络，双排气尾喉，无线充电，high country 专属中网格栅，high country定制高档黑棕内饰，“twin clutch”只能全路况四驱系统，20寸高光轮毂，智能前大灯，第三排座椅6/4比例电动折叠，拖车系统，ACC巡航带前自动刹车，前方碰撞预警系统，车道保持及车辆偏离预警。内饰方面雪佛兰Traverse设计富有科技感和豪华感，线条的切割和凹凸，显得饱满有力，高清仪表盘和多媒体屏幕，非常大气，整个内饰以单黑色为主调，稳重大气。整车座椅配备2+2+3的布局，第二排两个独立座椅是小编的最爱，可以前后滑动及翻折。超大的空间给全家出行提供了便利，无论是购物还是拉货都能游刃有余。动力配置方面雪佛兰Traverse3.6L V6自然吸气发动机，传动系统匹配9AT变速箱，最大输出功率314马力，峰值扭矩达到了360N.m。"本文来源于汽车之家车家号作者，不代表汽车之家的观点立场。

倒置算法很好

删除和查找基本操作问题补充：需要详细源码！ 其实这些算法并不复杂。具体操作比较繁琐而已，有兴趣可以参考下面的程序。有什么其他想法，帮你修改下就是

深度优先搜索？

我们正在上数据结构，已经写好了循环队列的所有算法代码。数组名你自己改一下啊，我没时间去改那个了。运行全部正确的。哦，忘了说明，我采用的语言是C++，编译环境是VC++ 6.0。其中包含三个文件：SqQueue.h SqQueue.cpp main.cpp至于那个怎么添加到VC中运行相信你知道吧，我就不说了。======================SqQueue.h=============================#include <iostream>using namespace std;#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2#define MAXQSIZE 100 //最大队列长度typedef int Status;typedef int QElemType;typedef struct{ QElemType * base; int front; int rear;}SqQueue;Status InitQueue(SqQueue & Q);int GetQueueLen(SqQueue Q);Status EnQueue(SqQueue & Q,QElemType e);Status DeQueue(SqQueue & Q,QElemType & e);Status QueueEmpty(SqQueue Q);Status GetHead(SqQueue Q,QElemType & e);Status ClearQueue(SqQueue & Q);Status DestoryQueue(SqQueue & Q);Status QueueTraverse(SqQueue Q);======================SqQueue.cpp=============================#include "SqQueue.h"Status InitQueue(SqQueue & Q){ Q.base = (QElemType *)malloc(MAXQSIZE*sizeof(QElemType)); if(!Q.base) exit(OVERFLOW); Q.front = Q.rear = 0; return OK;}int GetQueueLen(SqQueue Q){ return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;}Status EnQueue(SqQueue & Q,QElemType e){ if((Q.rear + 1)%MAXQSIZE == Q.front) //顺序队列已满 return ERROR; Q.base[Q.rear] = e; Q.rear = (Q.rear + 1)%MAXQSIZE; return OK;}Status DeQueue(SqQueue & Q,QElemType & e){ if(Q.rear == Q.front) //顺序队列空 return ERROR; e = Q.base[Q.front]; Q.front = (Q.front + 1)%MAXQSIZE; return OK;}Status QueueEmpty(SqQueue Q){ if(Q.rear == Q.front) return TRUE; return FALSE;}Status GetHead(SqQueue Q,QElemType & e){ if(Q.rear == Q.front) return ERROR; e = Q.base[Q.front]; return OK;}Status ClearQueue (SqQueue & Q){ Q.rear = Q.front; return OK;}Status DestoryQueue(SqQueue & Q){ free(Q.base); return OK;}Status QueueTraverse(SqQueue Q){ if(!Q.base) return ERROR; if(Q.rear == Q.front) return ERROR; int i = Q.front; while(i != Q.rear) { cout<<Q.base[i]<<" "; i++; } return OK;}======================main.cpp=============================#include "SqQueue.h"int main(){ Status status; SqQueue Q; int n; QElemType e; InitQueue(Q); cout<<"您想在队列中创建多少个元素？ n = "; cin>>n; for(int i = 0;i < n;i++) { cout<<" 请输入元素的值: "; cin>>e; EnQueue(Q,e); } status = QueueEmpty(Q); if(status) cout<<" 循环队列为空! "; else cout<<" 循环队列非空! "; status = DeQueue(Q,e); if(status) cout<<"被删除的队首元素是: "<<e<<endl<<endl; else cout<<"队首元素删除失败! "; n = GetQueueLen(Q); cout<<"队列的长度为: "<<n<<endl<<endl; status = QueueTraverse(Q); if(status) cout<<"遍历成功! "; else cout<<"遍历失败! "; cout<<"请输入您想向队列中插入的数值... e = "; cin>>e; status = EnQueue(Q,e); if(status) cout<<"插入成功! "; else cout<<"插入失败! "; n = GetQueueLen(Q); cout<<"队列的长度为: "<<n<<endl<<endl; status = QueueTraverse(Q); if(status) cout<<"遍历成功! "; else cout<<"遍历失败! "; status = GetHead(Q,e); if(status) cout<<"队首元素是: "<<e<<endl<<endl; else cout<<"ERROR! 获取队首元素失败! "; status = ClearQueue(Q); if(status) cout<<"循环队列清除成功! "; else cout<<"循环队列清除失败! "; n = GetQueueLen(Q); cout<<"队列的长度为: "<<n<<endl<<endl; status = QueueTraverse(Q); if(status) cout<<"遍历成功! "; else cout<<"遍历失败! "; status = DestoryQueue(Q); if(status) cout<<"循环队列销毁成功! "; else cout<<"循环队列销毁失败! "; n = GetQueueLen(Q); cout<<"队列的长度为: "<<n<<endl<<endl; status = QueueTraverse(Q); if(status) cout<<"遍历成功! "; else cout<<"遍历失败! "; return 0; /* QElemType e; int n; int i; int len; Status status; SqQueue Q; status = InitQueue(Q); if(status) cout<<"初始化成功! "<<endl; else cout<<"初始化失败! "<<endl; status = QueueEmpty(Q); if(status) cout<<"循环队列为空! "; else cout<<"循环队列非空! "; cout<<"您想为队列输入多少个元素？ 请输入:"; cin>>n; cout<<endl; for(i = 0;i<n;i++) { cout<<"请输入您想插入队列的元素值(后插):"; cin>>e; EnQueue(Q,e); } len = GetQueueLen(Q); cout<<" 队列长度为: "<<len<<endl<<endl; status = QueueEmpty(Q); if(status) cout<<"链性队列为空! "; else cout<<"链性队列非空! "; status = QueueTraverse(Q); if(status) cout<<" 遍历成功! "; else cout<<" 遍历失败! "; status = DeQueue(Q,e); if(status) { cout<<" 在队列中被删除的队首元素值是: "<<e; cout<<" 删除成功! "; } else cout<<" 删除失败! "; len = GetQueueLen(Q); cout<<"队列长度为: "<<len<<endl<<endl; status = QueueTraverse(Q); if(status) cout<<" 遍历成功! "; else cout<<" 遍历失败! "; status = GetHead(Q,e); if(status) cout<<" 队列的队首元素是: "<<e<<endl; else cout<<" 获取队首元素失败! "; status = ClearQueue(Q); if(status) cout<<" 队列清除成功! "; else cout<<" 队列清除失败! "; len = GetQueueLen(Q); cout<<"队列长度为: "<<len<<endl<<endl; status = QueueTraverse(Q); if(status) cout<<"遍历成功! "; else cout<<"遍历失败! "; status = DestoryQueue(Q); if(status) cout<<" 队列销毁成功! "; else cout<<" 销毁失败! "; status = QueueTraverse(Q); if(status) cout<<"遍历成功! "; else cout<<"遍历失败! "; */}

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

给你一个完整的例子吧。学习一下#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(" 程序结束. ");}

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

#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 }参考资料：找来的，你看看吧！

/* 我的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***（其中*代表空格，输入时*代表空格）*/

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

二叉树的基本操作 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);

#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;}

二叉树是采用递归定义的，实现起来代码简洁（也许并不简单）。并且它在具体的计算机科学中有很重要的运用，是一种很重要的数据结构，二叉树有三种遍历和建立的方式。今天先学习一下它的建立和打印。以下代码在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); }

文件 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 }这样可以么？

Insert就是将一个新元素插入线性表，使得插入后的结果有序InsertFront就是将一个新元素插在线性表的最前面InsertRear就是将一个新元素插在线性表的最后面DeleteFront就是将线性表的最前面的元素删除ClearList就是清空线性表TraverseList就是将线性表从头到尾输出一遍（1）InitList(La); Int a[]={100,26,57,34,79}; For (i=0;i<5;i++) Insert(La,a[i]);分析：for进行了5次循环，线性表分别为：10026，10026，57，10026，34，57，10026，34，57，79，100（2）DeleteFront(La); InsertRear(La, DeleteFront(La)); TraverseList(La);分析：DeleteFront执行后线性表为：34，57，79，100InsertRear(La, DeleteFront(La));分两步执行，先执行DeleteFront，并将删除的元素作为新元素插入到线性表的最后，过程为：57，79，10057，79，100，34（3）ClearList(La); For (i=0;i<5;i++) InsertFront(La,a[i]); 分析：清空线性表，再将元素依次插入线性表的最前面：空表10026,10057,26,10034,57,26,10079,34,57,26,100

如果有对gml格式转换成邻接表或邻接矩阵有问题的请看博文http://blog.sina.com.cn/s/blog_64914f1b0102vjzt.html或者http://weibo.com/p/1001603831291614203314

　　C++ visit函数表示一次页面阅览就是一次页面的下载，访问者成功地阅览到页面应该在访问者的浏览器上完整地看到该页面。　　度量方法：一次浏览器请求即可算作一次页面阅览。

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

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

丹-马尔利/Dan Majerle全名：Daniel Lewis Majerle位置：后卫-前锋身高：1.98米(6尺6寸)体重：98公斤(215磅)出生日期：1965年9月9日出生城市：Traverse City, Michigan高中：Traverse City in Traverse City, Michigan大学：Central Michigan University球衣号码：9选秀情况：1988年第1轮第14顺位被太阳选中

我们的数据结构实验也是这题，需要我把我的实验报告给你参考下么！ 我这里就只发这部分的代码。Status PreOrderTraverse(BiTree T){ //先序遍历二叉树T的递归算法 if (T) { printf("%d ",T->data); if(T->lchild) PreOrderTraverse(T->lchild); if(T->rchild) PreOrderTraverse(T->rchild); return FALSE; } else return OK;}Status PreOrder(BiTree T){ //先序遍历二叉树T的非递归算法 while(!(T==NULL&&top==NULL)) { if(T) { printf("%d ",T->data); push(T); T=T->lchild; } else { T=(BiTree)pop(); T=T->rchild; } } }Status InOrderTraverse(BiTree T){ //中序遍历二叉树T的递归算法 if (T) { if (T->lchild) InOrderTraverse(T->lchild); printf("%d ",T->data); if (T->rchild) InOrderTraverse(T->rchild); return FALSE; } else return OK;}Status InOrder(BiTree T){ //中序遍历二叉树T的非递归算法 while(!(T==NULL&&top==NULL)) { while(T) { push(T); T=T->lchild; } T=(BiTree)pop(); printf("%d ",T->data); T=T->rchild; }}Status PostOrderTraverse(BiTree T){ //后序遍历二叉树T的递归算法 if (T) { if (T->lchild) PostOrderTraverse(T->lchild); if (T->rchild) PostOrderTraverse(T->rchild); printf("%d ",T->data); return FALSE; } else return OK;}Status PostOrder(BiTree T){ //后序遍历二叉树T的递归算法 unsigned sign;//记录结点从栈中弹出的次数 while(!(T==NULL&&top==NULL)) { if(T) { push(T);//第一次遇到结点T时压入其指针 push(1);//置标志为1 T=T->lchild; } else { while(top) { sign=pop(); T=(BiTree)pop(); if(1==sign)//表示走过T的左子树 { push(T); push(2); T=T->rchild; break; } else { if(2==sign)//表示T的左右子树都已走过 { printf("%d ",T->data); T=NULL; } } } } }}

CreateBiTree ( BiTree T ) 改成CreateBiTree ( BiTree &T )不要以为指针传递就等于能改变参数值.指针传递改变的只是它指向的内存空间的值,而不是指针变量本身的值.你现在要改变的是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; } }

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

以前做的。 一、 需求分析 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