@[TOC]二叉树代码部分
二叉树的链式存储结构
typedef struct bitnode{
Elemtype data;
struct bitnode *lchild ,*rchild;
}bidnode ,*bitree二叉树的遍历(递归调用)
先序遍历：
void preorder(bitree (T))
if（T!=NULL）{
visit(T);
preorder(T->lchild);
preorder(T->rchild);
}
}中序遍历：
void inorder(bitree T）{
if(T!=NULL){
inorder (T->lchild);
visit(T);
inorder(T->rchild);
}
}后序遍历：
void postorder(bitree){
if(T!=NULL){
postorder(T->lchild);
postorder(T->rchild);
visit(T);
}
}递归算法和非递归算法的转化
中序遍历的非递归调用算法：
void inorder2(bitree T){
initstack(s);//初始化了一个栈s
bitree p=T;//把T的地址给了指针变量p
while(p||!Isempty(S)){
//啥时候循环？p=1即p不空，!Isempty(s)是指栈不空；最后栈空而且p=NULL
if(p){
push(s,p);
p=p->lchild
}
else{
pop(s,p);//意思就是出栈栈顶元素（这里的p你就理解成栈顶元素的地址就行了）
visit(p);
p=p->rchild;
}
}
}先序遍历的非递归算法：
void preorder2(bitree T){
initstack(s);
bitree p=T;
while(p||!isempty(S)){
if(p){
visit(p);//先访问p结点
push(s,p);//把该点压入栈中
p=p->lchild;//把左孩子的结点的地址给变量p
}
else{
pop(s,p);
p=p->rchild;
}
}
}后序遍历的非递归算法:
void levellorder(bitree T){
initqueue(Q);//初始化队列
Bitree p;//定义p指针，指向二叉树结点类型的结构
Enqueue(Q,p);//根结点入队；
while(!Isempty(Q)){
Dequeue(Q,p);//出队
visit(p);
if(p->lchild!=NULL)
enqueue(q,p->lchild);
if(p->rchild!=NULL)
enqueue(q,p->rchild);
}
}线索二叉树
线索二叉树的储存结构;
typedef struct threadnode{
elemtype data;
struct threadnode *lchild,*rchild;
int ltag,rtag;
}threadnode,*threadtree;中序线索二叉树的构造：
void createinthread(threadtree T){
threadtree pre=NULL;
if(T!=NULL){
inthread(T,pre);//非空二叉树 线索化
pre->rchild=NULL;//处理遍历的最后一个结点
pre->rtag=1;
}
}
void inthread(threadtree &p,threadtree &pre){
if(p!=NULL){
InThread(p->lchild,pre);
if(p->lchild==NULL){
P->lchild=pre;
p->ltag=1;
}
if(pre!=NULL&&pre->rchild==NULL)
pre->rchild=p;
pre->rtag=1;
}
pre=p;
inthread(p->rchild,pre);
}中序线索二叉树的遍历
threadnode *firstnode(threadnode *p){
while(p->ltag==0)
p=p->lchild;
return p;
}
threadnode *nextnode(threadnode *p){
if(p->rtag==0) return firstnode(p->rchild);
else return p->rchild;
}
void inorder (threadnode *p){
for(threadnode*p=firstnode(T);p=NULL;p=Nextnode(p))
visit(p);
}树的存储结构
双亲表示法：
#define max_tree_size 100
typedef struct{
elemtype data;
int parent;
}ptnode;
typedef struct{
ptnode nodes[max_tree_size];
int n;
}ptree;孩子表示法：
#define max_tree_size 100
typedef struct{
int child;
struct cnode *next;
}cnode;
typedef struct{
elemtype data;
struct cnode *child;
}pnode;
typedef struct{
pnode nodes[max_tree_size];
int n;
}ctree; 孩子兄弟表示法;
typedef struct csnode{
elemtype data;
struct csnode *firstchild,*nextsibling;
}csnode,cstree;并查集
并查集采用的是双亲表示(顺序存储结构)：
结构定义如下：
#define max_tree_size 100
typedef struct{
elemtype data;
int parent;
}ptnode;
typedef struct{
ptnode nodes[max_tree_size];
int n;
}ptree;
由于data与数组编号一样的，那么就不需要上面这样定义结构体了
直接定义一个一维数组就可以了；
并查集结构定义如下：
#define SIZE 100
int ufsets[SIZE];
初始化：
Initial(S);
void Initial(int S[]){
for(int i=0;i<size;I++)
S[I]=-1;
}
查找操作：
Find(S,x);
int Find(int S[],int x){
while(S[x]>=0)
x=S[x];
return x;
}
合并操作：
Union（S,Root1,Root2);
void Union(int S[],int root1,int root2){
S[Root2]=Root1;
}
树与二叉树的应用
二叉排序树
查找非递归调用算法：
BSTnode *BST_search(bitree T,Elemtype key{
while(T!=NULL&&key!=T->data){
if(key<T->data)
T=T->lchild;
else
T=T->rchild;
}
return T;
}
插入：
int BST_Insert (Bitree &T,KeyType k){
if(T==NULL){
T=(BiTree)malloc(sizeof(BSTNode));
T->key=k;
T->lchild=T->rchild=NULL;
return 1;
}
else if(k==T->key)
return 0;
else if(k<T->key)
return BST_Insert(T->lchild,k);
else
return BST_insert(T->rchild,k);
}
构造：
void Creat_BST(Bitree &T,KeyType str[],int n){
T=NULL;
int i=0;
while(i<n){
BST_Insert(T,str[i]);
i++;
}
}平衡二叉树：
判断：
void Judge AVL(Bitree bt,int &balance ,int &h){
//bt是一个树的指针地址，balance,h分别是两个可以改变的数值.balance 1是平衡，0是不平衡
//为什么用引用，因为把该类型的变量传入函数中，调用的函数会对参数进行修改，之后要利用这些修改的参数值，所以用引用；
int bl=0,br=0,hl=0,hr=0;
if(bt==NULL){
h=0;
balance=1;
}
else if(bt->lchild==NULL&&bt->rchild==NULL){
h=1;
balance=1;
}
else{
Judge_AVL(bt->lchild,b1,h1);//函数调用
Judge_AVL(bt->rchild,br,hr);
if(hl>hr)
h=hl+1;
else
h=hr+1;
if(abs(h1-hr)<2&&b1==1&&br==1)
balance=1;
else
balance=0;
}
}二叉树的应用
哈夫曼编码
固定长度编码：000001010010011100101011010110
helloworld
000 h
001 e
010 l
011 o
100 w
101 r
110 d可变长度编码：
helloworld:0001001101110000
00 h
01 e
0 l
1 o
10 w
11 r
000 但是这种可变编码是无法实现的