二叉树的建立及其应用程序代码
二叉树的建立与基本操作
二叉树的建立与基本操作二叉树是一种特殊的树形结构，它由节点（node）组成，每个节点最多有两个子节点。
二叉树的基本操作包括建立二叉树、遍历二叉树、查找二叉树节点、插入和删除节点等。
本文将详细介绍二叉树的建立和基本操作，并给出相应的代码示例。
一、建立二叉树建立二叉树有多种方法，包括使用数组、链表和前序、中序、后序遍历等。
下面以使用链表的方式来建立二叉树为例。
1.定义二叉树节点类首先，定义一个二叉树节点的类，包含节点值、左子节点和右子节点三个属性。
```pythonclass Node:def __init__(self, value):self.value = valueself.left = Noneself.right = None```2.建立二叉树使用递归的方法来建立二叉树，先构造根节点，然后递归地构造左子树和右子树。
```pythondef build_binary_tree(lst):if not lst: # 如果 lst 为空，则返回 Nonereturn Nonemid = len(lst) // 2 # 取 lst 的中间元素作为根节点的值root = Node(lst[mid])root.left = build_binary_tree(lst[:mid]) # 递归构造左子树root.right = build_binary_tree(lst[mid+1:]) # 递归构造右子树return root```下面是建立二叉树的示例代码：```pythonlst = [1, 2, 3, 4, 5, 6, 7]root = build_binary_tree(lst)```二、遍历二叉树遍历二叉树是指按照其中一规则访问二叉树的所有节点，常见的遍历方式有前序遍历、中序遍历和后序遍历。
1.前序遍历前序遍历是指先访问根节点，然后访问左子节点，最后访问右子节点。
```pythondef pre_order_traversal(root):if root:print(root.value) # 先访问根节点pre_order_traversal(root.left) # 递归访问左子树pre_order_traversal(root.right) # 递归访问右子树```2.中序遍历中序遍历是指先访问左子节点，然后访问根节点，最后访问右子节点。
二叉排序树c语言代码实现
if ((*n) != NULL) {
free (*n);
*n = NULL;
}
}
/* 查找结点 */
PNODE find_node (PNODE n, int value) {
in_order_traversal ( n->right);
}
}
int main() {
char buf[50],a[1000];
int i,n,option,s[80],p;
PNODE tree = NULL;/*树的第一个结点*/
PNODE node = NULL;
{
r = (PNODE)malloc(sizeof(NODE));
if(!r)
{
printf("内存分配失败！");
exit(0);
zjm3:fgets (buf, sizeof(buf), stdin);
sscanf (buf, "%i", &option);
printf ("\n\n");
if(option<0) {
printf ("输入错误，请重新输入该元素\n",n);
goto zjm3;}
if(find_node (tree, option))
{
(*n)->value = value;
(*n)->left = NULL;
(*n)->right = NULL;
}
}
二叉树的建立方法总结
⼆叉树的建⽴⽅法总结之前已经介绍了⼆叉树的四种遍历(如果不熟悉)，下⾯介绍⼀些⼆叉树的建⽴⽅式。
⾸先需要明确的是，由于⼆叉树的定义是递归的，所以⽤递归的思想建⽴⼆叉树是很⾃然的想法。
1. 交互式问答⽅式这种⽅式是最直接的⽅式，就是先询问⽤户根节点是谁，然后每次都询问⽤户某个节点的左孩⼦是谁，右孩⼦是谁。
代码如下(其中字符'#'代表空节点)：#include <cstdio>#include <cstdlib>using namespace std;typedef struct BTNode *Position;typedef Position BTree;struct BTNode{char data;Position lChild, rChild;};BTree CreateBTree(BTree bt, bool isRoot){char ch;if (isRoot)printf("Root: ");fflush(stdin); /* 清空缓存区 */scanf("%c", &ch);fflush(stdin);if (ch != '#'){isRoot = false;bt = new BTNode;bt->data = ch;bt->lChild = NULL;bt->rChild = NULL;printf("%c's left child is: ", bt->data);bt->lChild = CreateBTree(bt->lChild, isRoot);printf("%c's right child is: ", bt->data);bt->rChild = CreateBTree(bt->rChild, isRoot);}return bt;}int main(){BTree bt;bt = CreateBTree(bt, true);LevelOrderTraversal(bt); /* 层序遍历 */return0;}2. 根据先序序列例如输⼊序列ABDH##I##E##CF#J##G##（#表⽰空），则会建⽴如下图所⽰的⼆叉树思路和第⼀种⽅式很相似，只是代码实现细节有⼀点区别，这⾥给出创建函数BTree CreateBTree(){BTree bt = NULL;char ch;scanf("%c", &ch);if (ch != '#'){bt = new BTNode;bt->data = ch;bt->lChild = CreateBTree();bt->rChild = CreateBTree();}return bt;}3. 根据中序序列和后序序列和⽅式⼆不同的是，这⾥的序列不会给出空节点的表⽰，所以如果只给出先序序列，中序序列，后序序列中的⼀种，不能唯⼀确定⼀棵⼆叉树。
数据结构二叉树的基本操作代码
数据结构二叉树的基本操作代码x#include<iostream>using namespace std;//二叉树的结构struct TreeNode{int data;//节点的值TreeNode *left;//指向左子树TreeNode *right;//指向右子树};//插入节点void insert(TreeNode *&tree, int val){if(tree == NULL){tree = new TreeNode;tree->data = val;tree->left = tree->right = NULL;}else if(val<=tree->data)//小于根节点的值则插入到左子树 insert(tree->left, val);else if(val>tree->data)//大于根节点的值则插入到右子树 insert(tree->right,val);}//查找节点TreeNode* find(TreeNode *tree,int val){if (tree == NULL)//树为空，无法查找return NULL;else if (val == tree->data)//值和节点的值相等，返回该节点return tree;else if (val < tree->data)//值小于节点的值，查找左子树 return find(tree->left,val);else if (val > tree->data)//值大于节点的值，查找右子树 return find(tree->right,val);elsereturn NULL;//无法查找}//遍历二叉树//先序遍历void preOrder(TreeNode *tree){if(tree != NULL){cout<< tree->data <<'t'; //先访问根节点preOrder(tree->left); //再遍历左子树 preOrder(tree->right); //最后遍历右子树 }}//中序遍历void inOrder(TreeNode *tree){if(tree != NULL){inOrder(tree->left); //先遍历左子树 cout<< tree->data <<'t'; //再访问根节点inOrder(tree->right); //最后遍历右子树 }}//后序遍历void postOrder(TreeNode *tree){if(tree != NULL){postOrder(tree->left); //先遍历左子树 postOrder(tree->right); //再遍历右子树 cout<< tree->data <<'t'; //最后访问根节点 }}//查找最大值TreeNode* findMax(TreeNode *tree){if(tree == NULL)return NULL;else if(tree->right == NULL)return tree;elsereturn findMax(tree->right);}//查找最小值TreeNode* findMin(TreeNode *tree){if(tree == NULL)return NULL;else if(tree->left == NULL)return tree;elsereturn findMin(tree->left);}//删除节点void remove(TreeNode *&tree, int val){if(tree == NULL)return;else if(val < tree->data)remove(tree->left, val);else if(val > tree->data)remove(tree->right, val);else//找到要删除的节点{if(tree->left != NULL && tree->right != NULL)//左右子树均不为空{TreeNode *temp = tree;TreeNode *max = findMax(tree->left);//查找左子树的最大结点tree->data = max->data;//将最大结点的值替换到要删除的节点remove(temp->left, max->data);//将最大结点删掉}else//只有一边的子节点不为空或者左右节点都为空{TreeNode *temp = tree;if(tree->left == NULL)//如果左节点为空，就将右节点提升 tree = tree->right;else if(tree->right == NULL)//如果右节点为空，就将左节点提升tree = tree->left;delete temp;//删掉要删除的节点}}}int main(){TreeNode *tree = NULL; //声明一个空树int arr[10] = {12, 3, 4, 6, 7, 9, 10, 5, 2, 8};for(int i=0; i<10; i++){insert(tree, arr[i]);//把数组元素插入到树当中}cout<<'先序遍历：';preOrder(tree);cout<<endl;cout<<'中序遍历：';inOrder(tree);cout<<endl;cout<<'后序遍历：';postOrder(tree);cout<<endl;cout<<'查找节点数据：4';TreeNode *findNode = find(tree, 4);if(findNode != NULL)//如果节点存在cout<<'找到了，节点的值是：'<<findNode->data;else//如果节点不存在cout<<'没有找到';cout<<endl;cout<<'查找树的最大值：'<<findMax(tree)->data<<endl; cout<<'查找树的最小值：'<<findMin(tree)->data<<endl; cout<<'删除节点：。
二叉树的创建与应用实例
二叉树的创建与应用实例一、引言二叉树是一种非常常见的数据结构，它在很多领域都有着广泛的应用，如文件系统、计算机科学、数据挖掘等。
了解和掌握二叉树的结构和应用，对于深入理解数据结构和算法是非常有帮助的。
本篇文档将详细介绍二叉树的创建以及应用实例。
二、二叉树的基本概念二叉树是一种递归定义的数据结构，它由一个根节点和两个子节点（分别称为左子树和右子树）组成。
二叉树的每个节点最多有两个子节点，这使得二叉树具有高度优化和紧凑性的特点。
三、二叉树的创建创建二叉树通常有两种方式：手动创建和通过算法创建。
1.手动创建：手动创建二叉树需要按照二叉树的定义规则，逐个创建节点并连接它们。
这种方式的优点是直观易懂，缺点是手动创建大量的节点会比较繁琐。
2.算法创建：算法创建二叉树通常使用递归的方式，通过特定的算法步骤逐个构建节点。
这种方式可以自动化地创建大量的二叉树，而且效率较高。
四、二叉树的应用实例1.文件系统：文件系统中的目录结构可以看作是一种特殊的二叉树，其中根节点是整个文件系统的入口，左子节点表示子目录，右子节点表示文件。
通过二叉树可以方便地管理和查找文件。
2.计算机科学：在计算机科学中，二叉树常用于表示程序的执行路径，如决策树、堆栈等。
此外，二叉树也常用于数据压缩和哈希算法等。
3.数据挖掘：在数据挖掘中，二叉树常用于分类和聚类算法，如决策树、k-means等。
通过构建二叉树，可以将数据集划分为不同的类别，从而更好地理解和分析数据。
五、应用实例代码展示下面是一个简单的Python代码示例，展示了如何手动创建一个简单的二叉搜索树（BinarySearchTree,BST）：```pythonclassNode:def__init__(self,key):self.left=Noneself.right=Noneself.val=keydefinsert(root,key):ifrootisNone:returnNode(key)else:ifroot.val<key:root.right=insert(root.right,key)else:root.left=insert(root.left,key)returnrootdefinorder(root):ifroot:inorder(root.left)print(root.val),inorder(root.right)r=Node(50)r=insert(r,30)r=insert(r,20)r=insert(r,40)r=insert(r,70)r=insert(r,60)r=insert(r,80)print("Inordertraversalofthegiventree")inorder(r)#Output:20304050607080```六、总结本篇文档详细介绍了二叉树的创建以及应用实例，包括二叉树的基本概念、创建方式以及在文件系统、计算机科学、数据挖掘等领域的应用。
实现二叉树的各种基本运算的算法代码
实现二叉树的各种基本运算的算法代码（一）创建二叉树1. 二叉树的链表存储结构：//定义二叉树的链表存储结构typedef struct BiTNode{char data;struct BiTNode *lchild, *rchild;} BiTNode, *BiTree;2.利用二叉树的链表存储结构，创建一棵二叉树//根据二叉树的链表存储结构，创建一棵二叉树BiTree CreateBiTree(BiTree T){char c;scanf(&c);if(c=='#')T=NULL;else{T=(BiTree)malloc(sizeof(BiTNode)); // 产生根节点 T->data=c; // 生成根结点T->lchild = CreateBiTree(T->lchild); // 构造左子树 T->rchild = CreateBiTree(T->rchild); // 构造右子树 }return T;}（二）二叉树的遍历1.先序遍历// 先序遍历：根左右void PreOrderTraverse(BiTree T){if(T==NULL)return;printf('%c',T->data); // 访问根结点PreOrderTraverse(T->lchild); // 遍历左子树PreOrderTraverse(T->rchild); // 遍历右子树}2.中序遍历// 中序遍历：左根右void InOrderTraverse(BiTree T){if(T==NULL)return;InOrderTraverse(T->lchild); // 遍历左子树 printf('%c',T->data); // 访问根结点InOrderTraverse(T->rchild); // 遍历右子树 }3.后序遍历// 后序遍历：左右根void PostOrderTraverse(BiTree T){if(T==NULL)return;PostOrderTraverse(T->lchild); // 遍历左子树 PostOrderTraverse(T->rchild); // 遍历右子树 printf('%c',T->data); // 访问根结点}（三）二叉树的其他基本运算1.计算二叉树的结点数// 计算二叉树的结点数int CountTreeNode(BiTree T){if(T==NULL)return 0; // 二叉树T为空时，结点数为0elsereturnCountTreeNode(T->lchild)+CountTreeNode(T->rchild)+1; }2.计算二叉树的深度// 计算二叉树的深度int TreeDepth(BiTree T){int depL, depR;if(T==NULL)return 0; // 二叉树T为空时，深度为0else{depL = TreeDepth(T->lchild); // 左子树深度depR = TreeDepth(T->rchild); // 右子树深度if(depL > depR)return depL+1;elsereturn depR+1;}}。
二叉树的应用程序代码
if ((*p)->data==parents)
{
if((*p)->lchild)
{
*k= (*p)->lchild ; //查找左子树
//Deletel(*k);
}
}
else
{
if((*p)->lchild) Search_lchild(&(*p)->lchild,parents,&(*k));
if((*p)->rchild) Search_lchild(&(*p)->rchild,parents,&(*k));
}
}
void Deletel(Bitree *p)
{
Bitree *t;
t=p;
if((*t))
{
Deletel(&(*t)->lchild);
{
if((*p)->data==childl) //找到结点
{
q=(Bitree)malloc(sizeof(Bitree));
q->data=child;
if(!(*p)->lchild) //左结点不存在
{
(*p)->lchild=q;
if(T) printf("左子树为:%c\n",T->data); else printf("不符合要求\n");
printf("删除左子树后为: ");
Deletel(&T);
q->lchild=NULL;
First(p);
printf("\n");
二叉树的完整代码实现
⼆叉树的完整代码实现1 #include<stdio.h>2 #include<stdlib.h>3 #include<malloc.h>45 typedef struct Node//结构体6 {7char data;8struct Node *LChild;9struct Node *RChild;10 } BinNode,*BinTree;1112 BinTree CreateTree(BinTree T)13 {14char ch;15 scanf("%c",&ch);16if(ch=='#')17return NULL;18else19 {20 T=(BinTree)malloc(sizeof(BinNode));21 T->data=ch;22 T->LChild=CreateTree(T->LChild);/*创建左⼦树*/23 T->RChild=CreateTree(T->RChild);/*创建右⼦树*/24return T;25 }26 }2728void PreOrder(BinTree root)//先序遍历29 {30if (root != NULL)31 {32 printf("%c", root->data);33 PreOrder(root->LChild);34 PreOrder(root->RChild);35 }36 }3738void InOrder(BinTree root)//中序遍历39 {40if (root != NULL)41 {42 InOrder(root->LChild);43 printf("%c", root->data);44 InOrder(root->RChild);45 }46 }4748void PostOrder(BinTree root)//后序遍历49 {50if (root != NULL)51 {52 PostOrder(root->LChild);53 PostOrder(root->RChild);54 printf("%c", root->data);55 }56 }57/*求⼆叉树结点总数*/58int Count(BinTree T)59 {60if(T==NULL)61return0; /*空⼆叉树结点数为0*/62else/*左右⼦树结点总数加1*/63return Count(T->LChild)+Count(T->RChild)+1;64 }65//叶⼦数66int LeafCount(BinTree T){67if(T == NULL){68return0;69 }70else if ((T->LChild==NULL) && (T->RChild==NULL)){71return1;72 }73else{74return LeafCount(T->LChild)+LeafCount(T->RChild);75 }76 }77int main()78 {7980 BinTree bt;81 printf("⼀、请按先序的⽅式输⼊⼆叉树的结点元素（注：输⼊#表⽰节点为空）如:ABC##DE#G##F###\n");82 bt=CreateTree(bt);83 printf("⼆、前序遍历⼆叉树：\n");84 PreOrder(bt);85 printf("\n");86 printf("三、中序遍历⼆叉树：\n");87 InOrder(bt);88 printf("\n");89 printf("四、后序遍历⼆叉树：\n");90 PostOrder(bt);91 printf("\n");92 printf("五、⼆叉树结点数: %d\n",Count(bt));93 printf("六、叶⼦节点的个数：%d \n",LeafCount(bt));94 system("pause");95 }。
c语言实现二叉树各种基本运算的算法
c语言实现二叉树各种基本运算的算法二叉树是一种常见的数据结构，可以应用于许多算法和问题中。
在C语言中，我们可以使用指针和结构体来实现二叉树的各种基本运算。
本文将详细介绍二叉树的创建、插入、删除、查找以及遍历等基本操作的算法。
1.创建二叉树创建二叉树可以通过递归的方式来实现。
首先定义一个表示二叉树节点的结构体，包含一个值和左右子节点指针。
然后，通过递归地创建左右子树来构建整个二叉树。
```ctypedef struct TreeNode {int data;struct TreeNode* left;struct TreeNode* right;} TreeNode;//创建二叉树TreeNode* createBinaryTree() {int data;scanf("%d", &data);if (data == -1) { // -1表示空节点return NULL;}TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode)); node->data = data;node->left = createBinaryTree();node->right = createBinaryTree();return node;}```2.插入节点在二叉树中插入节点可以按照二叉搜索树的性质进行。
如果要插入的值小于当前节点的值，则将其插入到左子树中，否则插入到右子树中。
如果子树为空，则直接创建一个新节点作为子树。
```c//插入节点TreeNode* insertNode(TreeNode* root, int data) {if (root == NULL) {TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode));newNode->data = data;newNode->left = NULL;newNode->right = NULL;return newNode;}if (data < root->data) {root->left = insertNode(root->left, data);} else {root->right = insertNode(root->right, data);}return root;}```3.删除节点删除二叉树中的节点可以分为三种情况：删除叶子节点、删除只有一个子节点的节点、删除有两个子节点的节点。
简单二叉树的构建代码
简单二叉树的构建代码二叉树的构建包括创建二叉树的根节点、添加节点到二叉树、删除二叉树中的节点等操作。
下面是一个简单二叉树的构建代码：```class Node:def __init__(self, data):self.left = Noneself.right = Noneself.data = dataclass BinaryTree:def __init__(self):self.root = Nonedef add_node(self, data):new_node = Node(data)if self.root is None:self.root = new_nodeelse:current = self.rootwhile True:if data < current.data:if current.left is None:current.left = new_node breakelse:current = current.left else:if current.right is None:current.right = new_node breakelse:current = current.right def delete_node(self, data):if self.root is None:return Noneelif self.root.data == data:if self.root.left is None and self.root.right is None:self.root = Noneelif self.root.left is None:self.root = self.root.rightelif self.root.right is None:self.root = self.root.leftelse:parent = self.rootcurrent = self.root.leftwhile current.right is not None:parent = currentcurrent = current.rightself.root.data = current.dataif parent == self.root:parent.left = current.leftelse:parent.right = current.leftelse:parent = Nonecurrent = self.rootwhile current is not None and current.data != data:if data < current.data:parent = currentcurrent = current.leftelse:parent = currentcurrent = current.rightif current is None:return Noneelif current.left is None and current.right is None:if parent.left == current:parent.left = Noneelse:parent.right = Noneelif current.left is None:if parent.left == current:parent.left = current.rightelse:parent.right = current.rightelif current.right is None:if parent.left == current:parent.left = current.leftelse:parent.right = current.leftelse:temp_parent = currenttemp_node = current.leftwhile temp_node.right is not None:temp_parent = temp_nodetemp_node = temp_node.rightcurrent.data = temp_node.dataif temp_parent == current:temp_parent.left = temp_node.left else:temp_parent.right = temp_node.leftdef preorder_traversal(self, root):if root is not None:print(root.data)self.preorder_traversal(root.left)self.preorder_traversal(root.right)```上述代码中，我们定义了一个 `Node` 类，用于表示二叉树的节点；另外，我们定义了一个 `BinaryTree` 类，用于实现二叉树的操作。
c语言二叉树代码
c语言二叉树代码以下是一个简单的C语言二叉树代码，包括二叉树的创建、插入、遍历、删除等操作：```#include<stdio.h>#include<stdlib.h>//定义二叉树节点类型typedef struct node{int data;struct node *left;struct node *right;}Node;//创建二叉树Node* create_tree(){int value;printf('请输入节点的值（-1表示结束）：');scanf('%d', &value);if(value == -1){return NULL;}else{Node *p = (Node*)malloc(sizeof(Node));p->data = value;printf('请输入%d的左子节点：', value);p->left = create_tree();printf('请输入%d的右子节点：', value);p->right = create_tree();return p;}}//插入节点Node* insert_node(Node *root, int value){if(root == NULL){Node *p = (Node*)malloc(sizeof(Node));p->data = value;p->left = NULL;p->right = NULL;return p;}else if(value < root->data){root->left = insert_node(root->left, value);}else if(value > root->data){root->right = insert_node(root->right, value); }return root;}//先序遍历void preorder_traversal(Node *root){if(root != NULL){printf('%d ', root->data);preorder_traversal(root->left);preorder_traversal(root->right);}}//中序遍历void inorder_traversal(Node *root){if(root != NULL){inorder_traversal(root->left);printf('%d ', root->data);inorder_traversal(root->right);}}//后序遍历void postorder_traversal(Node *root){if(root != NULL){postorder_traversal(root->left);postorder_traversal(root->right);printf('%d ', root->data);}}//查找节点Node* search_node(Node *root, int value){ if(root == NULL){return NULL;}else if(root->data == value){return root;}else if(value < root->data){return search_node(root->left, value);}else{return search_node(root->right, value); }}//删除节点Node* delete_node(Node *root, int value){if(root == NULL){return NULL;}else if(value < root->data){root->left = delete_node(root->left, value); }else if(value > root->data){root->right = delete_node(root->right, value); }else{//情况一：被删除节点没有子节点if(root->left == NULL && root->right == NULL){ free(root);root = NULL;}//情况二：被删除节点只有一个子节点else if(root->left == NULL){Node *temp = root;root = root->right;free(temp);}else if(root->right == NULL){Node *temp = root;root = root->left;free(temp);}//情况三：被删除节点有两个子节点else{Node *temp = root->right;while(temp->left != NULL){temp = temp->left;}root->data = temp->data;root->right = delete_node(root->right, temp->data); }}return root;}//主函数int main(){Node *root = NULL;int choice, value;while(1){printf('请选择操作： ');printf('1.创建二叉树 ');printf('2.插入节点');printf('3.遍历二叉树 ');printf('4.查找节点');printf('5.删除节点');printf('6.退出程序');scanf('%d', &choice); switch(choice){case 1:root = create_tree(); break;case 2:printf('请输入要插入的节点值：');scanf('%d', &value);root = insert_node(root, value);break;case 3:printf('先序遍历：');preorder_traversal(root);printf('中序遍历：');inorder_traversal(root);printf('后序遍历：');postorder_traversal(root);printf('');break;case 4:printf('请输入要查找的节点值：');scanf('%d', &value);Node *result = search_node(root, value);if(result != NULL){printf('找到节点：%d', result->data);}else{printf('未找到节点：%d', value);}break;case 5:printf('请输入要删除的节点值：');scanf('%d', &value);root = delete_node(root, value); break;case 6:printf('程序已退出。
二叉树的创建c语言代码
以下是一个简单的C 语言代码示例，用于创建一个二叉树：#include <stdio.h>#include <stdlib.h>// 二叉树节点结构struct TreeNode {int data;struct TreeNode* left;struct TreeNode* right;};// 创建一个新的二叉树节点struct TreeNode* createNode(int data) {struct TreeNode* newNode = (struct TreeNode*)malloc(sizeof(struct TreeNode));newNode->data = data;newNode->left = NULL;newNode->right = NULL;return newNode;}// 将一个数据插入到二叉树中struct TreeNode* insert(struct TreeNode* root, int data) {if (root == NULL) {return createNode(data);} else {if (data <= root->data) {root->left = insert(root->left, data);} else {root->right = insert(root->right, data);}return root;}}// 中序遍历打印二叉树void inOrderTraversal(struct TreeNode* root) {if (root != NULL) {inOrderTraversal(root->left);printf("%d ", root->data);inOrderTraversal(root->right);}}int main() {struct TreeNode* root = NULL;root = insert(root, 10);insert(root, 5);insert(root, 15);insert(root, 8);insert(root, 3);printf("中序遍历结果：");inOrderTraversal(root);printf("\n");return 0;}在上面的示例中，我们定义了一个简单的二叉树结构，并编写了函数来创建节点、插入节点和中序遍历打印二叉树。
二叉树的创建与遍历代码
二叉树的创建与遍历代码一、概述二叉树是一种常用的数据结构，具有广泛的应用。
在计算机科学中，二叉树是一种非线性的数据结构，由一组称为节点的元素组成，每个节点最多可以有两个子节点。
创建和遍历二叉树是二叉树操作的关键。
二、二叉树的创建创建二叉树有多种方式，常见的有手动创建和通过遍历方式创建。
下面分别介绍这两种方式：2.1 手动创建二叉树手动创建二叉树是指根据实际需求，手动输入节点值和节点关系来构建二叉树。
以下为手动创建二叉树的步骤：1.定义二叉树节点结构，包含节点值和左右子节点指针。
2.创建根节点，并输入根节点的值。
3.根据实际需求，逐级输入左右子节点的值，并将其与父节点相连。
4.重复步骤3，直到所有节点都输入完毕。
手动创建二叉树的代码示例：class BinTreeNode:def __init__(self, value):self.value = valueself.left = Noneself.right = Nonedef build_binary_tree():root_value = input("请输入根节点的值：")root = BinTreeNode(root_value)nodes = [root] # 存储待连接的节点while nodes:parent = nodes.pop(0)left_value = input("请输入节点" + parent.value + "的左子节点的值（没有请输入None）：")if left_value != "None":left = BinTreeNode(left_value)parent.left = leftnodes.append(left)right_value = input("请输入节点" + parent.value + "的右子节点的值（没有请输入None）：")if right_value != "None":right = BinTreeNode(right_value)parent.right = rightnodes.append(right)return root# 创建二叉树root = build_binary_tree()2.2 遍历方式创建二叉树遍历方式创建二叉树是指通过遍历给定的序列（如前序遍历或层次遍历），逐个节点创建二叉树。
二叉树c语言的程序代码
# include "stdio.h"# include "stdlib.h"# include "malloc.h"typedef struct Node{char data; //定义根结点struct Node *lchild; //定义左子树struct Node *rchild; //定义右子树}Node,*BiTree;int JianShu(BiTree &T) { //构造二叉链表表示的二叉树T,按先序遍历输入二//叉树中结点的值(一个字符),空格字符表示空树.char e;T=(Node *)malloc(sizeof(Node)); //开辟一个以sizeof(Node)为单位的空间if(!T) //开辟失败exit (-2);fflush(stdin); //清空缓存scanf ("%c",&e);if(e==' ')T=NULL;else {T->data=e; // 生成根结点printf ("请输入%c的左孩子:",e);JianShu(T->lchild); // 构造左子树printf ("请输入%c的右孩子:",e);JianShu(T->rchild); // 构造右子树}return 1;}int DLR_P(BiTree &T) { //先序遍历打印二叉树中所有数据if (T!=NULL) { //非空二叉树printf ("%c ",T->data); //访问TDLR_P(T->lchild); //递归遍历左子树DLR_P(T->rchild); //递归遍历右子树}return 1;}int LDR_P(BiTree &T) { //中序遍历打印二叉树中所有数据if (T!=NULL) { //非空二叉树LDR_P(T->lchild); //递归遍历左子树printf ("%c ",T->data); //访问TLDR_P(T->rchild); //递归遍历右子树}return 1;}int LRD_P(BiTree &T) { //后序遍历打印二叉树中所有数据if (T!=NULL) { //非空二叉树LRD_P(T->lchild); //递归遍历左子树LRD_P(T->rchild); //递归遍历右子树printf ("%c ",T->data); //访问T}return 1;}int DLR_0(BiTree &T,int &s_0) { //用先序遍历求二叉树T中所有叶子总数if (T!=NULL) { //非空二叉树if(!T->lchild&&!T->rchild) { //判断该结点是否为叶子s_0++; //是叶子则计数并打印printf ("%c ",T->data);}DLR_0(T->lchild,s_0); //递归遍历左子树,直到叶子处DLR_0(T->rchild,s_0); //递归遍历右子树,直到叶子处}return s_0;}int DLR_1(BiTree &T,int &s_1) { //用先序遍历求二叉树T中所有1度结点总数if (T!=NULL) { //非空二叉树if(T->lchild&&!T->rchild) { //判断该结点是否为1度结点s_1++; //是1度结点则计数并打印printf ("%c ",T->data);}if(!T->lchild&&T->rchild) { //判断该结点是否为1度结点s_1++; //是1度结点则计数并打印printf ("%c ",T->data);}DLR_1(T->lchild,s_1); //递归遍历左子树,直到1度结点处DLR_1(T->rchild,s_1); //递归遍历右子树,直到1度结点处}return s_1;}int DLR_2(BiTree &T,int &s_2) { //用先序遍历求二叉树T中所有2度结点总数if (T!=NULL) { //非空二叉树if(T->lchild&&T->rchild) { //判断该结点是否为2度结点s_2++; //是2度结点则计数并打印printf ("%c ",T->data);}DLR_2(T->lchild,s_2); //递归遍历左子树,直到2度结点处DLR_2(T->rchild,s_2); //递归遍历右子树,直到2度结点处}return s_2;}int ShenDu(BiTree &T,int l,int &h) { //用递归求二叉树的深度if (T!=NULL) { //非空二叉树l=l+1;if (l>h) h=l;ShenDu(T->lchild,l,h); //递归遍历左子树ShenDu(T->rchild,l,h); //递归遍历右子树}return 1;}int QingKong(BiTree &T) { //清空二叉树if (T!=NULL) {QingKong(T->lchild); //遍历清空左子树free(T->lchild);QingKong(T->rchild); //遍历清空右子树free(T->rchild);}return 1;}int main () { //主函数int i,a=0;Node *T; //定义一个二叉树Twhile(1) {system("cls");printf("\t|===========================================================|\t\n");printf ("\t| |\t\n");printf ("\t| 二叉树的链式存储|\t\n");printf ("\t| |\t\n");printf("\t|===========================================================|\t\n");printf ("\n\t【1】建立二叉树及先序输入!\t 【2】遍历二叉树打印!\n");printf ("\n\t【3】打印各结点并统计! \t 【4】求二叉树的深度!\n");printf ("\n\t【5】清空二叉树!\t\t 【0】退出程序!\n");system("color F0");printf ("\n\n\t\t\t请输入你的选择:"); //输入选择的功能序号scanf ("%d",&i);switch(i) {case 1: //建立二叉树T并输入数据printf ("请输入二叉树T的根:");JianShu(T);a=1;system("pause");break;case 2: //遍历打印二叉树中所有数据if(a==1) {if(T!=NULL) { //非空二叉树Tprintf ("先序遍历打印结果:"); //执行先序遍历并打印DLR_P(T);printf ("\n\n中序遍历打印结果:"); //执行中序遍历并打印LDR_P(T);printf ("\n\n后序遍历打印结果:"); //执行后序遍历并打印LRD_P(T);printf ("\n");}elseprintf ("二叉树T为空树!\n");}else //未建立二叉树printf ("未建立二叉树!\n");system("pause");break;case 3: //先序遍历打印二叉树中0度1度2度结点if(a==1) {if(T!=NULL) { //非空二叉树Tint s_0=0,s_1=0,s_2=0;printf ("二叉树中叶子:");DLR_0(T,s_0); //执行先序遍历打印叶子并统计printf ("共有%d个叶子!\n",s_0);printf ("\n二叉树中1度结点:");DLR_1(T,s_1); //执行先序遍历打印1度结点并统计printf ("共有%d个1度结点!\n",s_1);printf ("\n二叉树中2度结点:");DLR_2(T,s_2); //执行先序遍历打印2度结点并统计printf ("共有%d个2度结点!\n",s_2);}elseprintf ("二叉树T为空树!\n");}else //未建立二叉树printf ("未建立二叉树!\n");system("pause");break;case 4: //用递归求二叉树的深度if(a==1) {if(T!=NULL) { //非空二叉树Tint l=0,h=0;ShenDu(T,l,h);printf ("二叉树的深度为%d.\n",h);}elseprintf ("二叉树T为空树!\n");}else //未建立二叉树printf ("未建立二叉树!\n");system("pause");break;case 5: //清空二叉树if(a==1) {if(T!=NULL) { //非空二叉树QingKong(T); //清空二叉树T=NULL;printf ("二叉树已清空!\n");}elseprintf ("二叉树T为空树,既不用清空!\n");}else //未建立二叉树printf ("未建立二叉树,既不用清空!\n");system("pause");break;case 0: //退出程序printf ("退出程序!\n");return 1;default: //重新输入选择的功能序号printf ("输入有误,请重新输入!\n");system("pause");break;}}}。
二叉树的建立和遍历及常见二叉树运算源码
二叉树的建立和遍历及常见二叉树运算源码#include"stdio.h"#include"malloc.h"typedef int status;typedef char TElemType;typedef int Status;int max(int m, int n);#define OK 1;typedef struct BiT ode{TElemType data;struct BiTode *Lchild,*Rchild;}BiTNode,*BiTree;void init(BiTree &T);//构建空二叉树Status CreateBiTree(BiTree &T);//先序建立二叉树void preorder(BiTNode *root);//先序遍历void visit (BiTNode *root);//输出某个节点的值void leaf_number(BiTNode *root);//求叶子节点的个数int TreeHeight(BiTNode *root);//求二叉树高度void DestroyTree(BiTree &T);//销毁二叉树void swap(BiTree &root);// 交换左右子树int n = 0;int main(void)int m;char l;int g;BiTree T;printf("1:构建空二叉树\n");printf("2:先序建立二叉树\n");printf("3:先序遍历二叉树\n");printf("4:求叶子节点的个数\n");printf("5:求二叉树高度\n");printf("6:销毁二叉树\n");do{scanf("%d",&m);switch(m){case 1: init(T); break;case 2: CreateBiTree(T);break;case 3: preorder(T);printf("\n");break;case 4: leaf_number(T);printf("叶子节点的个数为%d\n",n);break;case 5: g=TreeHeight(T);printf("二叉树的高度为%d\n",g);break;case 6: DestroyTree(T);break;default :printf("输入有误！");break;}printf("是否继续(y/n)\n");scanf("%s",&l);if(l=='y' || l=='Y')printf("请选择功能:");elseprintf("程序退出!");}while(l=='y' || l=='Y');return 0;}Status CreateBiTree(BiTree &T){ /* 按先序次序输入二叉树中结点的值*/char ch;scanf("%s",&ch);if(ch=='-') /* 空 */T=NULL;else{T=(BiTree)malloc(sizeof(BiTNode)); /* 生成根结点 */ // if(!T)// exit(OVERFLOW);T->data=ch;CreateBiTree(T->Lchild ); /* 构造左子树 */ CreateBiTree(T->Rchild ); /* 构造右子树 */}return OK;void init(BiTree &T){T = NULL;}void preorder(BiTNode *root){if (root!=NULL) {printf("%c",root->data);//访问根结点preorder(root->Lchild); //先序遍历根的左子树preorder(root->Rchild); //先序遍历根的右子树}//if}//inordervoid visit (BiTNode *root){printf("%c\n",root->data );}void leaf_number(BiTNode *root){if (root!=NULL){if(root->Lchild == NULL && root->Rchild == NULL) n++;elseleaf_number(root->Lchild);leaf_number(root->Rchild);}}}int max(int m, int n){if (m > n)return m;elsereturn n;}int TreeHeight(BiTNode *root){if (root == NULL)return 0;elsereturn 1 + max(TreeHeight(root->Lchild), TreeHeight(root->Rchild));}void DestroyTree(BiTree &root){if (root == NULL)return ;else {DestroyTree(root->Lchild);DestroyTree(root->Rchild);free(root);root = NULL;}}void swap(BiTree &root) {if (root){BiTree p;p= root->Lchild;root->Lchild=root->Rchild; root->Rchild=p;swap(root->Lchild);swap(root->Rchild);}}。
二叉树的创建与遍历代码
二叉树的创建与遍历代码本文将为大家讲解二叉树的创建与遍历，并提供详细的代码实现和指导意义。
二叉树的创建二叉树是由节点和边组成的树状结构，每个节点最多可以有两个子节点。
二叉树可以为空，或者由根节点和其它节点构成。
在创建二叉树时，我们可以使用递归方法，先创建根节点，然后再在根节点下创建左右子树。
递归过程中，每个节点的左右子树也是一个二叉树。
下面是二叉树创建代码的实现：```class Node:def __init__(self, val):self.val = valself.left = Noneself.right = Nonedef create_tree(nums):if not nums:return Nonemid = len(nums)//2root = Node(nums[mid])root.left = create_tree(nums[:mid])root.right = create_tree(nums[mid+1:])return root```代码中的`Node`类表示二叉树的节点，节点包括值、左子树和右子树三个属性。
`create_tree`函数是一个递归函数，传入一个列表，根据列表元素的顺序构建出一棵二叉平衡树。
二叉树的遍历在二叉树中，我们可以按照根节点、左子树和右子树的顺序遍历整棵树，这被称为前序遍历。
按照左子树、根节点和右子树的顺序遍历整棵树，被称为中序遍历。
按照左子树、右子树和根节点的顺序遍历整棵树，被称为后序遍历。
遍历时，我们可以通过递归函数访问每个节点。
下面是二叉树遍历的代码实现：```def pre_order(node):if not node:returnprint(node.val)pre_order(node.left) pre_order(node.right) def in_order(node):if not node:returnin_order(node.left)print(node.val)in_order(node.right) def post_order(node):if not node:returnpost_order(node.left) post_order(node.right) print(node.val)```代码中的`pre_order`函数实现了前序遍历，它首先输出根节点的值，然后依次遍历左子树和右子树。
二叉树程序设计
二叉树程序设计二叉树（Binary Tree）是一种树状数据结构，其中每个节点最多有两个子节点，分别为左子节点和右子节点。
在程序设计中，涉及到二叉树的问题通常包括二叉树的构建、遍历、搜索等方面。
以下是一些常见的二叉树程序设计问题和相关的代码示例：1. 二叉树节点定义：class TreeNode:def __init__(self, value):self.value = valueself.left = Noneself.right = None2. 二叉树的构建：递归方式：def build_tree(preorder, inorder):if not preorder or not inorder:return Noneroot_value = preorder[0]root = TreeNode(root_value)root_index = inorder.index(root_value)root.left = build_tree(preorder[1:1 + root_index], inorder[:root_index])root.right = build_tree(preorder[1 + root_index:], inorder[root_index + 1:])3. 二叉树的遍历：前序遍历：def preorder_traversal(root):if root:print(root.value, end=" ") preorder_traversal(root.left) preorder_traversal(root.right)中序遍历：def inorder_traversal(root):if root:inorder_traversal(root.left)print(root.value, end=" ") inorder_traversal(root.right)后序遍历：def postorder_traversal(root):if root:postorder_traversal(root.left) postorder_traversal(root.right) print(root.value, end=" ")4. 二叉树的搜索：递归方式：def search_in_tree(root, target):return Noneif root.value == target:return rootleft_search = search_in_tree(root.left, target)right_search = search_in_tree(root.right, target)return left_search if left_search else right_search这些是一些基本的二叉树程序设计问题的示例。
数据结构二叉树程序代码
数据结构⼆叉树程序代码#include#include#define STACK_INIT_SIZE 100#define STACKINCREMENT 10#define MAX_TREE_SIZE 100//⼆叉树的最⼤结点#define TRUE 1#define FALSE 0#define OVERFLOW -2#define telemtype char#define selemtype chartypedef telemtype sqbitree[MAX_TREE_SIZE];//0号单元储存根结点sqbitree bt;typedef struct bitnode{telemtype data;struct bitnode *lchild,*rchild;}bitnode,*bitree;bitree T;typedef struct{bitree *base;bitree *top;int stacksize;}sqstack;sqstack s;void menu();//菜单void initstack(sqstack &s);//初始化void clearstack(sqstack &s);//置空栈void push(sqstack &s,bitnode e);//⼊栈void pop(sqstack &s,bitnode e);//出栈void gettop(sqstack &s);//取栈顶元素int stackempty(sqstack s);//判断栈是否为空void createbitree(bitree &T);//创建树void traversetree(bitree T);//遍历树void preordertraverse(bitree T);//先序遍历void inordertraverse(bitree T);//中序遍历void postordertraverse(bitree T);//后序遍历int treedepth(bitree T);//求树深度void treenature(bitree T);//---------------------主函数----------------------void main(){int a;initstack(s);for(;;){menu();printf("请输⼊要操作的数字\n");scanf("%d",&a);switch(a){case 1:createbitree(T);break;case 2:traversetree(T);break;case 3:treenature(T);break;case 4:exit(0);break;default:printf("please input a number again!");}}}//---------------------⼦函数----------------------------void menu()//菜单{printf("************菜单*************\n");printf("********1、树的创建*********\n");printf("********2、树的遍历*********\n");printf("********3、树的属性*********\n");printf("********4、退出*********\n");}void initstack(sqstack &s)//初始化{s.base=(bitree*)malloc(STACK_INIT_SIZE*sizeof(bitree));if(!s.base)exit(OVERFLOW);s.top=s.base;s.stacksize=STACK_INIT_SIZE;}void clearstack(sqstack &s)//置空栈{s.top=s.base;}void push(sqstack &s,bitree e)//⼊栈{if(s.top-s.base>=s.stacksize){s.base=(bitree*)realloc(s.base,(s.stacksize+STACKINCREMENT)*sizeof(bitree)); if(!s.base)exit(OVERFLOW);s.top=s.base+s.stacksize;s.stacksize+=STACKINCREMENT;}*s.top++=e;}void pop(sqstack &s,bitree &e)//出栈{if(s.top==s.base)printf("栈为空!\n");e=*--s.top;}void gettop(sqstack &s,bitree &e)//取栈顶元素{if(s.top==s.base)printf("栈为空!\n");e=*(s.top-1);}int stackempty(sqstack s)//判断栈为空{if(s.top==s.base)return TRUE;else return FALSE;}void createbitree(bitree &T)//创建树{telemtype ch;telemtype a;a=getchar();scanf("%c",&ch);if(ch=='#')T=NULL;else{if(!(T=(bitnode*)malloc(sizeof(bitnode))))exit(OVERFLOW);T->data=ch;createbitree(T->lchild);createbitree(T->rchild);}}void traversetree(bitree T)//遍历树{int n,i;for(i=0;i<4;i++){printf("************树的遍历************\n");printf("**********1、先序遍历***********\n"); printf("**********2、中序遍历***********\n"); printf("**********3、后序遍历***********\n"); printf("**********4、退出应⽤***********\n"); scanf("%d",&n);switch(n){case 1:preordertraverse(T);break;case 2:inordertraverse(T);break;case 3:postordertraverse(T);break;case 4:printf("树的遍历已退出!\n");break; default:printf("输⼊有误，请重新输⼊!\n");}}}/*void preordertraverse(bitree T)//递归先序遍历{if(T){printf("%c",T->data);preordertraverse(T->lchild); preordertraverse(T->rchild);}printf("\n");}*/void preordertraverse(bitree T)//⾮递归先序遍历{sqstack s;initstack(s);bitree p;p=T;while(p||!stackempty(s)){if(p){printf("%c",p->data);p=p->lchild;}else p=p->rchild;}printf("\n");}/*void inordertraverse(bitree T)//递归中序遍历{if(T){inordertraverse(T->lchild);printf("%c",T->data);inordertraverse(T->rchild);printf("\n");}}*/void inordertraverse(bitree T)//⾮递归中序遍历{sqstack s;initstack(s);bitree p;p=T;while(p||!stackempty(s)){if(p){ push(s,p);p=p->lchild;}else{pop(s,p);printf("%c",p->data);p=p->rchild;}}printf("\n");}/*void postordertraverse(bitree T)//递归后序遍历{if(T){postordertraverse(T->lchild); postordertraverse(T->rchild);printf("%c",T->data);printf("\n");}}*/void postordertraverse(bitree T)//⾮递归后序遍历{bitree p;initstack(s);p = T;int tag;while(p||!stackempty(s)){if(p){push(s,p);tag=0;p = p->lchild;}else{if(tag==1){pop(s,p);printf("%c",p->data);p = NULL;}else{gettop(s,p);tag=1;p = p->rchild;}}}printf("\n");}int treedepth(bitree T)//求树深度{int depthall,depthl,depthr;if(!T)depthall = 0;else{depthl=treedepth(T->lchild);depthr=treedepth(T->rchild);depthall=(depthl > depthr ? depthl:depthr)+1;}//printf("树的深度为：%d\n",depthall);return depthall;}void treenature(bitree T)//树的结点数，叶⼦数，⼀度结点数，树的深度等属性。
c语言二叉树代码
c语言二叉树代码对于c语言的二叉树代码，我们可以先了解一下二叉树的性质。
二叉树是一种树形结构，每个节点最多有两个子节点。
根据二叉树的性质，我们可以定义一个结构体来表示二叉树的节点。
struct TreeNode {int val; // 节点的值struct TreeNode *left; // 左子节点struct TreeNode *right; // 右子节点};接下来就是实现二叉树的增删改查：1. 增加节点void addNode(struct TreeNode **node, int val) {if (*node == NULL) {struct TreeNode *newNode = (structTreeNode*)malloc(sizeof(struct TreeNode));newNode->val = val;newNode->left = NULL;newNode->right = NULL;*node = newNode;} else {if (val < (*node)->val) {addNode(&((*node)->left), val);} else {addNode(&((*node)->right), val);}}}2. 删除节点void deleteNode(struct TreeNode **node, int val) {if (*node == NULL) {return;}if ((*node)->val == val) {if ((*node)->left != NULL && (*node)->right != NULL) { struct TreeNode *minNode = (*node)->right;while (minNode->left != NULL) {minNode = minNode->left;}(*node)->val = minNode->val;deleteNode(&((*node)->right), minNode->val);} else {struct TreeNode *temp = *node;if ((*node)->left != NULL) {*node = (*node)->left;} else {*node = (*node)->right;}free(temp);}} else if (val < (*node)->val) {deleteNode(&((*node)->left), val);} else {deleteNode(&((*node)->right), val);}}3. 查找节点struct TreeNode* searchNode(struct TreeNode* node, int val) { if (node == NULL) {return NULL;}if (node->val == val) {return node;} else if (val < node->val) {return searchNode(node->left, val);} else {return searchNode(node->right, val);}}以上就是c语言实现二叉树的基本代码。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <string.h>
typedef char elemtype;
typedef struct tree //二叉树结构体
{
elemtype data;
struct tree *lchild;
struct tree *rchild;
}TREE;
TREE *createbitree() //递归建立二叉树{
char ch;
TREE *p;
ch=getchar();
if (ch=='#')
p=NULL;
else
{
p=(TREE *)malloc(sizeof(TREE));
p->data=ch;
p->lchild=createbitree();
p->rchild=createbitree();
}
return p;
}
void preorder(TREE *p) //前序遍历
{
if(p!=NULL)
{
printf("%c ",p->data);
preorder(p->lchild);
preorder(p->rchild);
}
}
void inorder(TREE *p) //中序遍历
{
if (p!=NULL)
{
inorder(p->lchild);
printf("%c ",p->data);
inorder(p->rchild);
}
}
void postorder(TREE *p) //后序遍历
{
if (p!=NULL)
{
postorder(p->lchild);
postorder(p->rchild);
printf("%c ",p->data);
}
}
void shu(TREE *p,int len) //数的形状{
if (p!=NULL)
{
shu(p->lchild,len+1);
for (int i=1;i<=4*len;i++)
{
printf(" ");
}
printf("%c",p->data);
printf("------\n");
shu(p->rchild,len+1);
}
}
int shendu(TREE *p) //计算深度
{
int l,r;
if (p==NULL)
{
return 0;
}
l=shendu(p->lchild)+1;
r=shendu(p->rchild)+1;
if (l>=r) //左右子树比较return l;
else
return r;
}
int dianshu(TREE *p) //计算结点数
{
int s;
if (p==NULL)
{
return 0;
}
s=dianshu(p->lchild)+dianshu(p->rchild)+1;
return s;
}
void jiemian() //操作界面
{
printf("请选择功能:\n");
printf("=========================\n");
printf("* 1.看看我建立的树\n");
printf("* 2.看看它的深度和叶子结点数\n");
printf("* 3.前、中、后序遍历\n");
printf("* 4.结束····\n");
printf("=========================\n");
printf("请选择：\n");
}
void main()
{
TREE *p;
int len=0,c,flag=1,i=0,s,a;
printf("实验3 二叉树的建立及其应用：\n");
printf("\n");
printf("请输入结点元素，输入#表示空（按前序输入）：\n");
p=createbitree();
while (flag) //循环
{
jiemian();
scanf("%d",&c);
switch (c)
{
case 1:
printf("数的形状：\n");
shu(p,len);
getch();
system("CLS");
break;
case 2:
printf("此树的深度：\n");
s=shendu(p);
printf("%d\n",s);
printf("\n");
printf("此树的结点数：\n");
a=dianshu(p);
printf("%d\n",a);
printf("\n");
printf("数的形状：\n");
shu(p,len);
getch();
system("CLS");
break;
case 3:
printf("前序遍历结果：\n");
printf("\n");
preorder(p);
printf("\n");
printf("\n");
printf("中序遍历结果：\n");
printf("\n");
inorder(p);
printf("\n");
printf("\n");
printf("后序遍历结果：\n");
printf("\n");
postorder(p);
printf("\n");
printf("\n");
getch();
system("CLS");
break;
default:
flag=0;
exit(0);
break;
}
}
}。