程序二叉树排序算法
C程序经典算法50例
C程序经典算法50例1.二分查找算法:在有序数组中查找指定元素。
2.冒泡排序算法:通过不断比较相邻元素并交换位置,将较大的元素向后冒泡。
3.快速排序算法:通过选择一个基准元素,将数组分割为左右两部分,并递归地对两部分进行快速排序。
4.插入排序算法:将数组划分为已排序和未排序两部分,每次从未排序中选择一个元素插入到已排序的合适位置。
5.选择排序算法:遍历数组,每次选择最小元素并放置在已排序部分的末尾。
6.希尔排序算法:将数组按照一定间隔进行分组并分别进行插入排序,然后逐步减小间隔并重复这个过程。
7.归并排序算法:将数组递归地划分为两部分,然后将两个有序的部分进行合并。
8.桶排序算法:将元素根据特定的映射函数映射到不同的桶中,然后对每个桶分别进行排序。
9.计数排序算法:统计每个元素的出现次数,然后根据计数进行排序。
10.基数排序算法:从低位到高位依次对元素进行排序。
11.斐波那契数列算法:计算斐波那契数列的第n项。
12.阶乘算法:计算给定数字的阶乘。
13.排列问题算法:生成给定数组的全排列。
14.组合问题算法:生成给定数组的所有组合。
15.最大连续子序列和算法:找出给定数组中和最大的连续子序列。
16.最长递增子序列算法:找出给定数组中的最长递增子序列。
17.最长公共子序列算法:找出两个给定字符串的最长公共子序列。
18.最短路径算法:计算给定有向图的最短路径。
19.最小生成树算法:构建给定连通图的最小生成树。
20.汉诺塔算法:将n个圆盘从一个柱子移动到另一个柱子的问题。
21.BFS算法:广度优先算法,用于图的遍历和查找最短路径。
22.DFS算法:深度优先算法,用于图的遍历和查找连通分量。
23.KMP算法:字符串匹配算法,用于查找一个字符串是否在另一个字符串中出现。
24.贪心算法:每次都选择当前情况下最优的方案,适用于求解一些最优化问题。
25.动态规划算法:将一个大问题划分为多个子问题,并通过子问题的解求解整个问题,适用于求解一些最优化问题。
二叉排序树
9
第9章
第三节
二、二叉排序树(插入)
查找
动态查找表
二叉排序树是一种动态查找表
当树中不存在查找的结点时,作插入操作
新插入的结点一定是叶子结点(只需改动一个 结点的指针) 该叶子结点是查找不成功时路径上访问的最后 一个结点的左孩子或右孩子(新结点值小于或 大于该结点值) 10
第9章
第三节
查找
19
在二叉排序树中查找关 键字值等于37,88,94
3
第9章
第三节
查找
动态查找表
二、二叉排序树(查找函数)中结点结构定义 二叉排序树通常采用二叉链表的形式进行存 储,其结点结构定义如下:
typedef struct BiNode { int data; BiNode *lChild, *rChild; }BiNode,*BitTree;
4
第9章
第三节
查找
动态查找表
2、二叉排序树的定义 定义二叉排序树所有用到的变量 BitTree root; int
//查找是否成功(1--成功,0--不成功) //查找位置(表示在BisCount层中的第几个位置
BisSuccess;
int
int
BisPos;
BisCount;
//查找次数(相当于树的层数)
7
第9章
第三节
查找
动态查找表
二、二叉排序树(查找函数)
else { BisSuccess = 0; root=GetNode(k);//查找不成功,插入新的结点}
} BiNode * GetNode(int k) { BiNode *s; s = new BiNode; s->data = k; s->lChild = NULL; s->rChild = NULL; return(s);}
二叉排序树
②若*p结点只有左子树,或只有右子树,则可将*p的左子 树或右子树直接改为其双亲结点*f的左子树,即: f->1child=p->1child(或f->1child=p->rchild); free(p); *f
F *p P P1
*f
F
*f
F *p P
*f
F
Pr
P1
Pr
③若*p既有左子树,又有右子树。则:
-1 0
47
-1
47
47
0
31 69
69
25
0
47
0
25
0
47
-1 0
31
0
69
0
40
69
40
69
0
25 76
40
76
(a)
AL、BL、BR 都是空树
(b) AL、BL、BR 都是非空树
LR型调整操作示意图
2
A
-1
0
C
AR C BL CL CR AR
0 0
B BL CL S
B
A
CR
(a) 插入结点*s后失去平衡
31
0 0 -1
31
0 1
28
0
25
0 0
47
0
25
-1
47
0
25
0
31
0
16 0
28
16
28
0
16 30
30
47
(c) LR(R)型调整
RL型调整操作示意图
A B C A BR CR B BR
AL
C
AL
CL CR
C语言常用算法程序汇总
C语言常用算法程序汇总C语言是一门广泛应用于计算机编程的语言,具有较高的效率和灵活性。
在C语言中,常见的算法程序包括排序算法、查找算法、递归算法等等。
以下是一些常用的C语言算法程序的汇总:1.排序算法:-冒泡排序:通过多次迭代比较相邻元素并交换位置,将最大的元素逐渐移动到正确的位置。
-插入排序:将待排序的元素与已排序的部分依次比较并插入到正确的位置。
-选择排序:每次从待排序的元素中选择最小的元素并与已排序的部分交换位置。
-快速排序:通过选择一个基准元素,将数组划分为两个子数组进行递归排序。
2.查找算法:-顺序查找:逐个比较数组中的元素,直到找到目标元素或到数组末尾。
-二分查找:通过比较目标元素与数组中间元素的大小,逐步缩小范围,直到找到目标元素。
-哈希查找:通过散列函数将目标元素映射到哈希表的索引位置进行查找。
3.递归算法:-阶乘:通过递归调用自身计算一个正整数的阶乘。
-斐波那契数列:通过递归调用自身计算斐波那契数列的第n个数。
-二叉树遍历:通过递归调用自身遍历二叉树的各个节点。
4.图算法:- 最短路径算法:如Dijkstra算法和Floyd算法,用于计算图中两个节点之间的最短路径。
-拓扑排序:通过对有向无环图进行排序,使得所有的边从排在前面的节点指向排在后面的节点。
- 最小生成树:如Prim算法和Kruskal算法,用于找到图中连接所有节点的最小子树。
5.动态规划:-最长公共子序列:通过寻找两个字符串中的最长公共子序列,解决字符串匹配问题。
-背包问题:通过动态规划解决在给定容量下选取物品使得总价值最大的问题。
-最大子序列和:通过动态规划解决一个数组中选取连续子序列使得和最大的问题。
以上只是一些C语言中常用的算法程序的汇总,实际上,还有很多其他的算法,如逆波兰表达式、霍夫曼编码、最小割等等。
通过学习这些算法,可以更好地理解C语言的应用和开发。
数据结构与算法系列研究五——树、二叉树、三叉树、平衡排序二叉树AVL
数据结构与算法系列研究五——树、⼆叉树、三叉树、平衡排序⼆叉树AVL树、⼆叉树、三叉树、平衡排序⼆叉树AVL⼀、树的定义树是计算机算法最重要的⾮线性结构。
树中每个数据元素⾄多有⼀个直接前驱,但可以有多个直接后继。
树是⼀种以分⽀关系定义的层次结构。
a.树是n(≥0)结点组成的有限集合。
{N.沃恩}(树是n(n≥1)个结点组成的有限集合。
{D.E.Knuth})在任意⼀棵⾮空树中:⑴有且仅有⼀个没有前驱的结点----根(root)。
⑵当n>1时,其余结点有且仅有⼀个直接前驱。
⑶所有结点都可以有0个或多个后继。
b. 树是n(n≥0)个结点组成的有限集合。
在任意⼀棵⾮空树中:⑴有⼀个特定的称为根(root)的结点。
⑵当n>1时,其余结点分为m(m≥0)个互不相交的⼦集T1,T2,…,Tm。
每个集合本⾝⼜是⼀棵树,并且称为根的⼦树(subtree)树的固有特性---递归性。
即⾮空树是由若⼲棵⼦树组成,⽽⼦树⼜可以由若⼲棵更⼩的⼦树组成。
树的基本操作1、InitTree(&T) 初始化2、DestroyTree(&T) 撤消树3、CreatTree(&T,F) 按F的定义⽣成树4、ClearTree(&T) 清除5、TreeEmpty(T) 判树空6、TreeDepth(T) 求树的深度7、Root(T) 返回根结点8、Parent(T,x) 返回结点 x 的双亲9、Child(T,x,i) 返回结点 x 的第i 个孩⼦10、InsertChild(&T,&p,i,x) 把 x 插⼊到 P的第i棵⼦树处11、DeleteChild(&T,&p,i) 删除结点P的第i棵⼦树12、traverse(T) 遍历树的结点:包含⼀个数据元素及若⼲指向⼦树的分⽀。
●结点的度: 结点拥有⼦树的数⽬●叶结点: 度为零的结点●分枝结点: 度⾮零的结点●树的度: 树中各结点度的最⼤值●孩⼦: 树中某个结点的⼦树的根●双亲: 结点的直接前驱●兄弟: 同⼀双亲的孩⼦互称兄弟●祖先: 从根结点到某结点j 路径上的所有结点(不包括指定结点)。
二叉排序树查找的递归算法
二叉排序树查找的递归算法介绍二叉排序树(Binary Search Tree),也称二叉查找树、有序二叉树或排序二叉树,是一种常用的数据结构。
它具有以下特点:•每个节点都包含一个键值和对应的数据。
•左子树中的所有节点的键值都小于根节点的键值。
•右子树中的所有节点的键值都大于根节点的键值。
•左右子树也分别是二叉排序树。
二叉排序树支持高效的查找、插入和删除操作,其中查找操作是利用递归实现的。
本文将详细介绍二叉排序树查找的递归算法。
二叉排序树的定义二叉排序树的定义如下:class TreeNode:def __init__(self, key, data):self.key = keyself.data = dataself.left = Noneself.right = Noneclass BinarySearchTree:def __init__(self):self.root = None在二叉排序树中,每个节点都是一个TreeNode对象,包含键值key和对应的数据data。
left和right分别指向左子树和右子树的根节点。
树的根节点由BinarySearchTree对象的root属性表示。
二叉排序树查找的递归算法二叉排序树的查找操作是利用递归实现的,其具体算法如下:1.如果待查找的键值等于当前节点的键值,返回当前节点的数据。
2.如果待查找的键值小于当前节点的键值,递归在左子树中查找。
3.如果待查找的键值大于当前节点的键值,递归在右子树中查找。
4.如果在左子树或右子树中找不到对应的键值,则返回空。
下面是二叉排序树查找的递归算法的代码实现:def search_recursive(node, key):if node is None or node.key == key:return node.dataelif key < node.key:return search_recursive(node.left, key)else:return search_recursive(node.right, key)在上述代码中,node表示当前节点,key表示待查找的键值。
数据结构 -第12周查找第3讲-二叉排序树.pdf
以二叉树或树作为表的组织形式,称为树表,它是一类动态查找表,不仅适合于数据查找,也适合于表插入和删除操作。
常见的树表:二叉排序树平衡二叉树B-树B+树9.3.1 二叉排序树二叉排序树(简称BST)又称二叉查找(搜索)树,其定义为:二叉排序树或者是空树,或者是满足如下性质(BST性质)的二叉树:❶若它的左子树非空,则左子树上所有节点值(指关键字值)均小于根节点值;❷若它的右子树非空,则右子树上所有节点值均大于根节点值;❸左、右子树本身又各是一棵二叉排序树。
注意:二叉排序树中没有相同关键字的节点。
二叉树结构满足BST性质:节点值约束二叉排序树503080209010854035252388例如:是二叉排序树。
66不试一试二叉排序树的中序遍历序列有什么特点?二叉排序树的节点类型如下:typedef struct node{KeyType key;//关键字项InfoType data;//其他数据域struct node*lchild,*rchild;//左右孩子指针}BSTNode;二叉排序树可看做是一个有序表,所以在二叉排序树上进行查找,和二分查找类似,也是一个逐步缩小查找范围的过程。
1、二叉排序树上的查找Nk< bt->keybtk> bt->key 每一层只和一个节点进行关键字比较!∧∧p查找到p所指节点若k<p->data,并且p->lchild=NULL,查找失败。
若k>p->data,并且p->rchild=NULL,查找失败。
查找失败的情况加上外部节点一个外部节点对应某内部节点的一个NULL指针递归查找算法SearchBST()如下(在二叉排序树bt上查找关键字为k的记录,成功时返回该节点指针,否则返回NULL):BSTNode*SearchBST(BSTNode*bt,KeyType k){if(bt==NULL||bt->key==k)//递归出口return bt;if(k<bt->key)return SearchBST(bt->lchild,k);//在左子树中递归查找elsereturn SearchBST(bt->rchild,k);//在右子树中递归查找}在二叉排序树中插入一个关键字为k的新节点,要保证插入后仍满足BST性质。
实现二叉排序树的各种算法(2)
BiTree S;
S = T;
while(S)
{
if(S -> data < e)
S = S->rchild;
else if(S -> data > e)
S = S->lchild;
else return OK;
}
return ERROR;
S1 -> data = e;S1 -> lchild = NULL;S1 -> rchild = NULL;
S2 = T;
if(S2 == NULL) T = S1;
else while(loop)
{
if(S1->data < S2->data)
if(S2->lchild == NULL)
{
BiTree S1, S3, S4;
S1 = T;
SqQueue S2;
InitQueue(S2);
EnQueue(S2,S1);
while(S2.front != S2.rear)
{
DeQueue(S2,S1);
printf("%d ",S1->data);
S3 = S1->lchild;S4 = S1->rchild;
if(S3) EnQueue(S2,S3);
if(S4) EnQueue(S2,S4);
}
return OK;
}
Status Turn (BiTree T)
S.top = S.base + S.stacksize;
S.stacksize += STACKINCREMENT;
二叉树的快速排序、归并排序方法
二叉树的快速排序、归并排序方法一、快速排序快速排序采用的是分治法策略,其基本思路是先选定一个基准数(一般取第一个元素),将待排序序列抽象成两个子序列:小于基准数的子序列和大于等于基准数的子序列,然后递归地对这两个子序列排序。
1. 递归实现(1)选定基准数题目要求采用第一个元素作为基准数,因此可以直接将其取出。
(2)划分序列接下来需要将待排序序列划分成两个子序列。
我们定义两个指针 i 和 j,从待排序序列的第二个元素和最后一个元素位置开始,分别向左和向右扫描,直到 i 和 j 相遇为止。
在扫描过程中,将小于等于基准数的元素移到左边(即与左侧序列交换),将大于基准数的元素移到右边(即与右侧序列交换)。
当 i=j 时,扫描结束。
(3)递归排序子序列完成划分后,左右两个子序列就确定了下来。
接下来分别对左右两个子序列递归调用快速排序算法即可。
2. 非递归实现上述方法是快速排序的递归实现。
对于大量数据或深度递归的情况,可能会出现栈溢出等问题,因此还可以使用非递归实现。
非递归实现采用的是栈结构,将待排序序列分成若干子序列后,依次将其入栈并标注其位置信息,然后将栈中元素依次出栈并分割、排序,直至栈为空。
二、归并排序归并排序同样采用的是分治思想。
其基本思路是将待排序序列拆分成若干个子序列,直至每个子序列只有一个元素,然后将相邻的子序列两两合并,直至合并成一个有序序列。
1. 递归实现(1)拆分子序列归并排序先将待排序序列进行拆分,具体方法是将序列平分成两个子序列,然后递归地对子序列进行拆分直至每个子序列只剩下一个元素。
(2)合并有序子序列在完成子序列的拆分后,接下来需要将相邻的子序列两两合并为一个有序序列。
我们先定义三个指针 i、j 和 k,分别指向待合并的左侧子序列、右侧子序列和合并后的序列。
在进行合并时,从两个子序列的起始位置开始比较,将两个子序列中较小的元素移动到合并后的序列中。
具体操作如下:- 当左侧子序列的第一个元素小于等于右侧子序列的第一个元素时,将左侧子序列的第一个元素移动到合并后的序列中,并将指针 i 和 k 分别加 1。
算法(平衡二叉树)
算法(平衡⼆叉树)科普⼆叉树⼆叉树⼆叉数是每个节点最多有两个⼦树,或者是空树(n=0),或者是由⼀个根节点及两个互不相交的,分别称为左⼦树和右⼦树的⼆叉树组成满⼆叉树有两个⾮空⼦树(⼆叉树中的每个结点恰好有两个孩⼦结点切所有叶⼦结点都在同⼀层)也就是⼀个结点要么是叶结点,要么是有两个⼦结点的中间结点。
深度为k且含有2^k-1个结点的⼆叉树完全⼆叉树从左到右依次填充从根结点开始,依次从左到右填充树结点。
除最后⼀层外,每⼀层上的所有节点都有两个⼦节点,最后⼀层都是叶⼦节点。
平衡⼆叉树AVL树[3,1,2,5,9,7]⾸先科普下⼆叉排序树⼜称⼆叉查找树,议程⼆叉搜索树⼆叉排序树的规则⽐本⾝⼤放右边,⽐本⾝⼩放左边平衡⼆叉数⾸先是⼀个⼆叉排序树左右两个⼦树的⾼度差不⼤于1下⾯图中是平衡的情况下⾯是不平衡的情况引⼊公式(LL)右旋function toateRight(AvlNode){let node=AvlNode.left;//保存左节点 AvlNode.left=node.right;node.right=AvlNode;}(RR)左旋function roateLeft(AvlNode){let node=AvlNode.right;//保存右⼦节点AvlNode.right=node.left;node.left=AvlNode;return node;}左右旋⼤图判断⼆叉树是不是平衡树⼆叉树任意结点的左右⼦树的深度不超过1深度计算定义⼀个初始化的⼆叉树var nodes = {node: 6,left: {node: 5,left: {node: 4},right: {node: 3}},right: {node: 2,right: {node: 1}}}//计算⾼度const treeDepth = (root) => {if (root == null) {return 0;}let left = treeDepth(root.left)let right = treeDepth(root.right)return 1+(left>right?left:right)}//判断深度const isTree=(root)=>{if (root == null) {return true;}let left=treeDepth(root.left)let right=treeDepth(root.right)let diff=left-right;if (diff > 1 || diff < -1) {return false}return isTree(root.left)&&isTree(root.right) }console.log(isTree(nodes))判断⼆叉数是不是搜索⼆叉树//第⼀种 //中序遍历let last=-Infinity;const isValidBST=(root)=>{if (root == null) {return true;}//先从左节点开始if (isValidBST(root.left)) {if (last < root.node) {last=root.node;return isValidBST(root.right)}}return false}console.log(isValidBST(nodes))//第⼆种const isValidBST = root => {if (root == null) {return true}return dfs(root, -Infinity, Infinity)}const dfs = (root, min, max) => {if (root == null) {return true}if (root.node <= min || root.node >= max) {return false}return dfs(root.left, min, root.node) && dfs(root.right, root.node, max)}console.log(isValidBST(nodes))实现⼀个⼆叉树实现了⼆叉树的添加,删除,查找,排序//⼆叉树结点class TreeNode {constructor(n, left, right){this.n = n;this.left = left;this.right = right;}}//⼆叉树class BinaryTree {constructor(){this.length = 0;this.root = null;this.arr = [];}//添加对外⼊⼝,⾸个参数是数组,要求数组⾥都是数字,如果有不是数字则试图转成数字,如果有任何⼀个⽆法强制转成数字,则本操作⽆效 addNode(){let arr = arguments[0];if(arr.length == 0) return false;return this.judgeData('_addNode', arr)}//删除结点deleteNode(){let arr = arguments[0];if(arr.length == 0) return false;return this.judgeData('_deleteNode', arr)}//传值判断,如果全部正确,则全部加⼊叉树judgeData(func, arr){let flag = false;//任何⼀个⽆法转成数字,都会失败if(arr.every(n => !Number.isNaN(n))){let _this = this;arr.map(n => _this[func](n));flag = true;}return flag;}//添加的真实实现_addNode(n){n = Number(n);let current = this.root;let treeNode = new TreeNode(n, null, null);if(this.root === null){this.root = treeNode;}else {current = this.root;while(current){let parent = current;if(n < current.n){current = current.left;if(current === null){parent.left = treeNode;}}else {current = current.right;if(current === null){parent.right = treeNode;}}}}this.length++;return treeNode;}//删除节点的真实实现_deleteNode(n){n = Number(n);if(this.root === null){return;}//查找该节点,删除节点操作⽐较复杂,为排除找不到被删除的节点的情况,简化代码,先保证该节点是存在的,虽然这样做其实重复了⼀次查询了,但⼆叉树的查找效率很⾼,这是可接受的let deleteNode = this.findNode(n);if(!deleteNode){return;}//如果删除的是根节点if(deleteNode === this.root){if(this.root.left === null && this.root.right === null){this.root = null;}else if(this.root.left === null){this.root = this.root.right;}else if(this.root.right === null){this.root = this.root.left;}else {let [replaceNode, replacePNode, rp] = this.findLeftTreeMax(deleteNode);replacePNode[rp] = null;replaceNode.left = this.root.left;replaceNode.right = this.root.right;this.root = replaceNode;}}else {//被删除的⽗节点,⼦节点在⽗节点的位置p,有left,right两种可能let [deleteParent, p] = this.findParentNode(deleteNode);if(deleteNode.left === null && deleteNode.right === null){deleteParent[p] = null;}else if(deleteNode.left === null){deleteParent[p] = deleteNode.right;}else if(deleteNode.right === null){deleteParent[p] = deleteNode.left;}else {//⽤来替换被删除的节点,⽗节点,节点在⽗节点的位置let [replaceNode, replacePNode, rp] = this.findLeftTreeMax(deleteNode);if(replacePNode === deleteNode){deleteParent[p] = replaceNode;}else {deleteParent[p] = replaceNode;replacePNode.right = null;}replacePNode[rp] = null;replaceNode.left = deleteNode.left;replaceNode.right = deleteNode.right;}}this.length--;}//查找findNode(n){let result = null;let current = this.root;while(current){if(n === current.n){result = current;break;}else if(n < current.n){current = current.left;}else {current = current.right;}}return result;}//查找⽗节点findParentNode(node){let [parent, child, p] = [null, null, null];if(this.root !== node){parent = this.root;if(node.n < parent.n){child = parent.left;p = 'left';}else {child = parent.right;p = 'right';}while(child){if(node.n === child.n){break;}else if(node.n < child.n){parent = child;child = parent.left;p = 'left';}else {parent = child;child = parent.right;p = 'right';}}}return [parent, p];}//查找当前有左⼦树的节点的最⼤值的节点M,如有A个节点被删除,M是最接近A点之⼀(还有⼀个是右⼦树节点的最⼩值) findLeftTreeMax(topNode){let [node, parent, p] = [null, null, null];if(this.root === null || topNode.left === null){return [node, parent, p];}parent = topNode;node = topNode.left;p = 'left';while(node.right){parent = node;node = node.right;p = 'right';}return [node, parent, p];}//查找最⼤值maxValue(){if(this.root !== null){return this._findLimit('right');}}//查找最⼩值minValue(){if(this.root !== null){return this._findLimit('left');}}//实现查找特殊值_findLimit(pro){let n = this.root.n;let current = this.root;while(current[pro]){current = current[pro];n = current.n;}return n;}//中序排序,并⽤数组的形式显⽰sortMiddleToArr(){this._sortMiddleToArr(this.root);return this.arr;}//中序⽅法_sortMiddleToArr(node){if(node !== null){this._sortMiddleToArr(node.left);this.arr.push(node.n);this._sortMiddleToArr(node.right);}}//打印⼆叉树对象printNode(){console.log(JSON.parse(JSON.stringify(this.root)));}}//测试var binaryTree = new BinaryTree();binaryTree.addNode([50, 24, 18, 65, 4, 80, 75, 20, 37, 40, 60]);binaryTree.printNode();//{n: 50, left: {…}, right: {…}}console.log(binaryTree.maxValue());//80console.log(binaryTree.minValue());//4console.log(binaryTree.sortMiddleToArr());// [4, 18, 20, 24, 37, 40, 50, 60, 65, 75, 80] binaryTree.deleteNode([50]);binaryTree.printNode();//{n: 40, left: {…}, right: {…}}排序复习function ArrayList() {this.array = [];}ArrayList.prototype = {constructor: ArrayList,insert: function(item) {this.array.push(item);},toString: function() {return this.array.join();},swap: function(index1, index2) {var aux = this.array[index2];this.array[index2] = this.array[index1];this.array[index1] = aux;},//冒泡排序bubbleSort: function() {var length = this.array.length;for (var i = 0; i < length; i++) {for (var j = 0; j < length - 1 - i; j++) {if (this.array[j] > this.array[j + 1]) {this.swap(j, j + 1);}}}},//选择排序selectionSort: function() {var length = this.array.length;var indexMin;for (var i = 0; i < length - 1; i++) {indexMin = i;for (var j = i; j < length; j++) {if (this.array[indexMin] > this.array[j]) {indexMin = j;}}if (indexMin !== i) {this.swap(indexMin, i);}}},//插⼊排序insertionSort: function() {var length = this.array.length;var j;var temp;for (var i = 1; i < length; i++) {temp = this.array[i];j = i;while (j > 0 && this.array[j - 1] > temp) {this.array[j] = this.array[j - 1];j--;}this.array[j] = temp;}},//归并排序mergeSort: function() {function mergeSortRec(array) {var length = array.length;if (length === 1) {return array;}var mid = Math.floor(length / 2);var left = array.slice(0, mid);var right = array.slice(mid, length);return merge(mergeSortRec(left), mergeSortRec(right)); }function merge(left, right) {var result = [];var il = 0;var ir = 0;while (il < left.length && ir < right.length) {if (left[il] < right[ir]) {result.push(left[il++]);} else {result.push(right[ir++]);}}while (il < left.length) {result.push(left[il++]);}while (ir < right.length) {result.push(right[ir++]);}return result;}this.array = mergeSortRec(this.array);},//快速排序quickSort:function(){function sort(array){if (array.length <= 1) {return array;}var pivotIndex = Math.floor(array.length/2);var pivot = array.splice(pivotIndex,1)[0];var left = [];var right = [];for(var i = 0; i < array.length; i++){if (array[i] < pivot) {left.push(array[i]);}else{right.push(array[i]);}}return sort(left).concat([pivot],sort(right));}this.array = sort(this.array);}};...................................................................................................................############################################################################ ###################################################################################。
二叉树的常考算法题目
二叉树的常考算法题目
二叉树是计算机科学中常见的数据结构,以下是几个常见的二叉树相关算法题目:
1. 二叉树的深度:给定一个二叉树,求其深度。
2. 判断二叉树是否为完全二叉树:给定一个二叉树,判断它是否是完全二叉树。
3. 查找二叉树中的最大值和最小值:给定一个二叉树,找到其中的最大值和最小值。
4. 二叉树的镜像:给定一个二叉树,将其镜像(即左右节点交换)。
5. 反转二叉树:给定一个二叉树,将其反转。
6. 二叉树的左视图:给定一个二叉树,找到其左视图。
7. 二叉树的右视图:给定一个二叉树,找到其右视图。
8. 查找二叉树中的前驱节点和后继节点:给定一个二叉树和一个节点,找到该节点的前驱节点和后继节点。
9. 二叉树的层序遍历:给定一个二叉树,使用层序遍历的方式访问其节点。
10. 二叉树的先序遍历、中序遍历和后序遍历:给定一个二叉树,分别使用先序遍历、中序遍历和后序遍历的方式访问其节点。
这些题目是常见的二叉树算法题目,对于掌握二叉树相关算法非常重要。
实验报告 实验三 二叉排序树的建立和查找
实验三二叉排序树的建立和查找一、实验目的1.掌握二叉排序树的建立算法2.掌握二叉排序树查找算法。
二、实验环境操作系统和C语言系统三、预习要求复习二叉排序树的生成及查找算法,编写完整的程序。
四、实验内容实现二叉排序树上的查找算法。
具体实现要求:用二叉链表做存储结构,输入键值序列,建立一棵二叉排序树并在二叉排序树上实现查找算法。
五、参考算法#include <stdio.h>#include <stdlib.h>typedef int InfoType;typedef int KeyType; /*假定关键字类型为整数*/typedef struct node /*结点类型*/{KeyType key; /*关键字项*/InfoType otherinfo; /*其它数据域,InfoType视应用情况而定,下面不处理它*/struct node *lchild,*rchild; /*左右孩子指针*/}BSTNode;typedef BSTNode *BSTree; /*BSTree是二叉排序树的类型*/BSTNode *SearchBST(BSTree T,KeyType key){ /*在二叉排序树T上查找关键字为key的结点,成功时返回该结点位置,否则返回NULL*/if(T==NULL||key==T->key) /*递归的终结条件*/return T; /*若T为空,查找失败;否则成功,返回找到的结点位置*/if(key<T->key)return SearchBST(T->lchild,key);elsereturn SearchBST(T->rchild,key); /*继续在右子树中查找*/}void InsertBST(BSTree *T,int key){ /*插入一个值为key的节点到二叉排序树中*/BSTNode *p,*q;if((*T)==NULL){ /*树为空树*/(*T)=(BSTree)malloc(sizeof(BSTNode));(*T)->key=key;(*T)->lchild=(*T)->rchild=NULL;}else{p=(*T);while(p){q=p;if(p->key>key)p=q->lchild;else if(p->key<key)p=q->rchild;else{printf("\n 该二叉排序树中含有关键字为%d的节点!\n",key);return;}}p=(BSTree)malloc(sizeof(BSTNode));p->key=key;p->lchild=p->rchild=NULL;if(q->key>key)q->lchild=p;elseq->rchild=p;}}BSTree CreateBST(void){ /*输入一个结点序列,建立一棵二叉排序树,将根结点指针返回*/BSTree T=NULL; /*初始时T为空树*/KeyType key;scanf("%d",&key); /*读入一个关键字*/while(key){ /*假设key=0是输入结束标志*/ InsertBST(&T,key); /*将key插入二叉排序树T*/scanf("%d",&key); /*读入下一关键字*/}return T; /*返回建立的二叉排序树的根指针*/ }void ListBinTree(BSTree T) /*用广义表示二叉树*/{if(T!=NULL){printf("%d",T->key);if(T->lchild!=NULL||T->rchild!=NULL){printf("(");ListBinTree(T->lchild);if(T->rchild!=NULL)printf(",");ListBinTree(T->rchild);printf(")");}}}void main(){BSTNode *SearchBST(BSTree T,KeyType key);void InsertBST(BSTree *Tptr,KeyType key);BSTree CreateBST();void ListBinTree(BSTree T);BSTree T;BSTNode *p;int key;printf("请输入关键字(输入0为结束标志):\n");T=CreateBST();ListBinTree(T);printf("\n");printf("请输入欲查找关键字:");scanf("%d",&key);p=SearchBST(T,key);if(p==NULL)printf("没有找到%d!\n",key);elseprintf("找到%d!\n",key);ListBinTree(p);printf("\n");}实验中出现的问题及对问题的解决方案输入数据时,总是不能得到结果,原因是在建立二叉树函数定义中,是对指针的值进行了修改。
二叉树的基本概念
二叉树的基本概念一、引言二叉树是计算机科学中最基础的数据结构之一,它是由节点和边组成的树形结构,其中每个节点最多有两个子节点。
在计算机科学中,二叉树被广泛应用于搜索、排序、编译器等领域。
本文将详细介绍二叉树的基本概念。
二、定义二叉树是一种特殊的树形结构,其中每个节点最多有两个子节点。
通常将左子节点称为左子树,右子节点称为右子树。
三、基本术语1. 根节点:二叉树的顶层节点称为根节点。
2. 叶子节点:没有任何子节点的节点称为叶子节点。
3. 父节点和子节点:一个父亲可以有多个儿子,但是一个儿子只能有一个父亲。
4. 兄弟:具有相同父亲的两个或多个儿子称为兄弟。
5. 深度:从根到某个节点所经过的边数称为该节点的深度。
6. 高度:从某个节点到其所有后代中深度最大者加一(即包括该结点)称为该结点所在的二叉树的高度。
四、分类1. 满二叉树:一棵深度为k且有2^k-1个节点的二叉树称为满二叉树。
2. 完全二叉树:对于一棵深度为k的,有n个节点的二叉树,当且仅当其每一个节点都与深度为k的满二叉树中编号从1至n的节点一一对应时,称之为完全二叉树。
3. 平衡二叉树:平衡二叉树也称为AVL树,是一种自平衡的排序二叉搜索树。
它具有以下性质:左右子树高度差不超过1,并且左右子树也是平衡二叉树。
五、遍历遍历是指按照某种顺序访问每个节点。
常见的遍历方式有三种:1. 前序遍历(Pre-order):先访问当前节点,再依次遍历左子树和右子树。
2. 中序遍历(In-order):先依次遍历左子树,再访问当前节点,最后遍历右子树。
3. 后序遍历(Post-order):先依次遍历左子树和右子树,最后访问当前节点。
六、应用1. 搜索算法:在搜索算法中,二叉树被广泛应用于二分查找。
2. 排序算法:在排序算法中,二叉树被广泛应用于堆排序和快速排序。
3. 编译器:在编译器中,二叉树被广泛应用于语法分析和代码生成。
七、总结本文介绍了二叉树的基本概念、术语、分类、遍历以及应用。
二叉排序树与平衡二叉排序树基本操作的实现 文本文档
10 设计说明书(论文)质量 30 综述简练完整,有见解;立论正确,论述充分,结论严谨合理;实验正确,分析处理科学。
11 创新 10 对前人工作有改进或突破,或有独特见解。
成绩
指导教师评语
指导教师签名: 年 月 日
摘要及关键字
本程序中的数据采用“树形结构”作为其数据结构。具体采用的是“二叉排序树”。
1.2.5 平衡二叉树( AVL树 )
①平衡二叉树(Balanced Binary Tree)是指树中任一结点的左右子树的高度大致相同。 ②任一结点的左右子树的高度均相同(如满二叉树),则二叉树是完全平衡的。通常,只要二叉树的高度为O(1gn),就可看作是平衡的。 ③平衡的二叉排序树指满足BST性质的平衡二叉树。 ④AVL树中任一结点的左、右子树的高度之差的绝对值不超过1。在最坏情况下,n个结点的AVL树的高度约为1.44lgn。而完全平衡的二叉树高度约为lgn,AVL树是最接近最优的。
1.2.4平均查找长度…………………………………………………………… 6
1.2.5平均二叉树(AVL树)…………………………………………………… 6
1.2.6平衡因子………………………………………………………………… 7
1.2.7平衡二叉树的调整方法…………………………………………………… 7
攀枝花学院本科学生课程设计任务书
题 目 二叉排序树与平衡二叉树的实现
1、课程设计的目的
使学生进一步理解和掌握课堂上所学各种基本抽象数据类型的逻辑结构、存储结构和操作实现算法,以及它们在程序中的使用方法。
使学生掌握软件设计的基本内容和设计方法,并培养学生进行规范化软件设计的能力。
3) 使学生掌握使用各种计算机资料和有关参考资料,提高学生进行程序设计的基本能力。
常用数据结构和算法
常用数据结构和算法在计算机科学领域,数据结构和算法是构建高效程序的基石。
无论是开发软件应用,还是进行系统优化,都离不开对数据结构和算法的研究和应用。
本文将介绍一些常用的数据结构和算法,并讨论它们的特点和应用场景。
一、数组(Array)数组是最基本的数据结构之一,它由一系列连续的内存空间组成,可以存储相同类型的数据。
数组的特点是随机存取,即可以通过索引直接访问指定位置的元素。
数组在存取数据时效率非常高,但插入和删除操作则比较低效。
它的应用场景包括存储一组有序的数据、快速查找等。
二、链表(Linked List)链表是一种非连续的数据结构,由多个节点组成,每个节点包含一个数据元素和指向下一个节点的指针。
链表的特点是插入和删除操作效率高,但查找操作则比较低效,需要遍历整个链表。
链表适用于频繁插入和删除元素的场景,比如实现队列、栈等。
三、栈(Stack)栈是一种特殊的数据结构,它遵循先入后出(LIFO)的原则。
栈可以用数组或链表来实现,常见的操作包括入栈(push)和出栈(pop)。
栈的应用场景很广,比如表达式求值、函数调用等。
四、队列(Queue)队列是一种遵循先入先出(FIFO)原则的数据结构。
队列可以用数组或链表来实现,常见的操作包括入队(enqueue)和出队(dequeue)。
队列的应用包括任务调度、消息传递等。
五、树(Tree)树是一种层次结构的数据结构,由节点和边组成。
树的结构使得在其中进行搜索、插入和删除等操作非常高效。
常见的树结构包括二叉树、二叉搜索树、平衡二叉树、红黑树等。
树的应用非常广泛,比如文件系统、数据库索引等。
六、图(Graph)图是一种由节点和边组成的非线性数据结构,它包括有向图和无向图。
图的表示方式有邻接矩阵和邻接表两种,它的应用场景包括网络拓扑分析、搜索算法等。
七、排序算法排序算法是数据处理中非常重要的一类算法,主要用于将一组无序的数据按照某种规则进行排序。
常见的排序算法包括冒泡排序、插入排序、选择排序、快速排序、归并排序等。
数据结构实验三——二叉树基本操作及运算实验报告
《数据结构与数据库》实验报告实验题目二叉树的基本操作及运算一、需要分析问题描述:实现二叉树(包括二叉排序树)的建立,并实现先序、中序、后序和按层次遍历,计算叶子结点数、树的深度、树的宽度,求树的非空子孙结点个数、度为2的结点数目、度为2的结点数目,以及二叉树常用运算。
问题分析:二叉树树型结构是一类重要的非线性数据结构,对它的熟练掌握是学习数据结构的基本要求。
由于二叉树的定义本身就是一种递归定义,所以二叉树的一些基本操作也可采用递归调用的方法。
处理本问题,我觉得应该:1、建立二叉树;2、通过递归方法来遍历(先序、中序和后序)二叉树;3、通过队列应用来实现对二叉树的层次遍历;4、借用递归方法对二叉树进行一些基本操作,如:求叶子数、树的深度宽度等;5、运用广义表对二叉树进行广义表形式的打印。
算法规定:输入形式:为了方便操作,规定二叉树的元素类型都为字符型,允许各种字符类型的输入,没有元素的结点以空格输入表示,并且本实验是以先序顺序输入的。
输出形式:通过先序、中序和后序遍历的方法对树的各字符型元素进行遍历打印,再以广义表形式进行打印。
对二叉树的一些运算结果以整型输出。
程序功能:实现对二叉树的先序、中序和后序遍历,层次遍历。
计算叶子结点数、树的深度、树的宽度,求树的非空子孙结点个数、度为2的结点数目、度为2的结点数目。
对二叉树的某个元素进行查找,对二叉树的某个结点进行删除。
测试数据:输入一:ABC□□DE□G□□F□□□(以□表示空格),查找5,删除E预测结果:先序遍历ABCDEGF中序遍历CBEGDFA后序遍历CGEFDBA层次遍历ABCDEFG广义表打印A(B(C,D(E(,G),F)))叶子数3 深度5 宽度2 非空子孙数6 度为2的数目2 度为1的数目2查找5,成功,查找的元素为E删除E后,以广义表形式打印A(B(C,D(,F)))输入二:ABD□□EH□□□CF□G□□□(以□表示空格),查找10,删除B预测结果:先序遍历ABDEHCFG中序遍历DBHEAGFC后序遍历DHEBGFCA层次遍历ABCDEFHG广义表打印A(B(D,E(H)),C(F(,G)))叶子数3 深度4 宽度3 非空子孙数7 度为2的数目2 度为1的数目3查找10,失败。
数据结构常考的5个算法
数据结构常考的5个算法数据结构是计算机科学中非常重要的一部分。
它是指用于组织和存储数据的方式,常用的有线性数据结构和非线性数据结构。
在数据结构中,有许多重要的算法,这些算法可以被用于许多问题的解决。
本文将介绍数据结构中常考的5个算法。
一.堆排序算法堆排序算法是一种高效的排序算法,它使用堆的概念。
它的时间复杂度为O(nlogn),比冒泡排序和选择排序更加优秀。
堆排序算法是分两个步骤进行的:第一步是建立堆,第二步是排序。
在建立堆的过程中,我们使用了一个特殊的数据结构——堆。
堆是一个树形数据结构,它的子节点的值永远小于或等于它的父节点的值。
堆有两种类型:最大堆和最小堆。
最大堆:就是父节点的值比其子节点的值都大。
最小堆:就是父节点的值比其子节点的值都小。
堆排序算法利用了最大堆的性质实现排序。
在排序过程中,我们首先把输入数据构建成一个最大堆,然后不断地取出最大值并把剩余的部分调整成新的堆。
重复这个过程,直到所有的数据都被排序。
二.快速排序算法快速排序算法是一种递归的分治算法,它的基本思想是选择一个枢轴元素,将所有小于枢轴元素的值放到左半边,将所有大于枢轴元素的值放到右半边,再分别对左右两边的子数组进行快速排序。
快速排序算法的时间复杂度为O(nlogn),但是最坏情况下它的时间复杂度为O(n^2)。
在最坏情况下,每次选择的枢轴元素都是当前数组中的最大值或最小值,这样就需要O(n)的时间进行交换。
为了避免最坏情况的出现,我们可以随机选择枢轴元素。
这样虽然不能完全避免最坏情况的出现,但是出现的概率较小。
三.归并排序算法归并排序算法是另一种常用的排序算法,它是分治算法的一个经典应用。
归并排序算法基于以下几个步骤:1.把一个大的数组分成两个子数组。
2.对子数组进行排序。
3.合并两个已经排好序的子数组,产生一个新的排好序的数组。
在归并排序算法中,我们使用递归方式对子数组进行排序,然后使用合并方法把已经排好序的子数组合并成一个新的数组。
二叉树总结点数
二叉树总结点数二叉树是一种常见的数据结构,适用于各种计算机科学中的问题。
在计算机科学中,二叉树通常用于排序、搜索和存储数据等操作。
一个二叉树由一个根节点和左右两个子节点组成,每个节点可以有零个或多个子节点。
本文将介绍的相关概念和算法。
首先,我们来了解什么是二叉树的总结点数。
总结点数指的是二叉树中节点的总数。
一个二叉树的节点总数取决于其结构和规模,通常用符号n表示。
对于一个空的二叉树,其节点总数为0。
在二叉树中,每个节点都有一个值和对应的左右子节点。
通过递归算法,可以从根节点开始统计二叉树中的节点总数。
递归算法是一种通过自身重复计算的方法,非常适合用来解决二叉树相关的问题。
二叉树的节点总数可以通过以下算法来计算:1. 如果二叉树为空,即根节点为null,总结点数为0,返回0。
2. 如果二叉树不为空,即根节点存在,总结点数由左子树和右子树的节点总数之和加1得到,即总结点数 = 左子树节点数 + 右子树节点数 + 1。
通过以上算法,我们可以递归地计算二叉树中的节点总数。
这种算法的时间复杂度为O(n),其中n为节点的总数。
这是因为每个节点都需要访问一次,所以总共需要访问n个节点。
除了递归算法外,还有其他一些方法可以计算二叉树的节点总数。
例如,可以通过层次遍历算法来访问二叉树中的每个节点,并计算节点的数量。
层次遍历算法是一种逐层遍历二叉树的方法,从根节点开始,首先访问根节点,然后依次访问每一层的节点。
通过层次遍历算法,我们可以在遍历的过程中统计节点的数量。
另一种方法是基于根节点的高度计算节点的数量。
根节点的高度是指从根节点到叶节点的最长路径上的节点数量。
通过计算二叉树的根节点高度,可以得到根节点为根的子树的节点总数。
然后,可以递归地计算左右子树的节点总数,并将其相加得到整个二叉树的节点总数。
总结来说,计算二叉树的节点总数是一个重要而常见的问题。
通过递归算法、层次遍历算法或者高度统计算法,我们可以有效地计算二叉树中节点的数量。
堆排序算法实现堆排序的原理和时间复杂度分析
堆排序算法实现堆排序的原理和时间复杂度分析堆排序(Heap Sort)是一种基于二叉堆数据结构的高效排序算法。
它被广泛应用于各种程序设计中,因为其时间复杂度较低且具备稳定性。
本文将介绍堆排序算法的原理和时间复杂度分析。
一、堆排序的原理堆是一种特殊的二叉树,它满足以下两个性质:1. 父节点的值大于(或小于)其子节点的值,这种特性被称为"堆属性"。
2. 堆是一颗完全二叉树,即除了最底层外,其他层次上的节点都是满的,且最底层节点从左到右连续存在。
堆排序的基本思想是将待排序的数组构建成一个大(或小)根堆,然后通过将堆顶元素与末尾元素交换,并缩小堆的范围来实现排序。
具体步骤如下:1. 构建堆:从待排序数组构建一个大(或小)根堆。
首先需要将待排序数组构建成一个完全二叉树,然后从最后一个非叶子节点开始,依次向上调整节点的位置,使得每个父节点的值都大于(或小于)其子节点的值。
2. 排序堆:将堆顶元素(最大值或最小值)与数组末尾元素交换位置,然后缩小堆的范围,再次调整堆,使得剩余的元素重新满足堆的属性。
重复该步骤,直到将所有元素排序完成。
二、堆排序的时间复杂度分析1. 构建堆的时间复杂度:构建堆的时间复杂度为O(n),其中n为待排序数组的长度。
这是因为从最后一个非叶子节点开始调整堆的过程中,每个节点的调整操作的时间复杂度都是O(logn),共有n/2个非叶子节点。
2. 排序堆的时间复杂度:排序堆的时间复杂度为O(nlogn)。
在每次交换堆顶元素与数组末尾元素之后,都需要对堆进行调整,而每次调整的时间复杂度为O(logn)。
由于需要执行n次该过程,因此总的时间复杂度为O(nlogn)。
综上所述,堆排序的时间复杂度为O(nlogn),在待排序数组规模较大时,具有较高的排序效率和稳定性。
本文简要介绍了堆排序算法的原理和时间复杂度分析。
堆排序通过构建堆和排序堆的过程实现排序,其时间复杂度为O(nlogn),适用于大规模数据的排序任务。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验报告课程名称:数据结构实验课程实验四、串的基本操作练习一、实验目的1. 掌握二叉树的存储实现2. 掌握二叉树的遍历思想3. 掌握二叉树的常见算法的程序实现二、实验环境VC++6.0三、实验内容1.输入字符序列,建立二叉树的二叉链表结构。
(可以采用先序序列)2.实现二叉树的先序、中序、后序的递归遍历算法。
3.实现二叉树的先序、中序、后序的非递归遍历算法。
4.求二叉树的高度。
5.求二叉树的结点个数。
6.求二叉树的叶子结点的个数。
四、实验要求:分别编写实现上述算法的子函数,并编写一个主函数,在主函数中设计一个简单的菜单,分别调用上述子函数。
五、实验步骤和结果1.打开vc,新建文本,命名二叉树算法,编写代码。
2.编写代码:#include <stdio.h>#include <stdlib.h>#define STACK_INIT_SIZE 100#define STACKINCREMENT 10int i=0;/*--------------------------------------建立堆栈------------------------------------------*/typedef struct BiTNode{char data;struct BiTNode *lchild,*rchild;} BiTNode,*BiTree;//树类型typedef struct SqStack{BiTNode *base;BiTNode *top;int stacksize;} SqStack;//栈类型void InitStack(SqStack *S)//创建二叉树{S->base=(BiTNode*)malloc(STACK_INIT_SIZE*sizeof(BiTNode));S->top=S->base;S->stacksize=STACK_INIT_SIZE;}void Push(SqStack *S,BiTNode e)//进栈{if(S->top - S->base >= S->stacksize)//如果栈空间不足{S->base=(BiTNode*)realloc(S->base,(S->stacksize+STACKINCREMENT)*sizeof(B iTNode));S->top=S->base+S->stacksize;S->stacksize+=STACKINCREMENT;}*(S->top)=e;S->top++;}BiTNode Pop(SqStack *S)//出栈{S->top --;return *S->top;}int StackEmpty(SqStack *S)//判断栈是否非空{if(S->top == S->base )return 1;elsereturn 0;}/*---------------------------------------------递归部分-------------------------------------------*/BiTree Create(BiTree T)//建立二叉树{char ch;ch=getchar();if(ch=='#')T=NULL;else{if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))printf("申请内存空间失败!");T->data=ch;T->lchild=Create(T->lchild);T->rchild=Create(T->rchild);}return T;}int Sumleaf(BiTree T)//计算叶子节点{int sum=0,m,n;if(T){if((!T->lchild)&&(!T->rchild))sum++;m=Sumleaf(T->lchild);sum+=m;n=Sumleaf(T->rchild);sum+=n;}return sum;}/*int Sumleaf(BiTree T)//老师课堂上的计算叶子数的代码,没有问题{if(!(T->lchild&&T->rchild))return 1;elsereturn(Sumleaf(T->lchild)+Sumleaf(T->rchild));}*/int PreOrder_1(BiTree T)//先序递归{if(T){printf("%c",T->data);//根节点i++;PreOrder_1(T->lchild);PreOrder_1(T->rchild);}return i;}void InOrder_1(BiTree T)//中序递归{if(T){InOrder_1(T->lchild);printf("%c",T->data);//根节点InOrder_1(T->rchild);}}void PostOrder_1(BiTree T)//后序递归{if(T){PostOrder_1(T->lchild);PostOrder_1(T->rchild);printf("%c",T->data);//根节点}}int Depth(BiTree T)//计算高度{int dep=0,depl,depr;if(!T)dep=0;else{depl=Depth(T->lchild);depr=Depth(T->rchild);dep=1+(depl>depr?depl:depr);}return dep;}/*-------------------------------------非递归部分----------------------------------------*/{SqStack S;BiTree p=T,q;q=(BiTNode *)malloc(sizeof(BiTNode));InitStack(&S);if(p)Push(&S,*p);while(!StackEmpty(&S)){p=q;*p=Pop(&S);//移到叶子时,出栈,输出出栈元素printf("%c",p->data);if(p->rchild)//如果有右孩子,访问右孩子,并沿右孩子移位Push(&S,*p->rchild);if(p->lchild)//如果没有右孩子,访问左孩子,并移到左孩子Push(&S,*p->lchild);}}void InOrder_2(BiTree T)//中序非递归{SqStack S;BiTree p,q;p=T;InitStack(&S);q=(BiTNode *)malloc(sizeof(BiTNode));while(p||!StackEmpty(&S)){if(p){Push(&S,*p);p=p->lchild;}else{p=q;*p=Pop(&S);printf("%c",p->data);p=p->rchild;}}}{int mark[100];//标示int t=0;int top=-1;//下标SqStack S;BiTree p=T,q;InitStack(&S);q=(BiTNode *)malloc(sizeof(BiTNode));if(p&&(p->lchild||p->rchild)){do{while((p->lchild||p->rchild)&&mark[top+1]!=2)//循环直到让p向左滑到叶子节点{top++;Push(&S,*p);//每循环一次,当前结点入栈mark[top]=1;//结点第一次入栈时,标志为1if(p->lchild)p=p->lchild;//找最左子树elseif(p->rchild)p=p->rchild;}if(p)printf("%c",p->data);p=q;*p=Pop(&S);top--;//出栈,下标归位if(!p->rchild||!p->lchild)//防止出现不必要的再次入栈mark[top+1]=2;if(mark[top+1]==1&&p->rchild)//若结点是第一次出栈,则再入栈{top++;Push(&S,*p);mark[top]=2;//结点第二次入栈时,标志为2p=p->rchild;//访问右子树mark[top+1]=0;}if(mark[0]==2&&t==0)//当栈剩下最后一个结点的时候,把下标初始化。
{int i;t++;for(i=0;i<100;i++){mark[i]=0;}}}while (top!=-1&&!StackEmpty(&S)&&p);printf("%c",p->data);//输出根节点}elseif(p)printf("%c",p->data);//当树仅有一个结点时}void main(){BiTree Ta;int sum,dep,total;printf("输入数据创建二叉树");Ta=Create(Ta);printf("************************递归遍历***************************");printf("\n递归先序遍历:\n");total=PreOrder_1(Ta);printf("\n递归中序遍历:\n");InOrder_1(Ta);printf("\n递归后序遍历:\n");PostOrder_1(Ta);sum=Sumleaf(Ta);printf("\n");printf("*******************结点总数叶子数和高度********************");printf("\n该二叉树结点总数为:%d",total);printf("\n叶子总数为:%d",sum);dep=Depth(Ta);printf("\n高度为:%d\n",dep);printf("***********************非递归遍历**************************");printf("\n非递归先序遍历:\n");PreOrder_2(Ta);printf("\n非递归中序遍历:\n");InOrder_2(Ta);printf("\n非递归后序遍历:\n");PostOrder_2(Ta);printf("\n\n");}六、实验结果和讨论1.首先,代码,修改语法错误,调试。