2024王道数据结构大题p143-p144（二）

已于 2023-04-26 16:46:20 修改
阅读量394 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 算法 c++ vscode 链表
于 2023-04-26 16:45:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47098905/article/details/130387240
版权
文章介绍了多种二叉树相关算法，包括寻找值为x的结点的所有祖先结点、找到两个结点的最近公共祖先、非递归后序遍历、求二叉树宽度、满二叉树的先序序列转后序序列、构建叶结点链表以及判断两棵二叉树是否相似等。这些算法通过不同的数据结构和遍历策略解决二叉树问题。
摘要由CSDN通过智能技术生成

二叉树

12.在二叉树中查找值为x的结点，试编写算法打印值为x的结点的所有祖先结点，假设值为x的结点不多于一个。

  • 算法的基本设计思想
    采用非递归的后序遍历，利用辅助栈，当弹出栈顶元素判断值是否为x，然后此时栈中元素即为x结点的祖先结点
  • 算法实现
// 在二叉树中查找值为x的结点，试编写算法打印值为x的结点的所有祖先结点
#include <iostream>
using namespace std;
#define Max 10
typedef struct treenode
{
    char data;
    treenode *lchild, *rchild;
} treenode, *tree;
void buildtree(tree &t)
{
    char ch;
    ch = getchar();
    if (ch == '#')
        t = NULL;
    else
    {
        t = (tree)malloc(sizeof(treenode));
        t->data = ch;
        t->rchild = NULL;
        t->lchild = NULL;
        buildtree(t->lchild);
        buildtree(t->rchild);
    }
}
typedef struct stack
{
    treenode *t;
    int tag;//tag=0表示左孩子被访问，tag=1表示右孩子被访问
} stack;

void rexfather(tree &t, char x)
{
   if(t==NULL) cout<<"未找到"<<endl;
    // 初始化栈
    stack s[100];
    int top=0;
    while (t!=NULL||top>0)//树空栈空就退出
    {
            while(t!=NULL&&t->data!=x) //沿着左分支向下压入栈中
            {
                s[++top].t=t;
                s[top].tag =0;  
                t=t->lchild; 
            }
            if(t!=NULL&&t->data==x)//找到x
            {
                cout<<"所查结点的所有祖先结点的值为:"<<endl;
                for(int i=1;i<=top;i++)//栈中元素都是祖先结点，
                {
                    printf("%c",s[i].t->data);
                }
                break;
            }
            while(top!=0&&s[top].tag==1)//栈顶元素的左右孩子都被访问了退栈
            top--;
            if(top!=0)
            {
                s[top].tag=1;
                t=s[top].t->rchild;
            }
    }   
    
}
int main()
{
    tree t;
    buildtree(t);
    rexfather(t,'G');

    return 0;
}//ABD##E##CF##G##
  • 小结

13. 设一颗二叉树的结点结构为（LLINK，INFO，RLINK），ROOT为指向该二叉树根结点的指针，p和q分别为指向该二叉树中任意两个结点的指针，试编写算法ANCESTOR（ROOT，p，q，r）找到p和q的最近的公共祖先结点r.

  • 算法的基本设计思想
    用两个栈，假设p在q左边先把p的祖先压栈s1，然后复杂这个栈到s2，然后找到p，将s1与s2匹配第一个相同的就是刚刚祖先r。

  • 算法实现

// 设一颗二叉树的结点结构为（LLINK，INFO，RLINK），ROOT为指向该二叉树根结点的指针，p和q分别为指向该二叉树中任意两个结点的
// 指针，试编写算法ANCESTOR（ROOT，p，q，r）找到p和q的最近的公共祖先结点r.
#include <iostream>
using namespace std;
typedef struct treenode
{
    char data;
    treenode *lchild, *rchild;
} treenode, *tree;
void buildtree(tree &t)
{
    char ch;
    ch = getchar();
    if (ch == '#')
        t = NULL;
    else
    {
        t = (tree)malloc(sizeof(treenode));
        t->data = ch;
        t->lchild = NULL;
        t->rchild = NULL;
        buildtree(t->lchild);
        buildtree(t->rchild);
    }
}
typedef struct stack
{
    treenode *t;
    int tag; // tag=0 左孩子被访问过，tag=1右孩子被访问过
} stack;
tree Ancestor(tree &t, treenode *p, treenode *q)
{
    stack s1[10], s2[10];
    int top1 = 0, top2 ;
    while (t != NULL || top1 > 0) // 树和栈都空跳出
    {
        while (t != NULL) // 沿着左分支压入栈中
        {
            s1[++top1].t = t;
            s1[top1].tag = 0;
            t = t->lchild;
        }
        while (top1 != 0 && s1[top1].tag == 1) // 假定p是在q的左测
        {
            if (s1[top1].t == p) // 找到p后，栈中元素都是p 的祖先
            {
                for (int i = 1; i <= top1; i++)
                    s2[i] = s1[i]; // 将栈s1复制到栈s2
                    top2=top1;
            }
            if (s1[top1].t == q) // 找到q结点
            {
                for (int i = top1; i > 0; i--) // 将栈中元素的结点到s2中去匹配
                    for (int j = top2; j > 0; j--)
                        if (s2[j].t == s1[i].t)
                            return s1[i].t; //找到了
            }
            top1--;    // 退栈
        }              // while
        if (top1 != 0)  //压右边
        {
            s1[top1].tag = 1;
            t = s1[top1].t->rchild; // 工作指针t指向栈顶的右孩子     沿右分支向下遍历
        }
    }            // while
    return NULL; // 前面都没返回那就是没找到，p和q无公共结点；
}

int main()
{
    tree t;
    buildtree(t);
    treenode *p = t->lchild->lchild, *q = t->lchild->rchild;
    cout << Ancestor(t, p, q)->data << endl;
    return 0;
}
// ABD##E##CF##G##
  • 小结
    用了tag位，tag=0 左孩子被访问过，tag=1右孩子被访问过；
    和双栈。

14.编写后序遍历二叉树的非递归算法

  • 算法的基本设计思想

  • 算法实现
  • 小结## 1.编写后序遍历二叉树的非递归算法

15. 假设二叉树采用二叉链表存储结构，设计一个算法，求非空二叉树b的宽度(即具有结点数最多的那一层的结点个数)

  • 算法的基本设计思想
    求宽度，最多那一层我们想到用层次遍历,求出每一层的宽度，然后比较大小；
  • 算法实现
// 假设二叉树采用二叉链表存储结构，设计一个算法，求非空二叉树b的宽度(即具有结点数最多的那一层的结点个数)
// 算法思路，求宽度，最多那一层我们想到用层次遍历,求出每一层的宽度，然后比较大小；
#include <iostream>
using namespace std;
#define Max 20
typedef struct treenode
{
    char data;
    treenode *rchild, *lchild;
} treenode, *tree;
void buildtree(tree &t)
{
    char ch;
    ch = getchar();
    if (ch == '#')
        t = NULL;
    else
    {
        t = (tree)malloc(sizeof(treenode));
        t->data = ch;
        t->rchild = NULL;
        t->lchild = NULL;
        buildtree(t->lchild);
        buildtree(t->rchild);
    }
}
// 队列结构
typedef struct queue
{
    treenode *data[Max];
    int level[Max]; // data中下标结点的层次
    int f, r;
} queue;
int Btwidth(tree &t)
{
    queue q;           // 队列
    tree p;            // 保存出队的结点指向
    int k;             // 保存出队的结构层次
    q.f = q.r = -1;    // 头尾指针的初始化
    q.data[++q.r] = t; // 根节点入队
    q.level[q.r] = 1;  // 刚入队的根结点的层次记为1；
    while (q.f < q.r)  // 层次遍历的循环条件，尾指针大于头指针
    {
        // 头指针出队；
        p = q.data[++q.f]; // p指针保存刚刚出队的结点
        k = q.level[q.f];  // 保存出队结点的层次；
        if (p->lchild)     // 有左孩子左孩子入队
        {
            q.data[++q.r] = p->lchild; // 左孩子入队
            q.level[q.r] = k + 1;      // 进入队列的结点的层次为出队的结点的层次+1；
        }
        if (p->rchild)
        {
            q.data[++q.r] = p->rchild;
            q.level[q.r] = k + 1;
        }
    }
    // 遍历的时候最大值更新，遍历下标，计算每层的个数
    int maxx = 0, i = 0, n;
    k = 1;
    while (i <= q.r) // 遍历的下标小于队尾部
    {
        n = 0; // 一开始每层默认0个
        while (i <= q.r && q.level[i] == k)
        {
            n++;
            i++;
        }
        k = q.level[i];
        if (n > maxx)
            maxx = n;
    }
    return maxx;
}
int main()
{
    tree t;
    buildtree(t);
    cout << Btwidth(t) << endl;
    return 0;
}
// ABD##E##CF##G##
  • 小结## 1.编写后序遍历二叉树的非递归算法

15.设有一颗满二叉树（所有结点均不同），已知其先序序列为pre，设计一个算法求出其后序序列post。

  • 算法的基本设计思想
    用递归，pre的第一个结点就是post的最后一个结点，然后每次去找到half=将剩下的结点划分为两部分去递归
  • 算法实现
// 设有一颗满二叉树（所有结点均不同），已知其先序序列为pre，设计一个算法求出其后序序列post。
#include <iostream>
using namespace std;
void prepost(char pre[], int l1, int r1, char post[], int l2, int r2) // 数组就是给地址
{
    int half;
    if (l1 <= r1)//左边大于右边就退出递归， 递归条件是左边小于等于右边才能去左右切割递归；
    {
        post[r2] = pre[l1];
        half = (r1 - l1) / 2;
        prepost(pre, l1 + 1, l1 + half, post, l2, l2 + half - 1);
        prepost(pre, l1 + half + 1, r1, post, l2 + half, r2 - 1);
    }
}
int main()
{
    char pre[8] = "ABDECFG", post[8];
    prepost(pre, 0, 6, post, 0, 6);
    for (int i = 0; i < 7; i++)
    {
        cout << post[i] << " ";
    }
    return 0;
}
  • 小结
    做这种题目先想到递归，然后大树化小数找中间的分界点，和结点之间的逻辑关系

  • 16.设计一个算法将二叉树的叶结点按从左到右的顺序连城一个单链表，表头指针为head，二叉树 按二叉链表方式存储，链接时用叶结点的右指针域来存放单链表

  • 算法的基本设计思想
    用中序递归遍历 （左根右）
  • 算法实现
//设计一个算法将二叉树的叶结点按从左到右的顺序连城一个单链表，表头指针为head，
//二叉树 按二叉链表方式存储，链接时用叶结点的右指针域来存放单链表
//由题目很容易想到用中序递归遍历。
#include <iostream>
using namespace std;
typedef struct treenode {
    char data;
    treenode *lchild,*rchild;

}treenode,*tree;
void buildtree(tree &t)
{
    char ch;
    ch=getchar();
    if(ch=='#') t=NULL;
    else{
        t=(tree)malloc(sizeof(treenode ));
        t->data=ch;
        t->lchild=NULL;
        t->rchild=NULL;
        buildtree(t->lchild);
        buildtree(t->rchild);
    }
}
void disp(tree &t)
{
    if(t)
    {
        cout<<t->data<<" ";
        disp(t->lchild);
        disp(t->rchild);
    }
}
tree head=(tree)malloc(sizeof(treenode)),pre=NULL;//初始化一个head结点，和一个前驱结点用来保存下一个结点的前驱结点初始为NULL；

tree Inorder(tree &t)//最后返回后head
{   
    if(t)//递归条件
    {
            Inorder(t->lchild);//找最左下的结点
            if(t->rchild==NULL&&t->rchild==NULL)//判断这个最左下的结点是不是叶子结点
            {
                //判断这个叶子结点是不是第一个叶子结点，前驱是NULL就是第一个
                if(pre==NULL)
                    {
                        head=t;
                        pre=t;
                    }
                else
                    {
                        pre->rchild=t;
                        pre=t;
                    }

            }
            Inorder(t->rchild);//再去右子树找
            t->rchild=NULL;  //注意这里需要将最后一个结点的右孩子指向空
    }
    return head;
}
int main(){
    tree t;
    buildtree(t);
    disp(t);
    Inorder(t);
     while(head)
   {
       cout<<head->data<<" ";
       head=head->rchild;
   }
    return 0;
}//ABD##E##CF##G##
  • 小结
    注意最后结点需要指向空

  • 17.设计判断两颗二叉树是否相似的算法。所谓二叉树T1和T2相似，指的是T1和T2都是空的二叉树或都只有一个根节点；或者T1的左子树和T2的右子树是相似的，且T1的右子树和T2的右子树是相似的。

  • 算法的基本设计思想
    相似： 空和空 || 非空和非空
    不相似 ： 空 和非空
    递归判断左边和右边，用int返回类型的递归函数
  • 算法实现
/* 设计判断两颗二叉树是否相似的算法。所谓二叉树T1和T2相似，指的是T1和T2都是空的二叉树或都只有一个根节点；
或者T1的左子树和T2的右子树是相似的，且T1的右子树和T2的右子树是相似的。 */
#include <iostream>
using namespace std;
typedef struct treenode
{
    char data;
    treenode *rchild, *lchild;
} treenode, *tree;

void buildtree(tree &t)
{
    char ch;
   cin>>ch;
    if (ch == '#')
        t = NULL;
    else
    {
        t = (tree)malloc(sizeof(treenode));
        t->data = ch;
        t->rchild = NULL;
        t->lchild = NULL;
        buildtree(t->lchild);
        buildtree(t->rchild);
    }
}
int similar(tree &t1, tree &t2)
{
    int left,right;
    if (t1 == NULL && t2 == NULL)
        return 1;
    else if (t1==NULL||t2==NULL)
        return 0;
    else
    {
         left = similar(t1->lchild, t2->lchild);
         right = similar(t1->rchild, t2->rchild);
    }
    return (left && right);
}
int main()
{
    tree t1, t2;
    cout << "创建第一个二叉树：" << endl;
    buildtree(t1);
    cout << "创建第二个二叉树：" << endl;
    buildtree(t2);
    if (similar(t1, t2))
        cout << "相似" << endl;
    else
        cout << "不相似" << endl;
    return 0;
}
  1. 小结
    用left 记录左边 right记录右边

  2. 18.写出在中序线索二叉树里查找指定结点在后序的前驱结点的算法

  3. 算法的基本设计思想
    先对二叉树中序线索化
    左根右，左右根，

后序的前驱：q

1)p有右孩子，q->p
2)else	if	p有左孩子 ，	q->p
3)else	if	p的左孩子是空	q = NULL
4)else	p的最上祖先的左孩子存在 q指向它  没有就是NULL
  1. 算法实现
/* 写出在中序线索二叉树里查找指定结点在后序的前驱结点的算法 */
#include <iostream>
using namespace std;
typedef struct treenode
{
    char data;
    treenode *rchild, *lchild;
    int ltag, rtag;
} treenode, *tree;
void buildtree(tree &t)
{
    char ch;
    cin >> ch;
    if (ch == '#')
        t = NULL;
    else
    {
        t = (tree)malloc(sizeof(treenode));
        t->data = ch;
        t->ltag = 0;
        t->rtag = 0;
        t->lchild = NULL;
        t->rchild = NULL;
        buildtree(t->lchild);
        buildtree(t->rchild);
    }
}
void zx(tree &t, treenode *&pre)
{
    if (t)
    {
        zx(t->lchild, pre);
        if (t->lchild == NULL)
        {
            t->lchild = pre;
            t->ltag = 1;
        }

        if (pre != NULL && pre->rchild == NULL)
        {
            pre->rchild = t;
            pre->rtag = 1;
        }
        pre = t;
        zx(t->rchild, pre);
    }
}
tree fpostpre(tree &t, treenode *p)
{
    treenode *q;
    if (p->rtag == 0)
        q = p->rchild; // 有右孩子
    else if (p->ltag == 0)
        q = p->lchild; // 有左孩子
    else if (p->lchild == NULL)
        q = NULL; // 中序第一个结点
    else
    {

        while (p->ltag == 1 && p->lchild != NULL)
            p = p->lchild; // 沿着线索找到最上祖先结点
        if (p->lchild)
            q = p->lchild; // 如果这个祖先结点有左孩子，q=它
        else
            q = NULL;
    }

    return q;
}
int main()
{
    tree t;
    buildtree(t);
    treenode *pre = NULL;
    zx(t, pre);
    cout << fpostpre(t, t->rchild)->data << endl;
    return 0;
} // ABD##E##CF##G##
  • 小结
    分析好后序的前驱结点的存在可能

  • 19.《2014统考真题》二叉树的带权路径长度WPL是二叉树中所有叶结点的带权路径长度之和，给定一颗二叉树T，采用二叉链表存储，结点结构为 left|weight|right 其中叶结点的weight域保存该结点的非负权指，

设root为指向T的根节点的指针，请设计求T的WPL算法

  • 算法的基本设计思想
    递归
  • 算法实现
/* 《2014统考真题》二叉树的带权路径长度WPL是二叉树中所有叶结点的带权路径长度之和，
给定一颗二叉树T，采用二叉链表存储，结点结构为 left|weight|right 其中叶结点的weight域保存该结点的非负权指，
设root为指向T的根节点的指针，请设计求T的WPL算法*/
#include <iostream>
using namespace std;
typedef struct treenode {
    char data;
    treenode *rchild,*lchild;
}treenode ,*tree;
void buildtree(tree &t)
{
    char ch;
    cin >>ch;
    if(ch=='#') t=NULL;
    else{
        t=(tree)malloc(sizeof(treenode ));
        t->data=ch;
        t->lchild=NULL;
        t->rchild=NULL;
        buildtree(t->lchild);
        buildtree(t->rchild);
    }
}
int wpl(tree &t,int deep )
{
    static int ans=0;
    if(t->lchild==NULL&&t->rchild==NULL)//是叶子结点
    {
     return    ans+=(deep*((t->data)-'0'));
    }
    if(t->lchild)
        wpl(t->lchild,deep+1);
    if(t->rchild)
        wpl(t->rchild,deep+1);
    return ans;
}   
int main(){
    tree t;
    buildtree(t);
    cout<<wpl(t,0)<<endl;
    return 0;
}
/*

             1                            
          2    3                    
        4  5  6  7                   
124##5##36##7##     
ans=(4+5+6+7)*2=44

*/
  • 小结
    ans+=(deep*((t->data)-‘0’)) 字符减去’0’就是数字

  • 20.《2017统考真题》请设计一个算法，将给定的表达树（二叉树）转换为等价的中缀表达式

（通过括号反映操作符的计算次序）并输出

  • 算法的基本设计思想
    从树的根节点左孩子用括号括起来，右孩子用括号括起来，叶子结点不用括，中序递归
  • 算法实现
/* 《2017统考真题》请设计一个算法，将给定的表达树（二叉树）转换为等价的中缀表达式
（通过括号反映操作符的计算次序）并输出 */
#include <iostream>
using namespace std;
typedef struct treenode
{
    char data;
    treenode *rchild, *lchild;

} treenode, *tree;
void buildtree(tree &t)
{
    char ch;
    cin >> ch;
    if (ch == '#')
        t = NULL;
    else
    {
        t = (tree)malloc(sizeof(treenode));
        t->data = ch;
        t->lchild = NULL;
        t->rchild = NULL;
        buildtree(t->lchild);
        buildtree(t->rchild);
    }
}
void toexp(tree &t, int deep)
{
    if (t == NULL)
        return;                                      // 树空直接访回
    else if (t->lchild == NULL && t->rchild == NULL) // 叶子结点输出data
    {
        cout << t->data;
    }
    else // 有左右孩子进行递归
    {
        if (deep > 1)
            cout << '(';
        if (t->lchild)//左
            toexp(t->lchild, deep + 1);
        cout << t->data;//print计算符
        if (t->rchild)//右
            toexp(t->rchild, deep + 1);
        if (deep > 1)
            cout << ')';
    }
}
int main()
{
    tree t;
    buildtree(t);
    toexp(t, 1);
    return 0;
}

/*

        *
    +       *
  a   b   c  -
  *+a##b##*c##-#d##
  • 小结
    递归
阿酱x
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【王道思维扩展1】求解斐波那契数列的递归和非递归算法，并分析两种时间复杂度
SoBeautifulgirl的博客
04-17 2815
求斐波那契数列的递归和非递归算法
2024 王道考研 数据结构+习题讲解_王道课后题pdf，差点挂在第四面
最新发布
2401_84239830的博客
04-13 1888
P4【2021版】1.2.1 算法的基本概念P5【2021版】1.2.2 算法的时间复杂度P6【2021版】1.2.3 算法的空间复杂度P7【2021版】2.1_线性表的定义和基本操作P8【2021版】2.2.1_顺序表的定义P9【2021版】2.2.2_1_顺序表的插入删除P10【2021版】2.2.2_2_顺序表的查找P11【2021版】2.3.1_单链表的定义P12【2021版】2.3.2_1_单链表的插入删除P13【2021版】2.3.2_2_单链表的查找P14【2021版】2.3.2_3_单链表的
王道数据结构思维拓展
kailsong的博客
08-25 2512
本文记录我在学习王道考研教材《数据结构考研复习指导》时，所遇到的各章思考题。仅供参考。 ps:持续更新中 Ch1 题目 求解斐波那契数列 F(n)={1,n = 0,1F(n−1)+F(n−2),n > 1 F(n) = \begin{cases} 1, & \text{n = 0,1} \\ F(n-1) + F(n-2), & \text{n > 1} \end{cases} F(n)=.
设一棵二叉树的结点结构为（LLINK,INFO,RLINK），ROOT为指向该二叉树根结点的指针，p和q分别为指向该二叉树中任意两个结点的指针，编写一个算法ANCESTOR(ROOT,p,q,r),找
weixin_43405277的博客
04-23 1809
设一棵二叉树的结点结构为(LLINK,INFO,RLINK）ROOT为指向该二叉树根结点的指针，p和q分别为指向该二叉树中任意两个结点的指针，编写一个算法ANCESTOR(ROOT,p,q,r),找到p和q的最近公共祖先结点. 思路: 采用非递归后续遍历算法,因为在访问一个结点p时,栈中结点恰好是p结点的所有祖先,从栈底到栈顶结点再加上p结点,刚好构成从根结点到p结点的一条路径. 栈内数据: 伪代码: BiTree Ancestor(BiTree ROOT,BiTNode *p,BiTNode *q
设一棵二叉树的结点结构为（LLINK,INFO,RLINK），ROOT为指向该二叉树根结点的指针，p和q分别为指向该二叉树中任意两个结点的指针，试编写一个算法ANCESTOR(ROOT,p,q,r)，
syh666233的博客
09-09 1870
思路：在做这道题之前，如果知道怎么求某个结点所有祖先结点就很好求了。在这个前提下，我们把p的祖先和q的祖先分别存放在两个栈里面，并且设p在q的左边，那么p的祖先一定也是q的祖先，然后对比两个栈中的元素，第一个相等的元素就是最近的公共祖先结点，下面是示意图， 把路径都找到过后，就挨个出栈，并且比较。 代码没时间写了，以后有时间再更吧，不过如果会写某个结点所有祖先的那道题，这道题其实是一样的。 ...
2019王道考研数据结构勘误
05-04
### 2019年王道考研数据结构勘误知识点详解 #### 一、概述 在准备考研的过程中，选择合适的复习资料至关重要。其中，《2019王道考研数据结构》作为一本广受好评的数据结构教材，对于考生来说是不可或缺的学习资源...
数据结构学习笔记（王道）
12-29
数据结构是计算机科学中至关重要的基础概念，它研究如何组织和管理数据，以便高效地进行存储、检索和处理。在本文中，我们将深入探讨数据结构的相关知识点，包括数据结构的定义、逻辑结构、存储结构、抽象数据类型...
郝斌老师数据结构笔记
06-18
### 郝斌老师数据结构笔记知识点总结 #### 数据结构与算法概述 - **定义**: 数据结构涉及如何将现实世界中的复杂问题转化为特定的数据类型及存储结构，并基于这些结构设计算法来解决问题。简单来说，数据结构关注...
2018年浙江大学878专业课试题回忆版
05-04
大题 - **二叉树的构建与遍历：** 通过给定的后序遍历和中序遍历构建二叉树，并输出前序遍历。 - **哈希表的冲突解决：** 使用线性探测法解决哈希表中的冲突问题。 - **弗洛伊德算法（Floyd）：** 实现...
王道训练营Java工程师 课程大纲1
08-03
此外，数据结构的学习包括线性表、链表、二叉树和红黑树，这些都是算法和高效编程的基础。 【数据库与JDBC】 数据库部分，课程将介绍SQL语言，包括查询、操作、定义和控制语言。MySQL数据库的安装配置、多表查询、...
王道——数据结构——树与二叉树（3）
不会就用洛必达的博客
05-03 1010
系列文章目录 王道——数据结构——树与二叉树（1） 王道——数据结构——树与二叉树（2） 文章目录系列文章目录前言一、5.3节 前言 本文为王道数据结构的第五章——树与二叉树的编程题。 运行软件：vscode 使用c++文件编写 本文所使用的树为《王道——数据结构——树与二叉树（1）》中建立的树 一、5.3节 11、已知二叉树以二叉链表存储，编写算法完成：对于树中的每个元素值为x的结点，删去以它为根节点的子树，并释放相应的空间。 // 第十一题 使用层次遍历主树，发现结点值为x时，对x的子树进行后续
二叉树的遍历和线索二叉树 p126 3-18
云淡风轻_的博客
09-14 1759
3.编写后序遍历二叉树非递归算法 后序非递归遍历二叉树的顺序是先访问左子树，再访问右子树，最后访问根节点，当用堆栈来存储节点时必须分清返回根节点时是从左子树返回的还是从右子树返回的。所以使用辅助指针r，其指向最近访问过的结点。也可在节点中增加一个标志域，记录是否已经被访问过。 void PostOrder(BiTree T){ InitStack(S); Bnode *p=T,*r=NULL; while(p||!IsEmpty){ if(p){ push(S,p); p=p
2022王道数据结构考研复习指导习题代码（树与二叉树）
qq_18431031的博客
05-16 1742
5.2二叉树的概念 1.已知一棵二叉树按顺序存储结构进行存储，设计一个算法，求编号分别i和j的两个结点的最近公共祖先结点的值。
数据结构学习笔记（四）—— 树
晓岚の代码社区
01-06 972
树 文章目录树一.树的基本概念二.树的遍历1.先序遍历2.后序遍历3.中序遍历4.层序遍历三.树的存储表示和操作实现1.双亲表示法2.孩子表示法3.双亲孩子表示法4.孩子兄弟表示法 一.树的基本概念 结点：包含一个元素及若干指向子树的分支。 根结点、终端结点、其他结点（仅有1个前驱，多个后继） 结点的度：一个结点所拥有的子树的个数 树的度：树中各结点度的最大值 叶子结点：度为0的结点 分支结点：度不为0的结点 路径：如果树的结点序列 {n1, n2, …, nk} 满足如下关系：结点 ni 是结
设一棵二叉树的结点结构为(LLINK,INFO,RLINK)，ROOT 为指向该二叉树根结点的指针,p和q分别为指向该二叉树中任意两个结点的指针,试编写算法ANCESTOR (ROOT,p,q)
gc的博客
11-30 391
考虑使用递归，找祖先，所以使用后序递归遍历；最近公共祖先是说离 p和q最近的祖先，p和q本身就可以时最近公共祖先。3、若其左右递归返回值都不为空，则 ROOT 是最近公共祖先。否则若左递归返回值不为空，则其返回值则为最近公共祖先。否则若右递归返回值不为空，则其返回值则为最近公共祖先。1、如果p和q本身就是公共祖先，则直接返回。
2024王道数据结构课后习题代码
m0_51057239的博客
03-14 4345
2.1.2 顺序表初始化（动态） 2.1.3 顺序表上插入和删除 2.2综合题 这些题是王道教材的p18-p19的1-14题，2.2.1即为第一题 2.2.2 2.2.3 未完待续… 2023年四月末之前将更新完本书所有习题
2021-08-30王道 数据结构 第5章 树与二叉树 p185 第10题
qq_44801423的博客
08-30 211
第5章 树与二叉树 5.5 树与二叉树的运用 综合应用题 第10题 void Output(BSTANode *bt,keyType k) { if(bt==NULL) return; if(bt->rchild!=NULL) Output(bt->rchild,k); if(bt->data>=k) cout<<bt->data; if(bt->lchild!=NULL) Output(bt->lchild,k); } ...
3.15√ 假设以顺序存储结构实现一个双向栈，inistack(tws), push(tws), pop(tws)的suanfa
qq_43661234的博客
09-17 3426
#include <stdio.h> #include <stdlib.h> #define maxsize 100 #define OK 1 #define error -1 typedef int status; typedef struct { int top1, top2; int data[maxsize]; }stack; void inis...
数据结构(C语言)第二版 第五章课后答案
热门推荐
博客
02-16 3万+
数据结构(C语言)第二版 第五章课后答案 1．选择题 （ 1）把一棵树转换为二叉树后，这棵二叉树的形态是（） 。 A．唯一的Ｂ．有多种 C．有多种，但根结点都没有左孩子Ｄ．有多种，但根结点都没有右孩子 答案： A 解释：因为二叉树有左孩子、右孩子之分，故一棵树转换为二叉树后，这棵二叉树的 形态是唯一的。 （ 2）由3 个结点可以构造出多少种不同的二叉树？（） A． 2 B ． 3 C ． 4 D ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿酱x

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值