二叉树
二叉树代码
二叉树： //先序遍历 void PreOrder(BTNode *t) { if(!t) return; printf("%d ", t->element); PreOrder(t->lChild); PreOrder(t->rChild); } void PreOrderTree(BinaryTree *tree) { if(!tree) return; PreOrder(tree->root); } //求二叉树的高度 int Height(BTNode *t) { if(!t) return 0; int l=Height(t->lChild); int r=Height(t->rChild); if(l>r) return l+1; else return r+1; } //求二叉树中所有节点的数量 void CountNodes(BTNode *t,int *count) { if(!t) return; *count++; CountNodes(t->lChild, count); CountNodes(t->rChild, count); } int CountN(BinaryTree *tree) { if(!tree) return 0; int count=0; CountNodes(tree->root, &count); return count; } //求二叉树中的最大值 void MaxNode(BTNode *t,int *max) { if(!t) return; if(t->element > *max) *max=t->element; MaxNode(t->lChild, max); MaxNode(t->rChild, max); } int MaxTree(BinaryTree *tree) { if(!tree) return -1; int max=-1; MaxNode(tree->root, &max); return max; } //求二叉树中叶子节点的数量 void CountLeaf(BTNode *t,int *count) { if(!t) return; if(!t->lChild && !t->rChild) *count++; CountLeaf(t->lChild, count); CountLeaf(t->rChild, count); } int CountL(BinaryTree *tree) { if(!tree) return 0; int count=0; CountLeaf(tree->root, &count); return count; } //交换二叉树中每个节点的左右子树 void Exchange(BTNode *t) { BTNode *tmp; if(!t) return; tmp=t->lChild; t->lChild=t->rChild; t->rChild=tmp; Exchange(t->lChild); Exchange(t->rChild); } void ExchangeTree(BinaryTree *tree) { if(!tree) return; Exchange(tree->root); } //拷贝一颗二叉树,将q拷贝一份放到p中 void Copy(BTNode *p, BTNode *q) { if(!q) return; p=(BTNode *)malloc(sizeof(BTNode)); p->element=q->element; Copy(p->lChild, q->lChild); Copy(p->rChild, q->rChild); } void CopyTree(BinaryTree *oldtree, BinaryTree *newtree) { if(!oldtree) return; Copy(newtree->root, oldtree->root); } //按先序方法删除一颗二叉树 void Delete(BTNode *t) { BTNode *l,*r; if(!t) return; l=t->lChild; r=t->rChild; free(t); Delete(l); Delete(r); } // 宽度优先遍历 void BFS(BinaryTree *tree) { if(!tree || tree->root) return; Queue Q; //用于存储结点指针的队列 BTNode *p; EnQueue(Q, tree->root); while(!IsEmpty(Q)){ Front(Q, &p); DeQueue(Q); printf("%d ", p->element); if(p->lChild) EnQueue(Q, p->lChild); if(p->rChild) EnQueue(Q, p->rChild); } } //1 利用宽度优先遍历计算度为1的结点的数量 int BFS_Degree1(BinaryTree *tree) { if(!tree || tree->root) return 0; Queue Q; //用于存储结点指针的队列 BTNode *p; int count=0; EnQueue(Q, tree->root); while(!IsEmpty(Q)){ Front(Q, &p); DeQueue(Q); if((p->lChild && !p->rChild) || (!p->lChild && p->rChild)) count++; if(p->lChild) EnQueue(Q, p->lChild); if(p->rChild) EnQueue(Q, p->rChild); } return count; } //2 求二叉树中大于x的节点的数量 void LargeThanX(BTNode *t,int *count, int x) { if(!t) return; if(t->element > x) *count++; LargeThanX(t->lChild, count, x); LargeThanX(t->rChild, count, x); } int LTX(BinaryTree *tree, x) { if(!tree) return 0; int count=0; LargeThanX(tree->root, &count, x); return count; } // 求二叉树的平均值 void Avgerage(BTNode *t,int *total, int *count) { if(!t) return; *total=*total+t->element; *count++; Avgerage(t->lChild, total, count); Avgerage(t->rChild, total, count); } double AvgTree(BinaryTree *tree) { if(!tree) return 0; int count=0; int total=0; Average(tree->root, &total, &count); if(count!=0) return total/count; else return 0; } //求二叉树中比x大的最小数据 void MinLTX(BTNode *t,int *min, int x) { if(!t) return; if(t->element > x && t->element < *min) *min=t->element; MinLTX(t->lChild, min, x); MinLTX(t->rChild, min, x); } int MLTX(BinaryTree *tree, int x) { if(!tree) return -1; int min=99999999; MinLTX(tree->root, &min, x); return min; } //扩展：求二叉搜索树中的最小数据（要求算法时间复杂度不高于log2(n)） int MinBST(BSTree *tree) { BSTNode *p; if(!tree || tree->root) return -1; p=tree->root; while(p->lChild){ p=p->lChild; } return p->element; } //判断以p和q为根的二叉树是否相似 BOOL IsSimilar(BTNode *p, BTNode *q) { if(!p&&q || p&&!q) return FALSE: if(!p&&!q) return TRUE; return IsSimilar(p->lChild, q->lChild)&&IsSimilar(p->rChild, q->rChild); } //计算两棵二叉树的相似度（相似度是指具有相同位置的结点的数量 //与包含结点最多的二叉树的结点数量的比例） void CountSimilarNodes(BTNode *p, BTNode *q, int *count){ if(!p&&q || p&&!q) return : if(!p&&!q) return ; *count++; CountSimilarNodes(p->lChild, q->lChild, count); CountSimilarNodes(p->rChild, q->rChild, count); } void CountNodes(BTNode *t,int *count){ if(!t) return; *count++; CountNodes(t->lChild, count); CountNodes(t->rChild, count); } double Similarity(BinaryTree *tree1, BinaryTree *tree2){ if(!tree1||!tree2) return 0; int count1=0, count2=0,c=0; CountNodes(tree1->root, &count1); CountNodes(tree2->root, &count2); if(count1==0 && count2==0) return 1.0; CountSimilarNodes(tree1->root, tree2->root, &c); if(count1>count2) return c/count1; else return c/count2; } 设计一个算法求二叉树的内路径长度和外路径长度。 算法思想: ipath和outpath分别为二又树的内路径长度和外路径长度变量，h用于记录当前考察节点t的路径长度，初始传入时为0，1初始传入为树根节点，ipath 和epath初始均为0，递归程序如下: (1) 若t为空，则返回: (2)若t为叶子节点，则根据h计算t的外 路径长度，并加入outpath;否则，根据h计算t的内路径长度，并加入inpath: (3) 以t的左子树的根节点指针，inpath, outpath和h+1为参数，递归计算整个二叉树的内路径和外路径长度: (4) 以t的右子树的根节点指针，inpath,epath和h+1为参数，递归计算整个二叉树的内路径和外路径长度。 //level为当前深度 void PL(BTNode *t, int *inpath, int *outpath, int level) { if(!t) return;//边界条件 if(!t->lChild && !t->rChild)//叶子结点，计入外路径长度 *outpath = *outpath + level; else//非叶结点，计入内路径长度 *inpath = *inpath + level; PL(t->lChild, inpath, outpath, level+1);//递归计算左子树 PL(t->rChild, inpath, outpath, level+1);//递归计算右子树 } void GetPL(BinaryTree *tree) { int inpath=0, outpath=0; if(!tree || !tree->root) return ; //如果。。。。 PL(tree->root, &inpath, &outpath, 0); printf("内路径和外路径长度分别为%d和%d",inpath,outpath); } //求二叉树中第i层中的结点的数量 void LevelCount(BTNode *t, int i, int level, int *count) { if(!t) return; if(level==i) *count++; else if(level>i) return; else{ LevelCount(t->lChild, i, level+1, count); LevelCount(t->rChild, i, level+1, count); } } int LCT(BinaryTree *tree, int i) { if(!tree || !tree->root) return 0; int count=0; LevelCount(tree->root, i, 1, &count); return count; } //求二叉树中以元素值为x的节点为根的子树的高度 算法思想：1 采用递归遍历思想，查找值为x的节点p，找到则返回 2 计算以p为根的二叉树的高度，并返回 int Height(BTNode *t){ if(!t) return 0; int l=Height(t->lChild); int r=Height(t->rChild); if(l>r) return l+1; else return r+1; } int HeightX(BTNode *t, int x) { int m, n; if(!t) return 0; if(t->element==x) return Height(t); else{ m=HeightX(t->lChild, x); if(m>0) return m; n=HeightX(t->rChild, x); if(n>0) return n; } return 0; } void FindNode(BTNode *t, int x, BTNode **p){ if(!t) return; if(t->element == x){ *p=t; return; } FindNode(t->lChild, x, p); FindNode(t->rChild, x, p); } int HeightX(BianryTree *tree, int x){ if(!tree || !tree->root) return -1; //如果。。。。 BTNode *p=NULL; FindNode(tree->root, x, &p); if(!p) return 0; // return Height(p); } 补充题：求与值为x的节点在二叉树的同一层的节点的数量（包含值为x的节点） void LevelX(BTNode *t, int x,int *level, int h){ if(!t) return; if(t->element==x){ *level=h; return;} LevelX(t->lChild, x, level, h+1); LevelX(t->rChild, x, level, h+1); } void CountLevel(BTNode *t, int level, int *count, int h){ if(!t) return; if(level==h) *count++; else{ //说明else的原因 CountLevel(t->lChild, level,count, h+1); CountLevel(t->rChild, level,count, h+1); } } int CountLX(BinaryTree *tree, int x){ if(!tree || !tree->root) return -1; //如果。。。。 int count=0, level=0; LevelX(tree->root, x, &level, 1); if(level==0) return 0; // CountLevel(tree->root, level, &count, 1); return count; } //求二叉树的宽度 //计算高度 int Height(BTNode *t) { if(!t) return 0; int l=Height(t->lChild); int r=Height(t->rChild); if(l>r) return l+1; else return r+1; } //递归计算每层的宽度 void Weight(BTNode *t, int w[], int level) { if(!t) return; w[level]++;//该层宽度加一 Weight(t->lChild, w, level+1); Weight(t->rChild, w, level+1); } //基于递归的实现方法（深度优先） int WeightOfTree(BinaryTree *tree) { if（！tree) return 0; int i,max=-1, h = Height(tree-root); int *w=(int*)malloc(sizeof(int)*(h+1)); for(i=0;i<h+1;i++) w[i]=0; Weight(tree->root, w, 1); for(i=1;i<h+1;i++) if(w[i]>max) max=w[i]; return max; } //求指定结点p在给定二叉排序树中的层次 int level(BSTNode *t, BSTNode *p) { int count=0; BSTNode *q; if(!t) return -1; q=t; while(q){ count++; if(q->element==p->element) return count; else if(q->element>p->element) q=q->lChild; else q=q->rChild; } return -1; } //扩展：求二叉树中值为x的节点的层号 void LevelX(BTNode *t, int x,int *level, int h){ if(!t) return; if(t->element==x){ *level=h; return;} LevelX(t->lChild, x, level, h+1); LevelX(t->rChild, x, level, h+1); } //判定给定二叉树是否为二叉排序树 BOOL IsLarger(int x, BTNode *t){ if(!t) return TRUE; return x>t->element && IsLarger(x, t->lChild) && IsLarger(x, t->rChild); } BOOL IsSmaller(int x, BTNode *t){ if(!t) return TRUE; return x<t->element && IsSmaller(x, t->lChild) && IsSmaller(x, t->rChild); } BOOL IsBSTree(BTNode *t) { if(!t) TRUE; int temp=t->element; if(IsLarger(temp, t->lChild) && IsSmaller(temp, t->rChild)) return IsBSTree(t->lChild)&&IsBSTree(t->rChild); else return FALSE; } //判断一棵二叉树是否是满二叉树 int Height(BTNode *t){ if(!t) return 0; int l=Height(t->lChild); int r=Height(t->rChild); if(l>r) return l+1; else return r+1; } void CountNodes(BTNode *t,int *count){ if(!t) return; *count++; CountNodes(t->lChild, count); CountNodes(t->rChild, count); } BOOL IsFullTree(BinaryTree *tree){ if(!tree->root) return TRUE; int h=Height(tree->root); int total=0; CountNodes(tree->root, &total); int x=1, i; for(i=0;i<h;i++) x=x*2; x=x-1; if(x==total) return TRUE; else return FALSE; } //判断一棵二叉树是否是完全二叉树 int Height(BTNode *t){ if(!t) return 0; int l=Height(t->lChild); int r=Height(t->rChild); if(l>r) return l+1; else return r+1; } void mapping(BTNode *t, BTNode *arr[], int i){ if(!t) return; arr[i]=t; mapping(t->lChild, arr, 2*i+1); mapping(t->rChild, arr, 2*i+2); } BOOL IsCompleteTree(BinaryTree *tree){ int h=Height(tree->root); //h表示。。。。。。 int max=1, i; //max表示。。。。。。 for(i=0;i<h;i++) max=max*2; max=max-1; BTNode **arr=(BTNode**)malloc(sizeof(BTNode*)*max); for(i=0;i<x;i++) arr[i]=NULL; //初始化 mapping(tree->root, arr, 0); for(i=0;i<max;i++) if(arr[i]==NULL) break; if(i==max) return TRUE; //当i==max时，当前二叉树为满二叉树，则也是完全二叉树 for(;i<max;i++) if(arr[i]!=NULL) return FALSE: return TRUE; } //试计算二叉树的加权路径长度 void WPL(BTNode *t, int *wpl, int level) { if(!t) return; if(!t->lChild && !t->rChild) *wpl = *wpl + t->element*level; WPL(t->lChild, wpl, level+1); WPL(t->rChild, wpl, level+1); } int GetWPL(BinaryTree *tree) { if(!tree || !tree->root) return -1; //如果。。。。 int wpl=0; WPL(tree->root, &wpl, 0); return wpl; } //利用宽度优先遍历判断完全二叉树 BOOL IsCompleteTree(BinaryTree *tree) { if(!tree->root) return TRUE; Queue Q; //用于存储结点指针的队列 BTNode *p; BOOL flag=FALSE; //是否已发生空指针出队的标记，FALSE表示未发生 EnQueue(Q, tree->root); while(!IsEmpty(Q)){ Front(Q, &p); DeQueue(Q); if(!flag && !p) flag=TRUE; //当出队元素第一次为空时，设置flag=TRUE else if(flag && p)//已有空指针出队的情况下，发现非空结点，则不是完全二叉树 return FALSE; else if(!flag && p){ //未有空指针出队的情况下，非空结点出队，此时将该结点 EnQueue(Q,p->lChild); //的左右孩子（不论是否为空）依次进队 EnQueue(Q,p->rChild); } else if(flag && !p) //已有空指针出队，且当前出队元素为空指针，则继续循环 continue; } return TRUE; } //设计一个尽可能快的算法，求出在一颗二叉排序树中关键字大于k的节点数量 int CountGK(BSTNode *bt,int k) { if(!bt) return 0; return Count(bt->root,k); } int Count(BSTNode *t,ink) { if(t==NULL) return 0; if(t->data<=k) //当前节点的关键字小于等于k时，左子树不必满足条件，无需遍历 return Count(t->rchild); else//当前节点的关键字大于k时，左右子树都要考虑 return 1+Count(t->lchild)+Count(t->rchild); } //判断一个二叉搜索树是否是AVL树 int Height(BTNode *t){ if(!t) return 0; int l=Height(t->lChild); int r=Height(t->rChild); if(l>r) return l+1; else return r+1; } BOOL IsAVL(BTNode *t) { if(!t) return TRUE; int l=Height(t->lChild); //计算左子树的高度 int r=Height(t->rCHild); //计算右子树的高度 if(l-r>1 || l-r<-1) //判断当前结点是否符合AVL树的定义 return FALSE; else return IsAVL(t->lChild)&&IsAVL(t->rChild); } BOOL IsAVLTree(BinaryTree *tree) { return IsAVL(tree->root); } //判断一棵二叉树是否是二叉搜索树 BOOL IsLarge(BTNode *t, int x) //判断x是否大于t中的所有结点 { if(!t) return TRUE; return x>t->element && IsLarge(t->lChild, x) && IsLarge(t->rChild, x); } BOOL IsSmall(BTNode *t, int x) //判断x是否小于t中的所有结点 { if(!t) return TRUE; return x<t->element && IsSmall(t->lChild, x) && IsSmall(t->rChild, x); } BOOL IsBST(BTNode *t) { if(!t) return TRUE; BOOL flag = IsLarge(t->lChild, t->element) && IsSmall(t->rChild, t->element); return flag && IsBST(t->lChild) && IsBST(t->rChild); } //判断二叉树中节点p和q的祖先后裔关系 BOOL IsInTree(BTNode *t, BTNode *p) { if(!t) return FALSE; return t==p || IsInTree(t->lChild, p) || IsInTree(t->rChild, p); } void IsAncestor(BTNode *p, BTNode *q) { if(IsInTree(p, q)) printf("p is a ancestor of q!"); else if(IsInTree(q, p)) printf("q is a ancestor of p!"); } //判断二叉树中节点p和q的兄弟关系 void IsSibiling(BTNode *t, BTNode *p, BTNode *q, int *flag) { if(!t) return ; if((t->lChild==p && t->rChild==q)||(t->lChild==q && t->rChild==p)) *flag=1; IsSibiling(t->lChild, p, q); IsSibiling(t->rChild, p, q); } BOOL Brothers(BinaryTree *tree, BTNode *p, BTNode *q) { int flag=0; if(!tree||!tree->root) return FALSE; IsSibiling(tree->root, p, q, &flag); if(flag) return TRUE; else return FALSE; } //判断A和B之间是否有祖先后裔关系 void Find(BTNode *t, BTNode **node, int x) { if(!t) return; if(t->element==x){ *node=t; return; } Find(t->lChild, node, x); Find(t->rChild, node, x); } void Level(BTNode *t, int x, int *le, int t_level) //返回x所在层的层号 { if(!t) return; if(t->element == x){ *le=t_level; return;} Level(t->lChild, x, le,t_level+1); Level(t->rChild, x, le,t_level+1); } BOOL JudgeAncestor(BinaryTree *tree, int A, int B) { BTNode *p==NULL, *q=NULL; int A_level=-1, B_level=-1; Level(tree->root, A, &A_level, 1); Level(tree->root, B, &B_level, 1); if(A_level==-1 || B_level==-1) { printf("不存在祖先后裔关系\n");return FALSE;} if(A_level<B_level){ Find(tree->root, &p, A); Find(p, &q, B); if(!q) {printf("不存在祖先后裔关系\n"); return FALSE}; else {printf("A是B的祖先\n")；return TRUE;} } else{ Find(tree->root, &p, B); Find(p, &q, A); if(!q) { printf("不存在祖先后裔关系\n");return FALSE; } else { printf("B是A的祖先\n"); return TRUE; } } } //p和q分别为二叉树中任意两个结点，试编写算法查找找到p和q的最近公共祖先结点 BOOL IsAncestor(BTNode *t, BTNode *p, Stack *S)//判断t是否是x的祖先，若是则将t进栈 { if(!t) return FALSE; if(t==p || IsAncestor(t->lChild, p, S) || IsAncestor(t->rChild, p, S)){ Push(S, t); return TRUE; } return FALSE; } BTNode *FindNA(BTNode *t, BTNode *p, BTNode *q) { Stack S1, S2; if(!IsAncestor(t, p, S1)) {printf("p节点不存在"); return NULL}; if(!IsAncestor(t, q, S2)) {printf("q节点不存在"); return NULL}; BTNode *tp=NULL; while(Top(S1)==Top(S2)){ tp=Top(S1); Pop(S1); Pop(S2); } return tp; } //已知A和B具有祖先后裔关系，求A和B之间的距离（即A和B之间的路径长度） void Level(BTNode *t, int A, int B, int *la, int *lb, int t_level) { if(!t) return; if(t->element == A) *la=t_level; if(t->element == B) *lb=t_level; if(*la != -1 && *lb != -1) //用于在完成A和B的层号计算的前提下，提前退出递归 return; //该判断语句块可以不要 Level(t->lChild, x, le,t_level+1); Level(t->rChild, x, le,t_level+1); } int Distance(BinaryTree *tree, int A, int B) { if(!tree) return -1; int A_level=-1, B_level=-1; Level(tree->root, A, B, &A_level, &B_level, 1); if(A_level==-1 || B_level==-1) return -1; if(A_level>B_level) return A_level-B_level; else return B_level-A_level; } //求A和B的最近共同祖先 BOOL IsInTree(BTNode *t, int x) //判断x是否在t树中 { if(!t) return FALSE; if(t->element == x) return TRUE; return IsInTree(t->lChild, x) || IsInTree(t->rChild, x); } void FindAllAncestors(BTNode *t, int t_level, int x, BTNode *arr[]) { ////将x的祖先结点从上到下依次存储到数组中 if(!t) return; if(IsInTree(t, x)){ arr[t_level]=t; FindAllAncestors(t->lChild, t_level+1, x, arr); FindAllAncestors(t->rChild, t_level+1, x, arr); } else return; } int Height(BTNode *t){ if(!t) return 0; int l=Height(t->lChild); int r=Height(t->rChild); if(l>r) return l+1; else return r+1; } BTNode *GetNearestAncestor(BinaryTree *tree, int A, int B) { int h=Height(tree->root); int i; BTNode **arrA=(BTNode**)malloc(sizeof(BTNode*)*h); BTNode **arrB=(BTNode**)malloc(sizeof(BTNode*)*h); for(i=0;i<h;i++) arrA[i]=arrB[i]=NULL; FindAllAncestors(tree->root, 0, A, &arrA); //将A的祖先结点从上到下依次存储到数组中 FindAllAncestors(tree->root, 0, B, &arrB); //将B的祖先结点从上到下依次存储到数组中 for(i=h-1;i>=0;i--) //从后向前寻找相同且不为空的结点，该结点即为最近的共同祖先 if(arrA[i]==arrB[i] && arrA[i]!=NULL) return arrA[i]; }
