用递归方法建树c语言,BinaryTree-递归遍历&建树--C语言

定义BinaryTree结构

测试用例

递归前中后遍历

中前 中后建树

层序 叶子结点 双亲结点

代码块

#include

#include

#include

typedef char ELELTYPE;

//定义结构体

typedef struct

{

ElemType data;

BtNode *leftchild;

BtNode *rightchild;

}BtNode,*BinaryTree;

//申请结点

BtNode * Buynode()

{

BtNode *s = (BtNode*)malloc(sizeof(BtNode));

if(s == NULL) exit(1);

memset(s,0,sizeof(BtNode)); //memset 以字节为单位初始化

return s;

}

//释放结点

void Freenode(BtNode *p)

{

free(p);

}

//递归先序遍历二叉树

void PreOrder(BtNode *ptr)

{

if(ptr!=NULL)

{

printf("%c",ptr->data);

PreOrder(ptr->leftchild);

PreOrder(ptr->rightchild);

}

}

//递归中序遍历二叉树

void InOrder(BtNode *ptr)

{

if(ptr!=NULL)

{

InOrder(ptr->leftchild);

printf("%c",ptr->data);

InOrder(ptr->rightchild);

}

}

//递归后序遍历二叉树

void PastOrder(BtNode *ptr)

{

if(ptr!=NULL)

{

PastOrder(ptr->leftchild);

PastOrder(ptr->rightchild);

printf("%c",ptr->data);

}

}

//建立二叉树方式一：屏幕读入 ABC##DE##F##G#H## (#表明null)

BtNode * CreateTree1()

{

BtNode *s = NULL;

ElemType item;

scanf("%c",&item);

if(item != '#')

{

s = Buynode();

s->data = item;

s->leftchild = CreateTree1();

s->rightchild = CreateTree1();

}

return s;

}

//建立二叉树方式二：二级指针 字符串

BtNode * CreateTree3(char ** const pstr)

{

BtNode *s = NULL;

// 二级指针 一级指针 值

if(pstr!=NULL && *pstr!=NULL && **pstr!='#')

{

s=Buynode();

s->data= **pstr;

s->leftchild = CreateTree3(&++*pstr);

s->rightchild = CreateTree3(&++*pstr);

}

return s;

}

//方式三：中序 前序 建立二叉树

int Find(char *is,int n,char ch)

{

for(int i = 0;i

{

if(is[i]==ch)

{

return i;

}

}

return -1;

}

BtNode * Create(char *ps,char *is,int n)

{

BtNode *s = NULL ;

if(n>0)

{

s=Buynode();

s->data = ps[0];

int pos = Find(is,n,ps[0]);

if(pos==-1){exit(1);}

//建立左子树(search,searchLine,len)

s->leftchild = Create(ps+1,is,pos);

//建立右子树 (search,searchLine,len)

s->rightchild = Create(ps+pos+1,is+pos+1,n-pos-1);

}

return s;

}

BtNode * CreatePI(char *ps,char *is)

{

if(ps==NULL || is == NULL)

{

return NULL;

}

else

{

int n = strlen(ps);

Create(ps,is,n);

}

}

// 方式四：中序 后序 建立二叉树

BtNode * CreateTree(char *ls,char *is,int n)

{

BtNode *s =NULL;

if(n>0)

{

int pos = Find(is,n,ls[n-1]);

if(pos==-1){exit(1);}

s=Buynode();

s->data = ls[n-1];

s->leftchild=CreateTree(ls,is,pos);

s->rightchild = CreateTree(ls+pos,is+pos+1,n-pos-1);

}

return s;

}

BtNode * CreateIL(char *is,char *ls)

{

if(is==NULL || ls== NULL)

{

return NULL;

}else

{

int m = strlen(ls); //is

CreateTree(ls,is,m);

}

}

BtNode *FindValue(BtNode *ptr,ElemType x)

{

if(ptr==NULL || ptr->data==x)

{

return ptr;

}

else{

BtNode *p=FindValue(ptr->leftchild,x);

if(p==NULL){

FindValue(ptr->rightchild,x);

}

return p;

}

}

//层序遍历二叉树

int front = 0,rear =1;

void LevelOrder(BtNode *ptr)

{

BtNode *q[100];

q[0]=ptr;

while(front

{

if(q[front]){

printf("%c",q[front]->data);

q[rear++]=q[front]->leftchild;

q[rear++]=q[front]->rightchild;

front++;

}

else

{

front++;

}

}

}

//双分支结点的个数

int SizeBinary(BtNode *ptr)

{

if(ptr == NULL)

{

return -1;

}

else

{

if(ptr->leftchild != NULL && ptr->rightchild != NULL)

{

++count;

SizeBinary(ptr->leftchild);

SizeBinary(ptr->rightchild);

}else

{

if(ptr->leftchild == NULL)

{

SizeBinary(ptr->rightchild);

}else

{

SizeBinary(ptr->rightchild);

}

}

}

}

//寻找孩子结点的双亲结点

BtNode * Paret(BtNode *ptr,BtNode *child){

if(ptr == NULL || ptr->leftchild ==child || ptr->rightchild == child)

{

return ptr;

}

else{

BtNode *p = Paret(ptr->leftchild,child);

if(NULL == p)

{

Paret(ptr->rightchild,child);

}

}

}

BtNode * FindParet(BtNode *ptr,BtNode *child)

{

if(ptr == NULL || child ==NULL || ptr==child)

{

return NULL;

}

else

{

return Paret(ptr,child);

}

}

// 叶子结点个数

int SizeLeaf(BtNode *ptr)

{

if(ptr == NULL)

{

return 0;

}else if(ptr->leftchild==NULL && ptr->rightchild ==NULL)

{

return 1;

}

else

{

return SizeLeaf(ptr->leftchild)+SizeLeaf(ptr->rightchild);

}

}

//结点总个数

int Size(BtNode *ptr){

if(ptr==NULL)

{return 0;}

return 1+Size(ptr->leftchild)+Size(ptr->rightchild);

}

// 树的深度

int Depth(BtNode *ptr)

{

if(ptr==NULL)

{

return 0;

}

int dl=Depth(ptr->leftchild);

int dr=Depth(ptr->rightchild);

return(dl>dr?dl:dr)+1;

}

void main()

{

char *ps = "ABCDEFGH";//前

char *is = "CBEDFAGH";//中

char *ls = "CEFDBHGA";//后

//输入序列建树

printf("请输入先序序列1：\n");

BinaryTree root = NULL;

root = CreateTree1();

//层序遍历二叉树

LevelOrder(root);

//查找

//FindValue(root,'B');

//equal比较两树结构类似 数据相等

char *str = "ABC##DE##F##G#H##";

char *ptr = "ABC##DE##F##H#G##";

BinaryTree root1 = NULL;

BinaryTree root2 = NULL;

root1 = CreateTree3(&str);

root2 = CreateTree3(&ptr);

printf("%d\n",Equal(root1,root2));

int n =Depth(root);

//int &a = 100; // 常量 无地址 不能编译经过

//const int &a =100; //常引用开辟空间

//int a = 10;

//int *ip = &a;

//int *&is = ip;// 指针的 引用

//int &*is; //不容许使用【指针】==》引用

// 测试 后序 中序 创建二叉树

BinaryTree root4= NULL;

root4 = CreateIL(is，ls);

PreOrder(root);

printf("\n");

InOrder(root);

printf("\n");

PastOrder(root);

printf("\n");

//测试 前序 中序 建立二叉树

BinaryTree root5= NULL;

root5= CreatePL(ps，is);

PreOrder(root);

printf("\n");

InOrder(root);

printf("\n");

PastOrder(root);

printf("\n");

}

做业：

// obj1:大数的加减乘除取模判断素数开方次方 文件加密的分布式算法

设计文档+功能函数+模块设计

// obj2:哈夫曼编码 基于哈夫曼编码的文本文件解压缩

// obj3:日历系统 年月日 小时分 对日期进行操做 日程安排表 node

下次函数：

int SizeOne();

int SizeOneLeft();

int SizeOneRight();web

Is_Full_BinaryTree(root); //满二叉树

bool Is_Comp_BinaryTree(BtNode *ptr); //彻底二叉树

bool Is_Balance_BinaryTree(BtNode *ptr); //平衡二叉树算法

//非递归建树 (is ls ps)

void NicePerOrder(BtNode *ptr);

void NiceInOrder(BtNode *ptr);

void NicePastOrder(BtNode *ptr);安全

// 找两个结点的最近公共双亲结点

BtNode * FindNearParet(BtNode *ptr ,BtNode *child1,BtNode *child2);

// 找这个树的最远两个结点的距离 返回两个结点的地址 …能够用结构体存放 地址 + int

int maxPath(BtNode *ptr);

struct RetNode

{

BtNode *child1;

BtNode *child2;

int path;

};

RetNode RetPath(BtNode *ptr);

int RetTwoMaxPath(BtNode ptr,BtNode&child1,BtNode *&child2);多线程

问题：

//引用和指针的区别 引用的特色：逻辑 物理上 分类

// 写一个 栈 队列 k队列 无锁队列 栈满扩容 堆区无空间？？

//如何解决内存不足 单进程无问题 多进程的线程安全 效率 多线程共享

// ++ 叶子结点个数 左分支结点 右分支 双分支？？分布式