广工anyview数据结构-07~08（乱码不贴）

/**********

【题目】试编写如下定义的递归函数的递归算法:

g(m,n) = 0 当m=0,n>=0

g(m,n) = g(m-1,2n)+n 当m>0,n>=0

**********/

int G(int m, int n)

/* 如果 m<0 或 n<0 则返回 -1 */

{

if(m<0||n<0) return -1;

if(m==0&&n==0) return 0;

if(m>0&&n>=0) return G(m-1,2*n)+n;

}

/**********

【题目】试写出求递归函数F(n)的递归算法：

F(n) = n+1 当n=0

F(n) = nF(n/2) 当n>0

**********/

int F(int n)

/* 如果 n<0 则返回 -1 */

{

if(n==0) return 1;

else if(n<0) return -1;

else if(n>0) return F(n/2)*n;

}

/**********

【题目】求解平方根 的迭代函数定义如下：

sqrt(A,p,e) = p 当|p*p-A|<e

sqrt(A,p,e) = sqrt(A,(p+A/p)/2,e) 当|p*p-A|>=e

其中，p是A的近似平方根，e是结果允许误差。试写出相

应的递归算法。

**********/

float Sqrt(float A, float p, float e)

{

if(-e<p*p-A&&p*p-A<e) return p;

else return Sqrt(A,(p+A/p)/2,e);

}

/**********

【题目】已知Ackerman函数的定义如下：

akm(m,n) = n+1 当m=0

akm(m,n) = akm(m-1,1) 当m!=0,n=0

akm(m,n) = akm(m-1,akm(m,n-1)) 当m!=0,n!=0

请写出递归算法。

**********/

int Akm(int m, int n)

/* 若 m<0 或 n<0 则返回-1 */

{

if(m<0||n<0)return -1;

else if(m==0)return n+1;

else if(m!=0&&n==0)return Akm(m-1,1);

else if(m!=0&&n!=0)return Akm(m-1,Akm(m,n-1)) ;

}

/**********

【题目】试写出求递归函数F(n)的非递归算法：

F(n) = n+1 当n=0

F(n) = nF(n/2) 当n>0

**********/

int F(int n)

/* 如果 n<0 则返回 -1 */

{

if(n<0)return -1;

else if(n==0)return 1;

else return n*F(n/2);

}

/**********

【题目】求解平方根 的迭代函数定义如下：

sqrt(A,p,e) = p 当|p*p-A|<e

sqrt(A,p,e) = sqrt(A,(p+A/p)/2,e) 当|p*p-A|>=e

其中，p是A的近似平方根，e是结果允许误差。试写出相

应的非递归算法。

**********/

float Sqrt(float A, float p, float e)

{

if(-e<p*p-A&&p*p-A<e) return p;

else return Sqrt(A,(p+A/p)/2,e);

}

/**********

【题目】假设以二维数组g[1..m][1..n]表示一个图像

区域，g[i][j]表示该区域中点(i,j)所具颜色，其值

为从0到k的整数。试编写递归算法，将点(i0,j0)所在

区域的颜色置换为颜色c。约定与(i0,j0)同色的上、

下、左、右的邻接点为同色区域的点。

表示图像区域的类型定义如下：

typedef char GTYPE[m+1][n+1];

**********/

void ChangeColor(GTYPE g, int m, int n,

char c, int i0, int j0)

/* 在g[1..m][1..n]中，将元素g[i0][j0] */

/* 所在的同色区域的颜色置换为颜色c */

{

char color=g[i0][j0];

g[i0][j0]=c;

if(i0-1>=1&&g[i0-1][j0]==color)

ChangeColor(g,m,n,c,i0-1,j0);

if(j0-1>=1&&g[i0][j0-1]==color)

ChangeColor(g,m,n,c,i0,j0-1);

if(i0+1<=m&&g[i0+1][j0]==color)

ChangeColor(g,m,n,c,i0+1,j0);

if(j0+1<=n&&g[i0][j0+1]==color)

ChangeColor(g,m,n,c,i0,j0+1);

}

/**********

【题目】若两棵二叉树T1和T2皆为空，或者皆不空

且T1的左、右子树和T2的左、右子树分别相似，则

称二叉树T1和T2相似。试编写算法，判别给定两棵

二叉树是否相似。

二叉链表类型定义：

typedef struct BiTNode {

TElemType data;

struct BiTNode *lchild, *rchild;

} BiTNode, *BiTree;

**********/

Status Similar(BiTree T1, BiTree T2)

/* 判断两棵二叉树是否相似的递归算法 */

{

if(!T1&&!T2)return TRUE;

else if(T1&&T2&&Similar(T1->lchild,T2->lchild)&&Similar(T1->rchild,T2->rchild)) return TRUE;

else return FALSE;

}

/**********

【题目】编写递归算法，求对二叉树T先序遍历时

第k个访问的结点的值。

二叉链表类型定义：

typedef struct BiTNode {

TElemType data;

struct BiTNode *lchild, *rchild;

} BiTNode, *BiTree;

**********/

int countNodes(BiTree bt){

return bt?(1 + countNodes(bt->lchild)+countNodes(bt->rchild)):0;

}

TElemType PreOrderK(BiTree T, int k)

/* 求对二叉树T先序遍历时第k个访问的结点的值。*/

/* 若失败，则返回'#' */

{

int count;

if(k <=0||!T) return '#';

if(k==1) return T->data;

count=countNodes(T->lchild);

return count>=--k?PreOrderK(T->lchild,k):PreOrderK(T->rchild,k-count);

}

/**********

【题目】编写递归算法，计算二叉树T中叶子结点的数目。

二叉链表类型定义：

typedef struct BiTNode {

TElemType data;

struct BiTNode *lchild, *rchild;

} BiTNode, *BiTree;

**********/

int Leaves(BiTree T)

/* 计算二叉树T中叶子结点的数目 */

{

if(NULL==T) return 0;

if(NULL == T->lchild && NULL == T->rchild ) return 1;

return Leaves(T->lchild)+Leaves(T->rchild);



}

/**********

【题目】试利用栈及其基本操作写出二叉树T的非递归

的先序遍历算法。

二叉链表类型定义：

typedef struct BiTNode {

TElemType data;

struct BiTNode *lchild,*rchild;

} BiTNode, *BiTree;

可用栈类型Stack的相关定义：

typedef BiTree SElemType; // 栈的元素类型

Status InitStack(Stack &S);

Status StackEmpty(Stack S);

Status Push(Stack &S, SElemType e);

Status Pop(Stack &S, SElemType &e);

Status GetTop(Stack S, SElemType &e);

**********/

void PreOrder(BiTree T, void (*visit)(TElemType))

/* 使用栈，非递归先序遍历二叉树T， */

/* 对每个结点的元素域data调用函数visit */

{

Stack S;

BiTree p;

if(!T)return;

InitStack(S);

do{

visit(T->data);

if(!T->lchild&&!T->rchild){

while(!StackEmpty(S)){

if(GetTop(S,p)&&p->rchild&&p->rchild!=T)

{T=p->rchild;break;}

Pop(S,T);

}

}

else {

Push(S,T);

T=(T->lchild)?T->lchild:T->rchild;}

}while(!StackEmpty(S));

}

/**********

【题目】试利用栈及其基本操作写出二叉树T的非递归

的后序遍历算法(提示：为分辨后序遍历时两次进栈的

不同返回点，需在指针进栈时同时将一个标志进栈）。

二叉链表类型定义：

typedef struct BiTNode {

TElemType data;

struct BiTNode *lchild,*rchild;

} BiTNode, *BiTree;

可用栈类型Stack的相关定义：

typedef struct {

struct BiTNode *ptr; // 二叉树结点的指针类型

int tag; // 0..1

} SElemType; // 栈的元素类型

Status InitStack(Stack &S);

Status StackEmpty(Stack S);

Status Push(Stack &S, SElemType e);

Status Pop(Stack &S, SElemType &e);

Status GetTop(Stack S, SElemType &e);

**********/

void PostOrder(BiTree T, void (*visit)(TElemType))

/* 使用栈，非递归后序遍历二叉树T， */

/* 对每个结点的元素域data调用函数visit */

{

Stack S;

InitStack(S);

SElemType e;

BiTree p=T;

int tag=0;

if(T){

e.tag=0;

while(!StackEmpty(S)||p==T){

while(p&&!tag){

e.ptr=p;

if(p->lchild){

p=p->lchild;

e.tag=0;

}

else{

p=p->rchild;

e.tag=1;

}

Push(S,e);

}//while

GetTop(S,e);

if(!StackEmpty(S)&&e.tag){

Pop(S,e);

p=e.ptr;

visit(p->data);

}

if(!StackEmpty(S)){

Pop(S,e);

p=e.ptr;

if(e.tag){

visit(p->data);

p=NULL;

}

else{

if(p->rchild){

p=p->rchild;

tag=0;

e.tag=1;

Push(S,e);

}

else{

visit(p->data);

p=NULL;

}

}

}

else{

p=NULL;

}

}

}

}

/**********

【题目】二叉树采用三叉链表的存储结构，试编写

不借助栈的非递归中序遍历算法。

三叉链表类型定义：

typedef struct TriTNode {

TElemType data;

struct TriTNode *parent, *lchild, *rchild;

} TriTNode, *TriTree;

**********/

void InOrder(TriTree PT, void (*visit)(TElemType))

/* 不使用栈，非递归中序遍历二叉树PT， */

/* 对每个结点的元素域data调用函数visit */

{

TriTNode *p;

p=PT;

while(p->lchild) p=p->lchild;

while(p){

visit(p->data);

if(p->rchild){

p=p->rchild;

while(p->lchild) p=p->lchild;

}

else if(p->parent->lchild==p) p=p->parent;

else

{

p=p->parent;

while(p->parent&&p->parent->rchild==p)

p=p->parent;

p=p->parent;

}

}

}

/**********

【题目】假设在三叉链表的结点中增设一个标志域

(mark取值0,1或2)以区分在遍历过程中到达该结点

时应继续向左或向右或访问该结点。试以此存储结

构编写不用栈辅助的二叉树非递归后序遍历算法。

带标志域的三叉链表类型定义：

typedef struct TriTNode {

TElemType data;

struct TriTNode *lchild, *rchild, *parent;

int mark; // 标志域

} TriTNode, *TriTree;

**********/

void PostOrder(TriTree T, void (*visit)(TElemType))

/* 不使用栈，非递归后序遍历二叉树T， */

/* 对每个结点的元素域data调用函数visit */

{

TriTree p;

p=T;

while(p){

while(p->mark==0){

p->mark=1;

if(p->lchild)

p=p->lchild;

}

while(p->mark==1){

p->mark=2;

if(p->rchild)

p=p->rchild;

}

if(p->mark==2){

visit(p->data);

p=p->parent;

}

}

}

/**********

【题目】编写递归算法，将二叉树中所有结点的

左、右子树相互交换。

二叉链表类型定义：

typedef struct BiTNode {

TElemType data;

struct BiTNode *lchild, *rchild;

} BiTNode, *BiTree;

**********/

void ExchangeSubTree(BiTree &T)

/* 将二叉树中所有结点的左、右子树相互交换 */

{

if (T == NULL) return;

BiTree pn = T->lchild;

T->lchild = T->rchild;

T->rchild = pn;

ExchangeSubTree(T->lchild);

ExchangeSubTree(T->rchild);

}

/**********

【题目】编写递归算法：求二叉树中以元素值

为x的结点为根的子树的深度。

二叉链表类型定义：

typedef struct BiTNode {

TElemType data;

struct BiTNode *lchild, *rchild;

} BiTNode, *BiTree;

**********/

int GetDepth(BiTree bt)//求树的深度子函数

{

int m,n; //记录返回的个数

if(bt) //非空执行

{

m=GetDepth(bt->lchild); //对左子树递归

n=GetDepth(bt->rchild); //对右子树递归

return (m>=n?m+1:n+1); //返回最深的度数

}

else //bt空，返回0

return 0;

}

int Depthx(BiTree T, TElemType x)

/* 求二叉树中以值为x的结点为根的子树深度 */

{

int m,n;

if(!T) //空，返回0

return 0;

if(T->data==x) //找到T，求T的深度

return GetDepth(T); //返回T的深夜

else

{

if(T->lchild) //向左子树找T

m=Depthx(T->lchild,x);

if(T->rchild) //向右子树找T

n=Depthx(T->rchild,x);

}

return (m>=n?m:n); //返回向下递归的最大深度

}

/**********

【题目】编写递归算法：对于二叉树中每一个元素值为x

的结点，删去以它为根的子树，并释放相应的空间。

二叉链表类型定义：

typedef struct BiTNode {

TElemType data;

struct BiTNode *lchild, *rchild;

} BiTNode, *BiTree;

**********/

void DelTree(BiTree bt, TElemType x)

{

if(bt)

{if(bt->lchild&&bt->lchild->data==x)

{free(bt->lchild);

bt->lchild=NULL;

}

if(bt->rchild&&bt->rchild->data==x)

{free(bt->rchild);

bt->rchild=NULL;

}

DelTree(bt->lchild,x);

DelTree(bt->rchild,x);

}

}

void ReleaseX(BiTree &T, char x)

/* 对于二叉树T中每一个元素值为x的结点， */

/* 删去以它为根的子树，并释放相应的空间 */

{

if(T!= NULL&&T->data==x)

{free(T);T=NULL;}

else DelTree(T,x);

}

/**********

【题目】编写复制一棵二叉树的递归算法。

二叉链表类型定义：

typedef char TElemType; // 设二叉树的元素为char类型

typedef struct BiTNode {

TElemType data;

struct BiTNode *lchild, *rchild;

} BiTNode, *BiTree;

**********/

void CopyBiTree(BiTree T, BiTree &TT)

/* 递归复制二叉树T得到TT */

{

BiTree lptr,rptr;

if (!T) T=NULL;

else{

CopyBiTree(T->lchild,lptr);

CopyBiTree(T->rchild,rptr);

TT=(BiTree)malloc(sizeof(BiTNode));

TT->data=T->data;

TT->lchild=lptr;TT->rchild=rptr;

}

}

/**********

【题目】编写算法判别给定二叉树是否为完全二叉树。

二叉链表类型定义：

typedef struct BiTNode {

TElemType data;

struct BiTNode *lchild, *rchild;

} BiTNode, *BiTree;

可用队列类型Queue的相关定义：

typedef BiTree QElemType; // 设队列元素为二叉树的指针类型

Status InitQueue(Queue &Q);

Status EnQueue(Queue &Q, QElemType e);

Status DeQueue(Queue &Q, QElemType &e);

Status GetHead(Queue Q, QElemType &e);

Status QueueEmpty(Queue Q);

**********/

Status CompleteBiTree(BiTree T)

/* 判别二叉树T是否为完全二叉树 */

{

int flag=0,top=0;

BiTree stack[100];

Queue Q;

BiTree p;

InitQueue(Q);

if(T){

EnQueue(Q,T);

while(!QueueEmpty(Q)){

DeQueue(Q,p);

if(p){

EnQueue(Q,p->lchild);

EnQueue(Q,p->rchild);

stack[top++]=p->lchild;

stack[top++]=p->rchild;

}

}//while

while(top){

if(flag){

if(stack[--top]==NULL)

return FALSE;

}

else{

if(stack[--top]!=NULL){//遇到第一个非NULL结点

flag=1;

}

}

}

}//if

return TRUE;

}

/**********

【题目】试编写一个二叉排序树的判定算法。

二叉排序树的类型BSTree定义如下：

typedef struct {

KeyType key;

... ... // 其他数据域

} TElemType;

typedef struct BiTNode {

TElemType data;

struct BSTNode *lchild, *rchild;

}BSTNode, *BSTree;

**********/

Status IsBSTree(BSTree T)

/* 判别二叉树T是否为二叉排序树。*/

/* 若是，则返回TRUE，否则FALSE */

{

KeyType k;

if(T==NULL)return TRUE;

k=T->data.key;

if(T->lchild==NULL&&T->rchild==NULL)return TRUE;

if(T->lchild!=NULL&&T->rchild!=NULL)

{

if(k>T->lchild->data.key&&k<T->rchild->data.key)

if(IsBSTree(T->lchild)&&IsBSTree(T->rchild))

return TRUE;

return FALSE;

}

if(T->lchild!=NULL&&k>T->lchild->data.key)

if(IsBSTree(T->lchild))return TRUE;

if(T->rchild!=NULL&&k<T->rchild->data.key)

if(IsBSTree(T->rchild))return TRUE;

return FALSE;

}

/**********

【题目】编写递归算法，从大到小输出给定二叉排序树

中所有关键字不小于x的数据元素。

二叉排序树的类型BSTree定义如下：

typedef struct {

KeyType key;

... ... // 其他数据域

} TElemType;

typedef struct BSTNode {

TElemType data;

struct BSTNode *lchild,*rchild;

}BSTNode, *BSTree;

**********/

void OrderOut(BSTree T, KeyType k, void(*visit)(TElemType))

/* 调用visit(T->data)输出 */

{

KeyType key = T->data.key;

if(!T)return;

if(key>=k)

{

OrderOut(T->rchild,k,visit);

visit(T->data);

OrderOut(T->lchild,k,visit);

}

else{ OrderOut(T->rchild,k,visit);}

}

/**********

【题目】试写一非递归算法，在二叉查找树T中插入元素e。

二叉查找树的类型BSTree定义如下：

typedef struct {

KeyType key;

... ... // 其他数据域

} TElemType;

typedef struct BSTNode {

TElemType data;

struct BSTNode *lchild,*rchild;

} BSTNode, *BSTree;

**********/

Status InsertBST_I(BSTree &T, TElemType k)

/* 在二叉查找树T中插入元素e的非递归算法 */

{

BSTree q,s,p=T;

q=(BSTNode *)malloc(sizeof(BSTNode));

if(NULL==q)return OVERFLOW;

q->data.key=k.key;

q->lchild=q->rchild=NULL;

while(p){

if(p->data.key==k.key)return TRUE;

s=p;

p=(p->data.key>k.key)?p->lchild:p->rchild;

}



if(T==NULL)T=q;

else if(k.key<s->data.key)

s->lchild=q;

else s->rchild=q;

}

/**********

【题目】试编写算法，求二叉树T中结点a和b的最近共同祖先。

二叉链表类型定义：

typedef struct BiTNode {

TElemType data;

struct BiTNode *lchild,*rchild;

} BiTNode, *BiTree;

可用栈类型Stack的相关定义：

typedef struct {

BiTNode *ptr; // 二叉树结点的指针类型

int tag; // 0..1

} SElemType; // 栈的元素类型

Status InitStack(Stack &S);

Status StackEmpty(Stack S);

int StackLength(SqStack S);

Status Push(Stack &S, SElemType e);

Status Pop(Stack &S, SElemType &e);

Status GetTop(Stack S, SElemType &e);

**********/

//封装压栈方法

Status Push_c(BiTree T, Stack &S)

{

SElemType sElem;

sElem.ptr=T;

return Push(S,sElem);

}

//将到目标元素的最短路径存起来

Status collect(BiTree T, TElemType a, Stack &S)

{

if(NULL==T) return FALSE;

if(a==T->data) return Push_c(T,S);

else if(collect(T->lchild,a,S)) return Push_c(T,S);

else if(collect(T->rchild,a,S)) return Push_c(T,S);

else return FALSE;

}

//查找栈内时候有跟目标元素相同的元素

Status search(Stack S,BiTNode *t)

{

SElemType e;

while(!StackEmpty(S))

{

if(Pop(S,e))

if(e.ptr->data==t->data)

return TRUE;

}

return FALSE;

}

//将栈倒置

Stack reverse(Stack &S)

{

SElemType sE;

Stack t; InitStack(t);

while(!StackEmpty(S))

{

if(Pop(S,sE))

Push(t,sE);

}

return t;

}

//比较两个栈的元素，查找最近的两个相同的元素

BiTree Comn(BiTree T, TElemType a, TElemType b, Stack S_a, Stack S_b)

{

SElemType e;

S_b=reverse(S_b);

S_a=reverse(S_a);

while(!StackEmpty(S_a))

{

if(Pop(S_a,e)&&e.ptr->data!=b)

if(search(S_b,e.ptr))

return e.ptr;

}

return NULL;

}

BiTree CommAncestor(BiTree T, TElemType a, TElemType b)

/* 求二叉树T中结点a和b的最近共同祖先 */

{

Stack S_a,S_b;

BiTree biT;

int flag;

if(NULL==T) return NULL;

if(T->data==a||T->data==b) return NULL;//当a或b所在节点为根节点时，a和b没有共同的祖先

if(!InitStack(S_a)||!InitStack(S_b)) return NULL;

if(!collect(T,a,S_a)||!collect(T,b,S_b)) return NULL;

flag=StackLength(S_a)>StackLength(S_b)?1:0;//比较两个路径的长度，可能有利于提高查找效率，可行性待定

if(flag&&(biT=Comn(T,a,b,S_a,S_b))!=NULL) return biT;

else return Comn(T,b,a,S_b,S_a);

}

/**********

【题目】在平衡二叉排序树的每个结点中增设一个

lsize域，其值为该结点的左子树中的结点数加1。

试编写时间复杂度为O(logn)的算法，求树中第k小

的结点的位置。

平衡二叉查排序树的类型BBSTree定义如下：

typedef char KeyType;

typedef struct BBSTNode {

KeyType key;

struct BBSTNode *lchild,*rchild;

int bf; // 平衡因子

int lsize; // 新增域，值为左子树的结点数+1

} BBSTNode, *BBSTree;

**********/

BBSTNode *Ranking(BBSTree T, int k)

/* 在含lsize域的平衡二叉排序树T中，*/

/* 求指向T中第k小的结点的指针 */

{

if(k>T->lsize)

{

if(!T->rchild) return NULL;

return(Ranking(T->rchild,k-T->lsize));

}

else if(k<T->lsize)

return (Ranking(T->lchild,k));

return T;

}

/**********

【题目】假设二叉排序树T的每个结点的平衡因子域bf当前

均为0。试编写算法，求二叉排序树T的深度，并为每个结点

的bf域赋予正确的平衡因子值。

平衡二叉排序树的类型BBSTree定义如下：

typedef char KeyType;

typedef struct BBSTNode {

KeyType key;

int bf; // 平衡因子

struct BBSTNode *lchild,*rchild;

} BBSTNode, *BBSTree;

**********/

int Depth_BF(BBSTree T)

/* 求二叉排序树T的深度，并为每个结点 */

/* 的bf域赋予正确的平衡因子值。 */

{

int dl,dr,s;

if(NULL==T)return 0;

else{

dl=Depth_BF(T->lchild);

dr=Depth_BF(T->rchild);

T->bf=dl-dr;

s=dl>dr?dl:dr;

return 1+s;

}

}

/**********

【题目】编写平衡二叉排序树的右平衡处理算法。

平衡二叉排序树的类型BBSTree定义如下：

typedef char KeyType;

typedef struct BBSTNode {

KeyType key;

int bf; // 平衡因子

struct BBSTNode *lchild,*rchild;

} BBSTNode, *BBSTree;

可调用下列旋转调整操作：

void L_Rotate(BBSTree &p); // 对最小失衡子树p做左旋调整

void R_Rotate(BBSTree &p); // 对最小失衡子树p做右旋调整

**********/

void RightBalance(BBSTree &T)

/* 实现对二叉树T的右平衡处理 */

{

BBSTree rd,lc;

rd=T->rchild;

switch(rd->bf)

{

case RH:

T->bf=rd->bf=EH;

L_Rotate(T);

break;

case LH:

lc=rd->lchild;

switch(lc->bf)

{

case RH:T->bf=LH;rd->bf=EH;

break;

case EH:T->bf=rd->bf=EH;

break;

case LH:T->bf=EH;rd->bf=RH;

break;

}

lc->bf=EH;

R_Rotate(T->rchild);

L_Rotate(T);

}

}