数据结构求两节点的最近共同祖先，用二叉链表作为存储结构，严蔚敏习题集答案如下，一疑点求解释

Posted 2023-05-17

int found=FALSE;
Bitree* Find_Near_Ancient(Bitree T,Bitree p,Bitree q)//求二叉树T中结点p和q的最近共同祖先

Bitree pathp[ 100 ],pathq[ 100 ] //设立两个辅助数组暂存从根到p,q的路径
Findpath(T,p,pathp,0);
found=FALSE;
Findpath(T,q,pathq,0); //求从根到p,q的路径放在pathp和pathq中
for(i=0;pathp[i]==pathq[i]&&pathp[i];i++); //查找两条路径上最后一个相同结点
return pathp[--i];
//Find_Near_Ancient
void Findpath(Bitree T,Bitree p,Bitree path[ ],int i)//求从T到p路径的递归算法

if(T==p)

found=TRUE;
return; //找到

path[i]=T; //当前结点存入路径
if(T->lchild) Findpath(T->lchild,p,path,i+1); //在左子树中继续寻找
if(T->rchild&&!found) Findpath(T->rchild,p,path,i+1); //在右子树中继续寻找
if(!found) path[i]=NULL; //回溯
//Findpath

回溯如何实现？

参考技术A 额，你所使用方法是很慢的，并且不常用的。
我说一个一般的算法，不仅仅适用于二叉树，多叉树也可以。
f[i]表示i节点的父亲。d[i]表示i节点深度。//可以通过深搜预处理出来。
//求xy的最近公共祖先：
while (deep[x]>deep[y]) x=f[x];
while (deep[x]<deep[y]) y=f[y];
while (x<>y) x=f[x];y=f[y]
return x;追问

可是我考试的时候是这么写算法的，所以想明白这个算法是行不行的，回溯又是怎么实现的

追答

算法可行。
但是有一点是必须注意的。
那就是如何存储一颗树！普通的办法是保存一个节点的所有儿子，这样并不是最优的存储方式。
最优的存储方式是用一个数组f[i]表示i节点的父亲。
这样的坏处仅仅是知道了父亲不知道儿子，但好处也是非常明显的，知道了儿子就能求出父亲。并且可以求出任意节点到根节点的路径，从而求出一些列你想要的东西。
注意：这种存储结构也是常用的。多叉树也适用。

本回答被提问者采纳

递归算法及递归算法求二叉树的高度（二叉链表存储）

文章目录

• • 题目描述
  • 算法思想
  • 实现代码
  • 完整代码及实例

题目描述

 假设二叉树采用二叉链表存储结构，设计一个非递归算法求二叉树的高度。

算法思想

 采用层次遍历的算法，设置变量level来记录当前结点所在的层数，设置变量last指向当前层的最右边的结点，每次层级遍历出队时与last指针比较，如果相等，则层数加1，并让last指向下一层的最右边的结点，直到遍历完成。那么最后的level的值即为二叉树的高度。

实现代码

实现代码：

 非递归算法：

int Depth(BNode *root){
    int level = 0; //level为层数
    BNode *last = root;//last为下一层的最右结点
    if(root == NULL){ //树空，则高度为0
        return 0;
    }
    queue<BNode *> treenode; //申请一个队列
    treenode.push(root); //根结点入队
    while(!treenode.empty()){ //队不空时循环
        BNode *p = treenode.front(); //队首
        treenode.pop(); //根结点出队
        if(p->lchild != NULL){ //如果存在左子树，则左子树根结点入队
            treenode.push(p->lchild);
        }
        if(p->rchild != NULL){ //如果存在右子树，则右子树根结点入队
            treenode.push(p->rchild);
        }
        if(p == last){ //如果刚才出队的是该层最右结点
            level++; //层数加1
            last = treenode.back(); //last指向下层
        }
    }
    return level;
}

 递归算法：

int Depth2(BNode *root){
    if(root == NULL){ //空树，高度为0
        return 0;
    }
    int left = Depth2(root->lchild); //左子树高度
    int right = Depth2(root->rchild); //右子树高度
    return (left>right? left+1 : right+1); //树的高度为最大子树的高度加上根结点
}

完整代码及实例

完整代码：

#include<bits/stdc++.h>
using namespace std;

typedef struct BNode{
    char data;
    struct BNode *lchild;
    struct BNode *rchild;
}BNode;

const int N = 100;
char str[N]; //存储先序遍历序列
int i; //标记处理到哪一个字符了
BNode *BulidTree(){
    if(str[i] == '#'){
        i++; //处理下一个字符
        return NULL;
    }else{
        //新建一个结点
        BNode *p = (BNode *)malloc(sizeof(BNode));
        p->data = str[i];
        p->lchild = NULL;
        p->rchild = NULL;
        i++;
        p->lchild = BulidTree();
        p->rchild = BulidTree();
        return p;
    }
}

//非递归算法
int Depth(BNode *root){
    int level = 0; //level为层数
    BNode *last = root;//last为下一层的最右结点
    if(root == NULL){ //树空，则高度为0
        return 0;
    }
    queue<BNode *> treenode; //申请一个队列
    treenode.push(root); //根结点入队
    while(!treenode.empty()){ //队不空时循环
        BNode *p = treenode.front(); //队首
        treenode.pop(); //根结点出队
        if(p->lchild != NULL){ //如果存在左子树，则左子树根结点入队
            treenode.push(p->lchild);
        }
        if(p->rchild != NULL){ //如果存在右子树，则右子树根结点入队
            treenode.push(p->rchild);
        }
        if(p == last){ //如果刚才出队的是该层最右结点
            level++; //层数加1
            last = treenode.back(); //last指向下层
        }
    }
    return level;
}

//递归算法
// int Depth2(BNode *root){
//     if(root == NULL){ //空树，高度为0
//         return 0;
//     }
//     int left = Depth2(root->lchild); //左子树高度
//     int right = Depth2(root->rchild); //右子树高度
//     return (left>right? left+1 : right+1); //树的高度为最大子树的高度加上根结点
// }

int main(){
    scanf("%s",str);
    i = 0;
    BNode *root = BulidTree();
    int level = Depth(root);
    printf("%d\\n",level);
    return 0;
}

运行结果：

实例中的二叉树为：