C语言课程设计_二叉树演示源程序

合集下载

数据结构c语言课设-二叉树排序

数据结构c语言课设-二叉树排序

题目:二叉排序树的实现1 内容和要求1)编程实现二叉排序树,包括生成、插入,删除;2)对二叉排序树进展先根、中根、和后根非递归遍历;3)每次对树的修改操作和遍历操作的显示结果都需要在屏幕上用树的形状表示出来。

4)分别用二叉排序树和数组去存储一个班(50 人以上)的成员信息(至少包括学号、姓名、成绩3 项),比照查找效率,并说明在什么情况下二叉排序树效率高,为什么?2 解决方案和关键代码2.1 解决方案:先实现二叉排序树的生成、插入、删除,编写DisplayBST函数把遍历结果用树的形状表示出来。

前中后根遍历需要用到栈的数据构造,分模块编写栈与遍历代码。

要求比照二叉排序树和数组的查找效率,首先建立一个数组存储一个班的成员信息,分别用二叉树和数组查找,利用clock〔〕函数记录查找时间来比照查找效率。

2.2关键代码树的根本构造定义及根本函数typedef struct{KeyType key;} ElemType;typedef struct BiTNode//定义链表{ElemType data;struct BiTNode *lchild, *rchild;}BiTNode, *BiTree, *SElemType;//销毁树int DestroyBiTree(BiTree &T){if (T != NULL)free(T);return 0;}//清空树int ClearBiTree(BiTree &T){if (T != NULL){T->lchild = NULL;T->rchild = NULL;T = NULL;}return 0;}//查找关键字,指针p返回int SearchBST(BiTree T, KeyType key, BiTree f, BiTree &p) {if (!T){p = f;return FALSE;}else if EQ(key, T->data.key){p = T;return TRUE;}else if LT(key, T->data.key)return SearchBST(T->lchild, key, T, p);elsereturn SearchBST(T->rchild, key, T, p);}二叉树的生成、插入,删除生成void CreateBST(BiTree &BT, BiTree p){int i;ElemType k;printf("请输入元素值以创立排序二叉树:\n");scanf_s("%d", &k.key);for (i = 0; k.key != NULL; i++){//判断是否重复if (!SearchBST(BT, k.key, NULL, p)){InsertBST(BT, k);scanf_s("%d", &k.key);}else{printf("输入数据重复!\n");return;}}}插入int InsertBST(BiTree &T, ElemType e){BiTree s, p;if (!SearchBST(T, e.key, NULL, p)){s = (BiTree)malloc(sizeof(BiTNode));s->data = e;s->lchild = s->rchild = NULL;if (!p)T = s;else if LT(e.key, p->data.key)p->lchild = s;elsep->rchild = s;return TRUE;}else return FALSE;}删除//某个节点元素的删除int DeleteEle(BiTree &p){BiTree q, s;if (!p->rchild) //右子树为空{q = p;p = p->lchild;free(q);}else if (!p->lchild) //左子树为空{q = p;p = p->rchild;free(q);}else{q = p;s = p->lchild;while (s->rchild){q = s;s = s->rchild;}p->data = s->data;if (q != p)q->rchild = s->lchild;elseq->lchild = s->lchild;delete s;}return TRUE;}//整棵树的删除int DeleteBST(BiTree &T, KeyType key) //实现二叉排序树的删除操作{if (!T){return FALSE;}else{if (EQ(key, T->data.key)) //是否相等return DeleteEle(T);else if (LT(key, T->data.key)) //是否小于return DeleteBST(T->lchild, key);elsereturn DeleteBST(T->rchild, key);}return 0;}二叉树的前中后根遍历栈的定义typedef struct{SElemType *base;SElemType *top;int stacksize;}SqStack;int InitStack(SqStack &S) //构造空栈{S.base = (SElemType*)malloc(STACK_INIT_SIZE *sizeof(SElemType));if (!S.base) exit(OVERFLOW);S.top = S.base;S.stacksize = STACK_INIT_SIZE;return OK;}//InitStackint Push(SqStack &S, SElemType e) //插入元素e为新栈顶{if (S.top - S.base >= S.stacksize){S.base = (SElemType*)realloc(S.base, (S.stacksize + STACKINCREMENT)*sizeof(SElemType));if (!S.base) exit(OVERFLOW);S.top = S.base + S.stacksize;S.stacksize += STACKINCREMENT;}*S.top++ = e;return OK;}//Pushint Pop(SqStack &S, SElemType &e) //删除栈顶,应用e返回其值{if (S.top == S.base) return ERROR;e = *--S.top;return OK;}//Popint StackEmpty(SqStack S) //判断是否为空栈{if (S.base == S.top) return TRUE;return FALSE;}先根遍历int PreOrderTraverse(BiTree T, int(*Visit)(ElemType e)) {SqStack S;BiTree p;InitStack(S);p = T;while (p || !StackEmpty(S)){if (p){Push(S, p);if (!Visit(p->data)) return ERROR;p = p->lchild;}else{Pop(S, p);p = p->rchild;}}return OK;}中根遍历int InOrderTraverse(BiTree T, int(*Visit)(ElemType e)) {SqStack S;BiTree p;InitStack(S);p = T;while (p || !StackEmpty(S)){if (p){Push(S, p);p = p->lchild;}else{Pop(S, p);if (!Visit(p->data)) return ERROR;p = p->rchild;}}return OK;}后根遍历int PostOrderTraverse(BiTree T, int(*Visit)(ElemType e)) {SqStack S, SS;BiTree p;InitStack(S);InitStack(SS);p = T;while (p || !StackEmpty(S)){if (p){Push(S, p);Push(SS, p);p = p->rchild;}else{if (!StackEmpty(S)){Pop(S, p);p = p->lchild;}}}while (!StackEmpty(SS)){Pop(SS, p);if (!Visit(p->data)) return ERROR;}return OK;}利用数组存储一个班学生信息ElemType a[] = { 51, "陈继真", 88,82, "黄景元", 89,53, "贾成", 88,44, "呼颜", 90,25, "鲁修德", 88,56, "须成", 88,47, "孙祥", 87, 38, "柏有患", 89, 9, " 革高", 89, 10, "考鬲", 87, 31, "李燧", 86, 12, "夏祥", 89, 53, "余惠", 84, 4, "鲁芝", 90, 75, "黄丙庆", 88, 16, "李应", 89, 87, "杨志", 86, 18, "李逵", 89, 9, "阮小五", 85, 20, "史进", 88, 21, "秦明", 88, 82, "杨雄", 89, 23, "刘唐", 85, 64, "武松", 88, 25, "李俊", 88, 86, "卢俊义", 88, 27, "华荣", 87, 28, "杨胜", 88, 29, "林冲", 89, 70, "李跃", 85, 31, "蓝虎", 90, 32, "宋禄", 84, 73, "鲁智深", 89, 34, "关斌", 90, 55, "龚成", 87, 36, "黄乌", 87, 57, "孔道灵", 87, 38, "张焕", 84, 59, "李信", 88, 30, "徐山", 83, 41, "秦祥", 85, 42, "葛公", 85, 23, "武衍公", 87, 94, "范斌", 83, 45, "黄乌", 60, 67, "叶景昌", 99, 7, "焦龙", 89, 78, "星姚烨", 85, 49, "孙吉", 90, 60, "陈梦庚", 95,};数组查询函数void ArraySearch(ElemType a[], int key, int length){int i;for (i = 0; i <= length; i++){if (key == a[i].key){cout << "学号:" << a[i].key << " 姓名:" << a[i].name << " 成绩:" << a[i].grade << endl;break;}}}二叉树查询函数上文二叉树根本函数中的SearchBST()即为二叉树查询函数。

二叉树的建立与遍历实验报告(c语言编写,附源代码)

二叉树的建立与遍历实验报告(c语言编写,附源代码)

二叉树的建立与遍历实验报告(c语言编写,附源代码)二叉树的建立与遍历实验报告级班年月日姓名学号_1.实验题目建立一棵二叉树,并对其进行遍历(先序、中序、后序),打印输出遍历结果。

2.需求分析本程序用VC编写,实现建立一棵二叉树的功能,并对其进行遍历(先序、中序、后序),并且打印输出遍历结果。

①输入的形式和输入值的范围:输入二叉树的先序,当其结点为空时,需要输入#。

(输入的先序仅含字母和#)②输出的形式:输出二叉树的先序、中序、后序。

③程序所能达到的功能:实现建立一棵二叉树的功能,并对其进行遍历(先序、中序、后序),并且打印输出遍历结果。

④测试数据:输入数据:输入ABC##DE#G##F###输出结果:二叉树的先序遍历为:ABCDEGF二叉树的中序遍历为:CBEGDFA二叉树的后序遍历为:CGEFDBA3.概要设计1)为了实现上述程序功能,需要定义二叉链表的抽象数据类型:typedef struct BinaryTreeNode{TElemType data;//二叉树结点中的数据域struct BinaryTreeNode *lchild , *rchild; //二叉树结点的左孩子和右孩子指针}BinaryTreeNode ,*BiTree;基本操作:A.void CreateBinaryTree (BiTree &T)初始条件:无操作结果:建立了二叉树。

B. void PreOrder(BiTree T)初始条件:存在一棵二叉树操作结果:先序遍历二叉树,并且输出先序遍历的结果。

C. void MidOrder(BiTree T)初始条件:存在一棵二叉树操作结果:中序遍历二叉树,并且输出中序遍历的结果。

D. void PostOrder(BiTree T)初始条件:存在一棵二叉树操作结果:后序遍历二叉树,并且输出后序遍历的结果。

程序包含5个函数:○1主函数main()○2先序建立二叉树 void CreateBinaryTree (BiTree &T)○3先序遍历二叉树,并且输出先序遍历的结果void PreOrder(BiTree T);○4中序遍历二叉树,并且输出中序遍历的结果void MidOrder(BiTree T);○5序遍历二叉树,并且输出后序遍历的结果void PostOrder(BiTree T); 各函数间关系如下:主函数main()CreateBinaryTree PreOrder MidOrder PostOrder4.详细设计1)二叉链表的定义typedef struct BinaryTreeNode{定义一个树结点的数据域;定义一个该结点的左孩子指针和右孩子指针;}2)void CreateBinaryTree (BiTree &T)//先序建立二叉树{输入一个字符量;if(输入字符== '#') T指针置值为NULL;else{动态申请一个指向二叉树结构体的指针把输入字符赋值给新指针的数据域data;调用CreateBinaryTree(新指针的lchild成员);调用CreateBinaryTree(新指针的rchild成员);}}3)void PreOrder(BiTree T) //先序遍历二叉树{if(T指针不为NULL){输出T的data域;先序遍历左子树;先序遍历右子树;}}4)void MidOrder(BiTree T) //中序遍历二叉树{if(T指针不为NULL){中序遍历左子树;输出T的data域;中序遍历右子树;}}5)void PostOrder(BiTree T) //中序遍历二叉树{if(T指针不为NULL){后序遍历左子树;后序遍历右子树;输出T的data域;}}5.调试分析在编写程序过程中,我将scanf(”%c”,&ch)中的%c写成%d,程序运行了一段时间没有结果,经过检查,发现了这个错误。

二叉树课程设计

二叉树课程设计
PreOrder(T->Rlink);
}
}
//ÖÐÐò±éÀú¶þ²æÊ÷
void InOrder(btreetype T)
{
if(T){
InOrder(T->Llink);
printf("%c",T->Data);
InOrder(T->Rlink);
}
}
//ºóÐò±éÀú¶þ²æÊ÷
void PostOrder(btreetype T){
btreetype T;
InitBiTree(T);
CreatBiTree(T);
printf("À¨ºÅ±íʾ·¨Êä³ö¶þ²æÊ÷:\n");
DispBiTree(T);
printf("\n");
LeftChild(T,'H');
RightChild(T,'H');
m=LeafPoint(T);printf("ÓÐ%d¸öÒ¶×Ó½áµã\n",m);
if(T){
PostOrder(T->Llink);
PostOrder(T->Rlink);
printf("%c",T->Data);
}
}
void main()
{timeb t1,t2;ftime(&t1);
long t;int m,n;
printf("ÃâÔðÉùÃ÷£º\n\tÓÉÓÚ±¾È˵çÄÔϵµÂÓïÊäÈë·¨£¬ÎÞ·¨ÔÚÔËÐÐʱÊäÈë'#'×Ö·ûºÅ£¬¹Ê¸ÄΪ¿Õ¸ñ´úÌæ\n");

C语言实现一.二叉树操作 二.用栈实现算术表达式求值 课设报告

C语言实现一.二叉树操作 二.用栈实现算术表达式求值  课设报告
沈阳理工大学
沈阳理工大学课程设计专用纸
No. 1
题目 一.二叉树操作(1)二.算术表达式求
一、课程设计的目的
本学期我们对《数据结构》这门课程进行了学习。这门课程是一门实践性非常强的 课程,为了让大家更好地理解与运用所学知识,提高动手能力,我们进行了此次课程设 计实习。这次课程设计不但要求学生掌握《数据结构》中的各方面知识,还要求学生具 备一定的 C 语言基础和编程能力。
{ int k; char *temp; if(len<=0) { *T=NULL;
沈阳理工大学
沈阳理工大学课程设计专用纸
No. 5
return; } *T=(BitNode*)malloc(sizeof(BitNode)); (*T)->data=*pre; for(temp=in;temp<in+len;temp++)
int h,lh,rh; if(T==NULL)
h=0; else {
lh=Depth(T->lchild); rh=Depth(T->rchild); if(lh>=rh)
h=lh+1; else
h=rh+1; } return h; }
沈阳理工大学
沈阳理工大学课程设计专用纸
No. 6
4、运行结果 先输入一棵树的先序遍历序列和中序遍历序列,然后构造出这颗二叉树,并输
(2)题目二的内容和要求: 1、算术表达式由操作数、运算符和界限符组成。操作数是正整数,运算符为 加减乘除,界限符有左右括号和表达式起始 2、将一个表达式的中缀形式转化为相应的后缀形式 3、依据后缀表达式计算表达式的值
沈阳理工大学
沈阳理工大学课程设计专用纸

c++课程设计报告(二叉树运算)

c++课程设计报告(二叉树运算)

课程设计报告设计题目:二叉树解决四则运算问题院系:自动化院班级:XXX学号:XXX姓名:XX指导老师:XX时间:XX一.程序功能简介利用二叉树的结构解决带括号的四则运算的问题。

程序利用二叉树的堆栈将二叉树的结点变成结点中的数据时运算符,左右子树是标准结点形式,或是另外的标准二叉树形式,通过后序遍历,经标准结点中的表达式求出。

二.课程设计要求(1)读懂程序,将程序的运算步骤完整的描述出来。

(2)四则运算的表达式可以接受空格输入(3)依照运算顺序依次输出四则运算每一步的算式及及结果,最后输出最终计算结果三.课程设计思想这个课题设计要求最关键的就是读懂程序,用类实现四则运算其实不是很难,只是利用二叉树实现带括号的四则运算有些难度。

初读源程序觉得摸不到头脑,几遍下来还是能够理解的。

在程序中先计算的式子放在栈顶,首先赋值右子树,再赋值左子树,保证优先级。

如图:二叉树类栈运算符栈)—* (+输入“+”,“(”,“*”三个运算符没有优先级冲突,按顺序压栈,然后输入“—”,优先级低于“*”,binary_tree temp_tree; //生成二叉树string thisstring="";thisstring = thisstring + OpStack.top();OpStack.pop() //将栈顶优先级高的运算符移除(即这边的乘号)etree.root = build_node(thisstring);//将优先级高的运算符作为二叉树的根结点copy(temp_tree.root,NodeStack.top().root);//将二叉树堆栈栈顶的二叉树复制到新生成的二叉树中(即把1复制到新的二叉树中)NodeStack.pop();//移除二叉树栈栈顶etree.root->right_child = temp_tree.root;//将二叉树作为新二叉树的右分支temp_tree.root = NULL;copy(temp_tree.root,NodeStack.top().root); //继续将下一个栈顶二叉树复制(即把5复制)etree.root->left_child = temp_tree.root;//成为新二叉树的左分支NodeStack.pop();//移除temp_tree.root = NULL;copy(temp_tree.root, etree.root);NodeStack.push(temp_tree);//新二叉树进栈etree.root = NULL;OpStack.push(c);//优先级低的运算符压栈过程如图:栈顶二叉树temp_tree二叉树Etree二叉树将temp_tree作为etree的右结点新的二叉树类栈最后进行一个遍历,判断运算符栈是否处理完,算出最后结果。

数据结构二叉树应用课程设计含源代码实现

数据结构二叉树应用课程设计含源代码实现
再取栈顶元素进行相应判断。输出根结点后就是要找它的左孩子,直 到左孩子为 NULL 后,退一个结点向右一次(找它的右孩子),然后继 续循环找这个右孩子的左孩子。直到所有的左右孩子都找完(栈空), 此时先序遍历结束。
中序遍历,是先找左孩子,直到左孩子为 NULL,这时退一个结点 输出,然后再向右一次(找其右孩子),继续循环找这个右孩子的左 孩子。直到栈空全部找完,此时中序遍历结束。
QElemType data; struct QNode *next; }QNode, *QueuePtr;
typedef struct //队列的数据结构 {
QueuePtr front; QueuePtr rear; }LkQueue;
typedef BiTree SElemType;//把二叉树结点作为栈的数据成员 #define STACK_INIT_SIZE 100//初始分配量 #define STACKINCREMENT 10 //分配增量
1 / 17
struct QNode *next;
}QNode,*QueuePtr;
//队列结点
***********************************************************
typedef struct
{
QueuePtr front;
QueuePtr rear;
3.2 数据结构
***********************************************************
typedef int TElemType;
typedef struct BiTNode
{
TElemType data;
//值

平衡二叉树的实现c语言

平衡二叉树的实现c语言

平衡二叉树的实现c语言平衡二叉树(AVL树)是一种自平衡的二叉查找树,其中任何节点的两个子树的高度差最多为1。

下面是一个简单的AVL树的C语言实现:```cinclude <>include <>typedef struct AVLNode {int key;int height;struct AVLNode left, right;} AVLNode;typedef struct {AVLNode root;} AVLTree;int getHeight(AVLNode node) {if (node == NULL)return 0;return node->height;}int getBalance(AVLNode node) {if (node == NULL)return 0;return getHeight(node->left) - getHeight(node->right);}AVLNode rotateRight(AVLNode y) {AVLNode x = y->left;AVLNode T2 = x->right;x->right = y;y->left = T2;y->height = max(getHeight(y->left), getHeight(y->right)) + 1; x->height = max(getHeight(x->left), getHeight(x->right)) + 1; return x; // new root is x}AVLNode rotateLeft(AVLNode x) {AVLNode y = x->right;AVLNode T2 = y->left;y->left = x;x->right = T2;x->height = max(getHeight(x->left), getHeight(x->right)) + 1; y->height = max(getHeight(y->left), getHeight(y->right)) + 1; return y; // new root is y}AVLNode insert(AVLTree tree, int key) {AVLNode root = tree->root;if (root == NULL) { // tree is empty, create a new node as root. tree->root = (AVLNode)malloc(sizeof(AVLNode));root = tree->root;root->key = key;root->height = 1;return root;} else if (key < root->key) { // insert into left subtree.root->left = insert(root->left, key);} else if (key > root->key) { // insert into right subtree.root->right = insert(root->right, key);} else { // duplicate keys not allowed.return root; // don't insert duplicate key.}root->height = 1 + max(getHeight(root->left), getHeight(root->right)); // adjust height of current node.int balance = getBalance(root);if (balance > 1 && key < root->left->key) { // left left case.return rotateRight(root); // rotate right.} else if (balance < -1 && key > root->right->key) { // right right case.return rotateLeft(root); // rotate left.} else if (balance > 1 && key > root->left->key) { // left right case. root->left = rotateLeft(root->left); // rotate left first.return rotateRight(root); // then rotate right.} else if (balance < -1 && key < root->right->key) { // right left case.root->right = rotateRight(root->right); // rotate right first.return rotateLeft(root); // then rotate left.} // keep balance.return root; // already balanced.} ```。

二叉树C语言实现

二叉树C语言实现

#include "stdio.h"#include "conio.h"#include "stdlib.h"#define NULL 0int leftdep,rightdep;typedef struct bitnode{char data;struct bitnode *lchild,*rchild;} bintnode,*bintree;bintree createbitree() {bintree t;char x;scanf("%c",&x);if(x==' ') t=NULL;else{t=(bintnode *)malloc(sizeof(bintnode)); t->data=x;t->lchild=createbitree();t->rchild=createbitree();}return(t);}void preorder(bintree t)/*前序遍历*/{if(t){printf("%2c",t->data);preorder(t->lchild);preorder(t->rchild);}}void midorder(bintree t)/*中序遍历*/{if(t){midorder(t->lchild);printf("%2c",t->data);midorder(t->rchild);}}void printree(bintree t){if(t!=NULL){printf("%c",t->data);if(t->lchild!=NULL||t->rchild!=NULL) {printf("(");printree(t->lchild);if(t->rchild!=NULL) printf(",");printree(t->rchild); printf(")");}}}int treedepth(bintree t){if(t==NULL) return 0;else{leftdep=treedepth(t->lchild); rightdep=treedepth(t->rchild);if(leftdep>rightdep)return (leftdep+1); elsereturn(rightdep+1);}}int treeleaf(bintree t) {if(t==NULL)return0;elseif(t->lchild==NULL&&t->rchild==NULL) return1;elsereturn(treeleaf(t->lchild)+treeleaf(t->rchild));} void lastorder(bintree t)/*后序遍历*/{if(t){lastorder(t->lchild);lastorder(t->rchild );printf("%2c",t->data);}}void translevel(bintree t) {struct bitnode{bintree vec[30];int f,r;}q;q.f=0;q.r=0;if(t!=NULL)printf("%2c",t->data);q.vec[q.r]=t;q.r=q.r+1;while (q.f<q.r){t=q.vec[q.f];q.f=q.f+1;if(t->lchild!=NULL){printf("%2c",t->lchild->data);q.vec[q.r]=t->lchild; q.r=q.r+1;}if(t->rchild!=NULL){printf("%2c",t->rchild->data);q.vec[q.r]=t->rchild;q.r=q.r+1;}} printf("\n");}main(){bintree a;int j,k;clrscr();textcolor(2); printf("**************************欢迎您使用本二叉树操作系统**************************\n");printf("建造一棵二叉树请您输入各个结点的元素值,()表示一个空格键:\n");printf("输入示例:abc()()de()g()()f()()()回车:\n");a=createbitree();printf("您输入的二叉数嵌套法表示如下:\n");printree(a);printf("\n");printf("树的深度为:\n");j=treedepth(a);printf("%d\n",j);printf("二叉数的叶子接点个数为:\n");k=treeleaf(a);printf("%d\n",k);printf("您所输入的二叉树的前序遍历顺序输出如下:\n");if(!a) printf("二叉树为空\n");else{preorder(a);printf("\n");}printf("您所输入的二叉树的中序遍历顺序如下输出:\n");if(!a) printf("二叉树为空\n");else{ midorder(a);printf("\n");}printf("您所输入的二叉树的后序遍历顺序输出如下:\n");if(!a) printf("二叉树为空\n");else{lastorder(a);printf("\n");}printf("您所输入的二叉树的层次顺序遍历输出如下:\n");if(!a) printf("二叉树为空\n");else{translevel(a);}}。

二叉树课程设计c语言

二叉树课程设计c语言

二叉树是计算机科学中常用的一种数据结构,可以用于表示各种类型的数据。

以下是一个简单的二叉树课程设计,使用C语言实现。

```c#include <stdio.h>#include <stdlib.h>// 定义二叉树节点结构体typedef struct Node {int data;struct Node *left;struct Node *right;} Node;// 创建新节点Node* createNode(int data) {Node* newNode = (Node*)malloc(sizeof(Node));if (!newNode) {printf("内存分配失败\n");return NULL;}newNode->data = data;newNode->left = NULL;newNode->right = NULL;return newNode;}// 插入节点Node* insertNode(Node* root, int data) {if (root == NULL) {return createNode(data);}if (data <= root->data) {root->left = insertNode(root->left, data); } else {root->right = insertNode(root->right, data); }return root;}// 中序遍历二叉树void inorderTraversal(Node* root) {if (root == NULL) {return;}inorderTraversal(root->left);printf("%d ", root->data);inorderTraversal(root->right);}int main() {Node* root = NULL; // 初始时,根节点为空int arr[] = {8, 3, 10, 1, 6, 14, 4, 7, 13}; // 要插入的节点数据数组int n = sizeof(arr) / sizeof(arr[0]); // 数组元素个数for (int i = 0; i < n; i++) { // 插入节点到二叉树中 root = insertNode(root, arr[i]);}printf("中序遍历二叉树的结果为:"); // 中序遍历二叉树,输出结果为升序排列的节点数据数组inorderTraversal(root);printf("\n");return 0;}```。

c语言二叉树代码

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('程序已退出。

二叉树源程序

二叉树源程序

二叉树源程序程序存放在bltree.c文件中,以下为程序清单:#include <stdio.h>#define null 0#define max 100int counter=0;int stack[max],top=0;//****************************************////****************************************//typedef struct btreenode{int data;struct btreenode *lchild;struct btreenode *rchild;}bnode;//*****************************//bnode *creat(int x,bnode *lbt,bnode *rbt) //建立一个只有根结点的二叉树{bnode *p;p=(bnode*)malloc (sizeof(bnode));p->data=x;p->lchild=lbt;p->rchild=rbt;return(p);}//************************************************//bnode *inslchild(bnode *p,int x) //x作为左孩子插入到二叉树中{bnode *q;if(p==null)printf("Illegal insert.");else{q=(bnode*)malloc(sizeof(bnode));q->data=x;q->lchild=null;q->rchild=null;if(p->lchild!=null) //若p有左孩子,则将原来的左孩子作为结点x 的右孩子q->rchild=p->lchild;p->lchild=q; //x做为p的左孩子}}//***************************************//bnode *insrchild(bnode *p,int x){bnode *q;if(p==null)printf("Illegal insert.");else{q=(bnode*)malloc(sizeof(bnode));q->data=x;q->lchild=null;q->rchild=null;if(p->rchild!=null)q->lchild=p->rchild;p->rchild=q;}}//**************************************//void prorder(bnode *p) //输出二叉树的结构{if(p==null)return;printf("%d\t%u\t%d\t%u\t%u\n",++counter,p,p->data,p->lchild,p->r child);if(p->lchild!=null)prorder(p->lchild);if(p->rchild!=null)prorder(p->rchild);}//***********************************//void print(bnode *p) //嵌套括号表示二叉树,输出左子树前打印左括号,{ //输出右子树后打印右括号。

二叉树c语言的程序代码

二叉树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;}}}。

二叉树基本操作演示程序的设计与实现

二叉树基本操作演示程序的设计与实现

二叉树基本操作演示程序的设计与实现2012级电器信息类X班(姓名)(学号)注意:文档以word格式提供,文件名起名规则:学号+姓名+实验报告名称一、需求分析1、创建二叉树。

按照用户需要的二叉树,构建二叉树。

2、将创建的二叉树,以树状形式输出。

3、分别以先序、中序、后序三种方式遍历访问二叉树。

4、输出二叉树的叶子结点及叶子结点的个数。

5、输出二叉树的高度。

6、将创建的二叉树,以括号形式输出。

二、概要设计为了实现以上功能,可以从三个方面着手设计。

1、主界面设计为了实现二叉树相关操作功能的管理,设计一个含有多个菜单项的主控菜单子程序以链接系统的各项子功能,方便用户使用本程序。

本系统主控菜单运行界面如图1所示。

首先请输入二叉树结点序列:请按菜单提示操作:----------------------------欢迎使用二叉树基本操作程序-------------------------------菜单选择1. 树状输出二叉树2. 先序遍历二叉树3. 中序遍历二叉树4. 后序遍历二叉树5. 输出叶子结点6. 输出叶子结点个数7. 输出二叉树的深度8. 括号形式输出二叉树9. 退出--------------------------------------------------------------------------------------------------图1 二叉树基本操作程序主菜单2、存储结构设计本程序采用二叉链式存储类型(BiTNode)存储二叉树的结点信息。

二叉树的链表中的结点至少包含3个域:数据域(data)、左孩子指针域(lchild)、右孩子指针域(rchild)。

3、系统功能设计本程序除了完成二叉树的创建功能外还设置了9个子功能菜单。

由于这9个子功能都是建立在二叉树的构造上的,所以二叉树的创建由主函数main()实现。

9个子功能的设计描述如下:⑴树状输出二叉树。

树状输出二叉树由函数TranslevelPrint()实现。

c语言二叉树实例

c语言二叉树实例

c语言二叉树实例C语言二叉树实例一、引言二叉树是一种常见的数据结构,在计算机科学中有着广泛的应用。

而C语言作为一种常用的编程语言,也提供了丰富的数据结构和算法支持,使得实现二叉树成为一项相对简单的任务。

本文将以C语言为基础,介绍如何实现一个二叉树,并通过一个实例来演示其使用方法。

二、二叉树的定义二叉树是一种特殊的树形结构,其中每个节点最多有两个子节点。

每个节点包含一个数据元素和指向其左右子节点的指针。

二叉树的特点是具有递归的结构,即每个子树也是二叉树。

三、二叉树的实现在C语言中,可以通过定义一个结构体来表示二叉树的节点。

结构体中包含一个数据元素和两个指针,分别指向左右子节点。

下面是一个简单的二叉树节点的定义:```ctypedef struct TreeNode {int data;struct TreeNode* left;struct TreeNode* right;} TreeNode;```四、二叉树的操作1. 创建节点可以通过动态分配内存的方式创建一个二叉树节点,然后为节点的数据元素赋值,并将左右子节点指针初始化为NULL。

2. 插入节点插入节点是二叉树的一个重要操作,可以根据节点的值来确定其插入位置。

如果插入的值小于当前节点的值,则将其插入到左子树中;如果插入的值大于当前节点的值,则将其插入到右子树中。

插入操作可以通过递归或循环实现。

3. 删除节点删除节点是另一个常用的操作,可以根据节点的值来确定删除的位置。

删除节点时需要考虑三种情况:节点没有子节点、节点只有一个子节点、节点有两个子节点。

删除操作同样可以通过递归或循环实现。

4. 查找节点查找节点可以根据节点的值来确定其位置。

可以通过递归或循环的方式进行查找,当找到对应的节点时,可以返回该节点的指针。

5. 遍历二叉树常见的二叉树遍历方式有三种:前序遍历、中序遍历和后序遍历。

前序遍历是先访问根节点,然后递归遍历左子树和右子树;中序遍历是先递归遍历左子树,然后访问根节点,再递归遍历右子树;后序遍历是先递归遍历左子树和右子树,然后访问根节点。

二叉树的基本操作(C语言、源代码)

二叉树的基本操作(C语言、源代码)

二叉树的基本操作(源代码)#include "stdio.h"#include "malloc.h"#define MAX 100typedef struct node{int date;struct node *lchild,*rchild;}bitnode,*bitree;bitree createbitree(bitree bt){int m;printf("m=");scanf("%d",&m);if(m==-1)bt=NULL;else{bt=(bitnode *)malloc(sizeof(bitnode));bt->date=m;bt->lchild=createbitree(bt->lchild);bt->rchild=createbitree(bt->rchild);}return bt;}//树的建立bitree queue[MAX],p=bt;int rear=0,front=0;if(p!=NULL){queue[++rear]=p;while(front<rear){p=queue[++front];printf("%d\t",p->date);if(p->lchild!=NULL)queue[++rear]=p->lchild;if(p->rchild!=NULL)queue[++rear]=p->rchild;}}}//树的层次遍历void preordertraverse(bitree bt){if(bt!=NULL){printf("%d\t",bt->date);preordertraverse(bt->lchild);preordertraverse(bt->rchild);}}//树的先序遍历if(bt!=NULL){inordertraverse(bt->lchild);printf("%d\t",bt->date);inordertraverse(bt->rchild);}}//树的中序遍历void postordertraverse(bitree bt){ if(bt!=NULL){postordertraverse(bt->lchild);postordertraverse(bt->rchild);printf("%d\t",bt->date);}}//树的后序遍历int bitreedepth(bitree bt){int h,lh,rh;if(bt==NULL)h=0;else{lh=bitreedepth(bt->lchild);rh=bitreedepth(bt->rchild);if(lh>=rh)h=lh+1;elseh=rh+1;}return h;}//求树的深度int bitreeleaf(bitree bt){int m=0;if(!bt)return 0;else if(bt->lchild==NULL&&bt->rchild==NULL)return 1;m+=bitreeleaf(bt->lchild)+bitreeleaf(bt->rchild);return m;}//求树的叶子树int countbitreenode(bitree bt){if(!bt)return 0;elsereturn countbitreenode(bt->lchild)+countbitreenode(bt->rchild)+1; }//求树的节点数void OperateBitree(bitree bt){printf("\n");printf("The level traversal of the bitree is:\n\t");leveltraverse(bt);printf("\n\n");printf("The preorder traversal of the bitree is:\n\t");preordertraverse(bt);printf("\n\n");printf("The inorder traversal of the bitree is:\n\t");inordertraverse(bt);printf("\n\n");printf("The postorder traversal of the bitree is:\n\t");postordertraverse(bt);printf("\n\n");printf("The number of the bitreenode is %d.\n",countbitreenode(bt));printf("The depth of the bitree is %d.\n",bitreedepth(bt));printf("The number of the leaves of the bitree is %d.\n\n",bitreeleaf(bt)); }//树的基本操作void main(){bitree bt;bt=createbitree(bt);OperateBitree(bt);}。

数据结构课程设计二叉树相关操作源代码

数据结构课程设计二叉树相关操作源代码

可运行c语言数据结构课程设计二叉树相关操作源代码#include<stdio.h>#include<stdlib.h>#define MAXSIZE 1000structBiTNode{int c;intlchild,rchild;}BiTNode,*BiTree;structBiTNode tree[MAXSIZE];void creat()//创建二叉树函数{inti,j;printf("需要输入权值个数:\n");scanf("%d",&j);if (j<8)//判断二叉树是否达到4层{printf("错误:二叉树的层数少于4层!\n");return;}printf("开始输入权值:\n");for(i=1;i<=j;i=i+1)//权值的录入{scanf("%d",&tree[i].c);tree[i].lchild=2*i;tree[i].rchild=2*i+1;}printf("成功创建二叉树\n");}int leaves()//统计叶子个数函数{intl,i;l=0;for (i=1;tree[i].c!=NULL;i++)//计算二叉树结点的个数{l++;}if ((l%2))//判断结点的奇偶性从而计算叶子的个数{return(((l-1)/2)+1);}elsereturn(l/2);}int deep()//求二叉树的深度{intd,i,sum;sum=1;for (i=1;tree[i].c!=NULL;i++);//计算二叉树结点的个数for (d=1;sum<=i;d++)//求出二叉树的深度{if (d!=1){sum=sum+sum*2;}}return(d-1);}void qian(int a)//前序遍历输出列表{if (tree[a].c!=NULL)//判断当前结点是否有值,若有执行如下操作,若无则返回上一层{printf("%d,",tree[a].c);//首先输出当前结点(根节点)的权值qian((a*2));//递归调用,用当前结点的左孩子作根节点重复当前函数的操作qian((a*2+1));//递归调用,用当前结点的右孩子作根节点重复当前函数的操作}elsereturn;}void zhong(int a)//中序遍历输出列表{if (tree[2*a].c!=NULL)//首先判断当前结点的左孩子是否为空,不是就进行递归调用,用当前结点的左孩子作根节点重复当前函数的操作{zhong((2*a));}printf("%d,",tree[a].c);//输出当前结点的权值if (tree[2*a+1].c!=NULL)//判断当前结点的右孩子是否为空,不是就进行递归调用,用当前结点的右孩子作根节点重复当前函数的操作{zhong((2*a+1));}}void hou(int a)//后序遍历输出序列{if (tree[2*a].c!=NULL)//判断当前结点的左孩子是否为空,不是就进行递归调用,用当前结点的左孩子作根节点重复当前函数的操作{hou((2*a));}if (tree[2*a+1].c!=NULL)//判断当前结点的右孩子是否为空,不是就进行递归调用,用当前结点的右孩子作根节点重复当前函数的操作{hou((2*a+1));}printf("%d,",tree[a].c);//输出当前结点的权值}void main(){intd,l,i;i=10;printf("******************目录******************\n");printf("1、创建二叉树\n");printf("2、统计叶子个数\n");printf("3、求二叉树的深度\n");printf("4、前序遍历输出列表\n");printf("5、中序遍历输出列表\n");printf("6、后序遍历输出序列\n");printf("0、退出操作\n");printf("*****************************************\n"); while(i!=0){printf("选择操作:\n");scanf("%d",&i);if(i==0){break;}else if(i==1){printf("开始创建二叉树(层数不少于4层)\n");creat();}else if(i==2){l=leaves();printf("叶子个数为:%d\n",l);}else if(i==3){d=deep();printf("二叉树的深度是%d\n",d);}else if(i==4){printf("用前序遍历输出的结果是:\n");qian(1);printf("\n");}else if(i==5){printf("用中序遍历输出的结果是:\n");zhong(1);printf("\n");}else if(i==6){printf("用后序遍历输出的结果是:\n");hou(1);printf("\n");}elseprintf("错误:没有该操作!\n");}printf("欢迎使用!\n");}。

实现二叉树各种基本运算源程序

实现二叉树各种基本运算源程序

实现二叉树各种基本运算源程序// BiTree.cpp : Defines the entry point for the console application. //#include "stdafx.h"#include#include#define MaxSize 100typedef char ElemType;typedef struct node{ElemType data;struct node *lchild;struct node *rchild;}BTNode;void CreateBTNode(BTNode *&b,char *str);BTNode *FindNode(BTNode *b,ElemType x);BTNode *LchildNode(BTNode *p);BTNode *RchildNode(BTNode *p);int BTNodeDepth(BTNode *b);void DispBTNode(BTNode *b);int BTWidth(BTNode *b);int Nodes(BTNode *b);int LeafNodes(BTNode *b);void CreateBTNode(BTNode *&b,char *str){BTNode *St[MaxSize],*p=NULL;int top=-1,k,j=0;char ch;b=NULL;ch=str[j];while(ch!='\0'){switch(ch){case'(':top++;St[top]=p;k=1;break;case')':top--;break;case',':k=2;break;default:p=(BTNode *)malloc(sizeof(BTNode));p->data=ch;p->lchild=p->rchild=NULL;if(b==NULL)b=p;else{switch(k){case 1:St[top]->lchild=p;break;case 2:St[top]->rchild=p;break;}}}j++;ch=str[j];}}BTNode *FindNode(BTNode *b,ElemType x) //返回data域为x的结点指针{BTNode *p;if(b==NULL)return NULL;else if(b->data==x)return b;else{p=FindNode(b->lchild,x);if(p!=NULL)return p;elsereturn FindNode(b->rchild,x);}}BTNode *LchildNode(BTNode *p) //返回*p结点的左孩子结点指针{return p->lchild;}BTNode *RchildNode(BTNode *p) //返回*p结点的右孩子结点指针{return p->rchild;}int BTNodeDepth(BTNode *b) //求二叉树b的深度{int lchilddep,rchilddep;if(b==NULL)return(0);else{lchilddep=BTNodeDepth(b->lchild); //左子数的高度rchilddep=BTNodeDepth(b->rchild); //右子树的高度return(lchilddep>rchilddep)?(lchilddep+1):(rchilddep+1); }}void DispBTNode(BTNode *b) //广义表输出二叉树{if(b!=NULL){printf("%c",b->data);if(b->lchild!=NULL||b->rchild!=NULL){printf("(");DispBTNode(b->lchild);if(b->rchild!=NULL) printf(",");DispBTNode(b->rchild);printf(")");}}}int BTWidth(BTNode *b) //求二叉树宽度{struct{int lno; //结点的层次编号BTNode *p; //结点指针}Qu[MaxSize]; //定义顺序非循环队列int front,rear; //定义队首和队尾指针int lnum,max,i,n;front=rear=0; //置队列为空if(b!=NULL){rear++;Qu[rear].p=b; //根结点指针入队Qu[rear].lno=1; //根结点的层次编号为1 while(rear!=front) //队列不为空{front++;b=Qu[front].p; //队头出队lnum=Qu[front].lno;if(b->lchild!=NULL) //左孩子入队{rear++;Qu[rear].p=b->lchild;Qu[rear].lno=lnum+1;}if(b->rchild!=NULL) //右孩子入队{rear++;Qu[rear].p=b->rchild;Qu[rear].lno=lnum+1;}}max=0;lnum=1;i=1;while(i<=rear){n=0;while(i<=rear&&Qu[i].lno==lnum) {n++;i++; //求每层的结点数}lnum=Qu[i].lno;if(n>max) max=n;}return max;}elsereturn 0;}int Nodes(BTNode *b) //求二叉树的结点个数{int num1,num2;if(b==NULL)return 0;else if(b->lchild==NULL&&b->rchild==NULL) return 1;else{num1=Nodes(b->lchild);num2=Nodes(b->rchild);return(num1+num2+1);}}int LeafNodes(BTNode *b) //求二叉树的叶子结点个数{int num1,num2;if(b==NULL)return 0;else if(b->lchild==NULL&&b->rchild==NULL) return 1;else{num1=LeafNodes(b->lchild);num2=LeafNodes(b->rchild);return(num1+num2);}}void BiTreeTest(){BTNode *b,*p,*lp,*rp;CreateBTNode(b,"A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))"); printf("\n");printf("(1)输出二叉树:");DispBTNode(b);printf("\n");printf("(2)'H'结点:");p=FindNode(b,'H');if(p!=NULL){lp=LchildNode(p);if(lp!=NULL)printf("左孩子为%c",lp->data);elseprintf("无左孩子");rp=RchildNode(p);if(rp!=NULL)printf("右孩子为%c",rp->data);elseprintf("无右孩子");}printf("\n");printf("(3)二叉树的深度:%d\n",BTNodeDepth(b)); printf("(4)二叉树的宽度:%d\n",BTWidth(b));printf("(5)二叉树的结点个数:%d\n",Nodes(b));printf("(6)二叉树的叶子结点个数:%d\n",LeafNodes(b)); printf("\n");}int main(int argc, char* argv[]){BiTreeTest();printf("Hello World!\n");return 0; }。

参考程序4二叉树演示源程序

参考程序4二叉树演示源程序

/*二叉树演示源程序*/#include <graphics.h>#include <stdio.h>#include <stdlib.h>#include <dos.h>#include <time.h>typedef struct TREE{char data;/*树的结点数据*/struct TREE *lchild;struct TREE *rchild;int x;/*树的x坐标*/int y;/*树的y坐标*/}Tree;struct OUTPUT{int x;/*三种遍历的x坐标*/int y;/*三种遍历的y坐标*/int num;}s;int nodeNUM=0;/*统计当前的结点数字,最多26个*/char way;/*自动建立树和手动建立树的标志,2手动,1自动*/ char str[3];/*显示结点数据的字符串*/void Init();/*图形初始化*/void Close();/*图形关闭*/Tree *CreatTree();/*文本模式下创建树的过程*/Tree *InitTree(int h,int t,int w);/*创建树,h层次,t横坐标,w树之间的宽度,n树的建立方式*/ void DrawTree(Tree *t);/*用图形显示创建好的树*/void Preorder(Tree *t);/*前序遍历*/void Midorder(Tree *t);/*中序遍历*/void Posorder(Tree *t);/*后序遍历*/void DrawNode(Tree *t,int color);/*遍历时显示每个结点的过程*/void ClrScr();/*清空树的区域*/void main(){Tree *root;randomize();root=CreatTree();/*创建树*/Init();DrawTree(root);/*每次遍历前显示白色的树*/sleep(1);s.x=100;s.y=300;s.num=1;/*每次遍历前设置显示遍历顺序显示的x,y坐标*/Preorder(root);/*前序遍历*/getch();ClrScr();DrawTree(root);sleep(1);s.x=100;s.y=350;s.num=1;Midorder(root);/*中序遍历*/getch();ClrScr();DrawTree(root);sleep(1);s.x=100;s.y=400;s.num=1;Posorder(root);/*后序遍历*/Close();}/*清空树的区域*/void ClrScr(){setcolor(BLACK);setfillstyle(SOLID_FILL,BLACK);bar(0,20,640,280);}/*文本模式下创建树的过程*/Tree *CreatTree(){Tree *root;clrscr();printf("please input n\n");printf("puter creat\n");printf("2.people creat\n");way=getch();/*输入创建树的方法,1电脑自动建立,2人工手动建立*/ if(way!='2')way='1';/*其他数字默认自动建立*/if(way=='2')/*手动建立提示输入结点*/printf("Please creat the tree\n");root=InitTree(1,320,150);system("pause");return root;}/*生成二叉树,h表示层次,t表示横坐标,w表示结点左右子树的宽度,随机数n确定结点是空或非空,如n为0,则为空*,但要限定确保结点数不少于三个*/Tree *InitTree(int h,int t,int w){char ch;int n;/*自动建立时随机赋值判断是否是NULL的标志*/Tree *node;if(way=='2')/*手动建立需要自己输入*/scanf("%c",&ch);else/*自动建立的赋值*/{n=random(5);if(n==0&&nodeNUM>=3)/*随机赋值时候确保自动建立的二叉树有三个结点*/ch='.';elsech=65+random(25);}if(ch=='.')/*输入空格代表NULL*/return NULL;else{if(h==6||nodeNUM==26)/*如果树的层次已经到5或者结点树到达26个就自动返回NULL*/ return NULL;node=(Tree*)malloc(sizeof(Tree));node->data=ch;node->x=t;/*树的x坐标是传递过来的横坐标*/node->y=h*50;/*树的y坐标与层次大小有关*/nodeNUM++;node->lchild=InitTree(h+1,t-w,w/2);node->rchild=InitTree(h+1,t+w,w/2);}return node;}/*用图形显示创建好的树*/void DrawTree(Tree *t){if(t!=NULL){setcolor(BLACK);setfillstyle(SOLID_FILL,BLACK);fillellipse(t->x,t->y,9,9);setcolor(WHITE);circle(t->x,t->y,10); /*画圆*/sprintf(str,"%c",t->data);/*将内容转换成字符串输出*/ outtextxy(t->x-3,t->y-2,str);if(t->lchild!=NULL)/*左子树*/{line(t->x-5,t->y+12,t->lchild->x+5,t->lchild->y-12); DrawTree(t->lchild);}if(t->rchild!=NULL)/*右子树*/{line(t->x+5,t->y+12,t->rchild->x-5,t->rchild->y-12); DrawTree(t->rchild);}}}/*遍历时显示每个结点的过程*/void DrawNode(Tree *t,int color){setcolor(YELLOW);setfillstyle(SOLID_FILL,YELLOW);fillellipse(t->x,t->y,10,10);setcolor(RED);sprintf(str,"%c",t->data);/*将内容转换成字符串输出*/ outtextxy(t->x-3,t->y-2,str);setcolor(color);outtextxy(s.x,s.y,str);setcolor(RED);sprintf(str,"%d",s.num);/*将遍历次序用数字显示在树的结点上*/ outtextxy(t->x-3,t->y-20,str);s.num++;sleep(1);}/*前序遍历*/void Preorder(Tree *t){if(t!=NULL){s.x+=15;DrawNode(t,GREEN);Preorder(t->lchild);Preorder(t->rchild);}}void Midorder(Tree *t){if(t!=NULL){Midorder(t->lchild);s.x+=15;DrawNode(t,YELLOW);Midorder(t->rchild);}}/*后序遍历*/void Posorder(Tree *t){if(t!=NULL){Posorder(t->lchild);Posorder(t->rchild);s.x+=15;DrawNode(t,BLUE);}}void Init(){int gd=DETECT,gm;initgraph(&gd,&gm,"c:\\tc"); cleardevice();setcolor(YELLOW);outtextxy(250,10,"anykey to continue"); setcolor(RED);outtextxy(20,300,"preorder"); outtextxy(20,350,"midorder"); outtextxy(20,400,"posorder");getch();}/*图形关闭*/void Close(){getch();closegraph();}。

C语言实现二叉树

C语言实现二叉树

C语⾔实现⼆叉树#include "stdio.h"#include "stdlib.h"/*树节点*/typedef struct node{int data;struct node * left; /*节点左边的树枝*/struct node * right;/*节点右边的树枝*/}Node;/*树根*/typedef struct tree{Node * root;}Tree;/*插⼊函数向⼀个树⾥⾯插⼊数据*/void insert(Tree* tree, int value){/*创建⼀个节点*/Node* node=(Node*)malloc(sizeof(Node));node->data = value;node->left = NULL;node->right = NULL;/*判断树是不是空树*/if (tree->root == NULL){tree->root = node;}else/*不是空树*/{Node* temp = tree->root;/*从树根开始*/while (temp != NULL){if(value < temp->data)/*⼩于就进左⼉⼦*/{if(temp->left == NULL){temp->left = node;return;}else/*继续判断*/{temp = temp->left;}}else/*否则进右⼉⼦*/{if(temp->right == NULL){temp->right = node;return;}else/*继续判断*/{temp = temp->right;}}}}}/*遍历⼀整颗树中序遍历:先左后根再右*/void traverse(Node* node){if(node != NULL){traverse(node->left);printf("%d ",node->data);traverse(node->right);}}/*销毁⼀棵树*/void distory_tree(Node* node){if(node != NULL){distory_tree(node->left);distory_tree(node->right);printf("free node:%d\n",node->data);free(node);node = NULL;}}/*主函数*/int main(){int i = 0;Tree tree;tree.root = NULL;/*创建⼀个空树*/int n;printf("input total num:\n");/*输⼊n个数并创建这个树*/scanf("%d",&n);for(i = 0; i < n; i++){int temp;scanf("%d",&temp);insert(&tree, temp);}/*遍历整个树*/traverse(tree.root);/*销毁⼀棵树*/distory_tree(tree.root);return0;}。

二叉树(C语言实现)

二叉树(C语言实现)
网络错误503请刷新页面重试持续报错请尝试更换浏览器或网络环境
二叉树( C语言实现)
# include <stdio.h> # include <malloc.h>
struct BTNode * pLchild; //p是指针 L是左 child是孩子 struct BTNode * pRchild; };
void InTraverseBTree(struct BTNode * pT) {
if (NULL != pT) {
if (NULL != pT->pLchild) {
InTraverseBTree(pT->pLchild); }
printf("%c\n", pT->data);
if (NULL != pT->pRchild) {
int main(void) {
struct BTNode * pT = CreateBTree();
// PreTraverseBTree(pT); // InTraverseBTree(pT);
PostTraverseBTree(pT);
return 0; }
void PostTraverseBTree(struct BTNode * pT) {
void PostTraverseBTree(struct BTNode * pT); struct BTNode * CreateBTree(void); void PreTraverseBTree(struct BTNode * pT); void InTraverseBTree(struct BTNode * pT);
struct BTNode * CreateBTree(void) {
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

C语言课程设计_二叉树演示源程序
/********tree2.c二叉树演示********/
#include <graphics.h>
#include <stdio.h>
#include <stdlib.h>
#include <dos.h>
#include <time.h>
typedef struct TREE
{
char data;/*树的结点数据*/
struct TREE *lchild;
struct TREE *rchild;
int x;/*树的x坐标*/
int y;/*树的y坐标*/
}Tree;
struct OUTPUT
{
int x;/*三种遍历的x坐标*/
int y;/*三种遍历的y坐标*/
int num;
}s;
int nodeNUM=0;/*统计当前的结点数字,最多26个*/
char way;/*自动建立树和手动建立树的标志,2手动,1自动*/
char str[3];/*显示结点数据的字符串*/
void Init();/*图形初始化*/
void Close();/*图形关闭*/
Tree *CreatTree();/*文本模式下创建树的过程*/
Tree *InitTree(int h,int t,int w);/*创建树,h层次,t横坐标,w树之间的宽度,n树的建立方式*/ void DrawTree(Tree *t);/*用图形显示创建好的树*/
void Preorder(Tree *t);/*前序遍历*/
void Midorder(Tree *t);/*中序遍历*/
void Posorder(Tree *t);/*后序遍历*/
void DrawNode(Tree *t,int color);/*遍历时显示每个结点的过程*/
void ClrScr();/*清空树的区域*/
void main()
{
Tree *root;
randomize();
root=CreatTree();/*创建树*/
Init();
DrawTree(root);/*每次遍历前显示白色的树*/
sleep(1);
s.x=100;s.y=300;s.num=1;/*每次遍历前设置显示遍历顺序显示的x,y坐标*/ Preorder(root);/*前序遍历*/
getch();
ClrScr();
DrawTree(root);
sleep(1);
s.x=100;
s.y=350;
s.num=1;
Midorder(root);/*中序遍历*/
getch();
ClrScr();
DrawTree(root);
sleep(1);
s.x=100;
s.y=400;
s.num=1;
Posorder(root);/*后序遍历*/
Close();
}
/*清空树的区域*/
void ClrScr()
{
setcolor(BLACK);
setfillstyle(SOLID_FILL,BLACK);
bar(0,20,640,280);
}
/*文本模式下创建树的过程*/
Tree *CreatTree()
{
Tree *root;
clrscr();
printf("please input n\n");
printf("puter creat\n");
printf("2.people creat\n");
way=getch();/*输入创建树的方法,1电脑自动建立,2人工手动建立*/
if(way!='2')
way='1';/*其他数字默认自动建立*/
if(way=='2')/*手动建立提示输入结点*/
printf("Please creat the tree\n");
root=InitTree(1,320,150);
system("pause");
return root;
}
/*生成二叉树,h表示层次,t表示横坐标,w表示结点左右子树的宽度,随机数n确定结点是空或非空,如n为0,则为空*,但要限定确保结点数不少于三个*/
Tree *InitTree(int h,int t,int w)
{
char ch;
int n;/*自动建立时随机赋值判断是否是NULL的标志*/
Tree *node;
if(way=='2')/*手动建立需要自己输入*/
scanf("%c",&ch);
else/*自动建立的赋值*/
{
n=random(5);
if(n==0&&nodeNUM>=3)/*随机赋值时候确保自动建立的二叉树有三个结点*/ ch='.';
else
ch=65+random(25);
}。

相关文档
最新文档