二叉树研讨题（线索二叉树、字符串构建二叉树、复制二叉树、二叉树判同）

已于 2024-05-29 09:05:23 修改
阅读量501 收藏 3
点赞数 9
文章标签： 数据结构 c++
于 2024-04-12 00:27:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79790771/article/details/137658251
版权
文章详细描述了如何通过前序序列构建二叉树，进行线索化处理，输出中序遍历序列，以及比较两棵树结构是否相同的方法。
摘要由CSDN通过智能技术生成

目录

线索二叉树（输入前序，输出中序并销毁二叉树）

用字符串构建一棵二叉树（输入扩展二叉树的前序序列，输出中序）

设计算法复制一棵二叉树（给定前序，复制，输出中序）

判断两棵二叉树是否结构相同（给定前序，构建二棵二叉树，判断是否相同）

线索二叉树（输入前序，输出中序并销毁二叉树）

【问题描述】

建立线索链表，实质上就是将二叉链表中的空指针改为指向前驱或后继的线索，而前驱或后继的信息只有在遍历该二叉树时才能得到。给定扩展二叉树的前序序列，构建二叉树。然后为这棵二叉树建立中序线索链表，并利用线索链表输出中序遍历结果。

【输入形式】

输入扩展二叉树的前序序列。

【输出形式】

利用线索二叉树输出树的中序遍历序列，并且按照中序顺序输出销毁线索二叉树的过程。

【样例输入】

abd#g###ce##f##  

【样例输出】

Inorder:dgbaecf

Inorder finished. Calling destructer...

delete d

delete g

delete b

delete a

delete e

delete c

delete f

【题目要求】

要求创建二叉树，然后建立线索链表

【题解代码】

#include<iostream>
#include<stdio.h>
using  namespace  std;

struct  ThreadNode
{
    char  data;
    ThreadNode    *lchild,  *rchild;
    int  ltag,  rtag;
};

class  ThreadBiTree
{
private:
    ThreadNode  *root;//指向线索链表的头指针
public:

    ThreadBiTree()  //构造函数，建立中序线索链表
    {
        root = NULL;
        root = creat(root);
        inThread(root);
    }
    ~ThreadBiTree();            //析构函数，释放各结点的存储空间
    ThreadNode  *next(ThreadNode  *p);    //查找p的后继
    void  inOrder();                                              //中序遍历线索链表
private:
    ThreadNode  *creat(ThreadNode  *bt);
    void  destroy(ThreadNode  *p);  //线索化，由构造函数调用

    void inThread(ThreadNode *p); //线索化，由构造函数调用



};

//create函数创建二叉树
ThreadNode *ThreadBiTree::creat(ThreadNode *bt)
{
//在此处填写创建线索二叉树的代码
    char ch;
    cin >> ch;
    if (ch == '#')
        bt = NULL;
    else
    {
        bt = new ThreadNode;
        bt->data = ch;
        bt->ltag = 0;
        bt->rtag = 0;
        bt->lchild = creat(bt->lchild);
        bt->rchild = creat(bt->rchild);
    }
    return bt;

}
//实现二叉树线索化，这个函数由构造函数调用
void ThreadBiTree::inThread(ThreadNode *p)
{
//在此处填写建立二叉树线索化的代码，注意，这个函数跟其他函数不同，它 的函数头可以修改，注意检查大括号是否匹配
    static ThreadNode* pre = NULL;//保存上一次递归遍历的结果
    if (p == NULL)
        return;
    inThread(p->lchild);
    if (p->lchild == NULL)
    {
        p->ltag = 1;
        p->lchild = pre;
    }
    if (pre != NULL && pre->rchild == NULL)
    {
        pre->rtag = 1;
        pre->rchild = p;
    }
    pre = p;
    inThread(p->rchild);
}

//查找p的后继
ThreadNode* ThreadBiTree::next(ThreadNode *p)
{
    //在此处填写next函数的代码
    ThreadNode* q;
    if (p->rtag == 1)
        q = p->rchild;
    else
    {
        q = p->rchild;
        while (q->ltag == 0)
            q = q->lchild;
    }
    return q;
}

//中序遍历线索链表
void ThreadBiTree::inOrder()
{
    //在此处填写中序遍历线索二叉树的代码
    if (root == NULL)
        return;
    ThreadNode* p = root;
    while (p->ltag == 0)
    {
        p = p->lchild;
    }
    cout << p->data;
    while (p ->rchild!= NULL)
    {
        p = next(p);
        cout << p->data;
    }
}

//析构函数，释放各结点的存储空间
//这个要注意，和普通的析构函数不一样   
ThreadBiTree::~ThreadBiTree()                             //卡了好久
{
    //在此处填写销毁线索二叉树的代码
    ThreadNode *p,*q;
    p=root;
    while(p->ltag==0)
    {
        p=p->lchild;
    }
    q=p;
    while(p->rchild!=NULL)
    {
        cout<<"delete "<<p->data<<endl;
        p=next(p);
        delete q;
        q=p;
    }
    cout<<"delete "<<p->data<<endl;
    delete p;
}


int  main()
{
    ThreadBiTree  tree;
    cout  <<  "Inorder:";
    tree.inOrder();
    cout  <<  endl  <<  "Inorder  finished.  Calling  destructer..."<<endl;
    return  0;
}
                                                        //好累，不写每一句的注释了

用字符串构建一棵二叉树（输入扩展二叉树的前序序列，输出中序）

【问题描述】

输入一组扩展二叉树的前序序列存入字符串，然后构建一棵二叉树。输出这棵二叉树的中序遍历序列。

【输入形式】

输入扩展二叉树的前序序列。

【输出形式】

输出二叉树的中序遍历序列。

【样例输入】

ab##cd##e##

【样例输出】

badce

【题目要求】

要求在递归函数中传入保存扩展二叉树前序序列的字符串。

【题解代码】

/**用前序字符串创建树*/
#include<iostream>
#include<stdio.h>
#include<string.h>
const  int  MAX=1000;
using  namespace  std;
struct  BiNode
{
    char  data;//数据域
    BiNode    *lchild,  *rchild;//左右儿子指针
};

class  BiTree
{
private:
    BiNode  *root;                            //指向根结点的头指针

public:
    BiTree()
    {
        root  =  NULL;                        //无参构造函数，创建空的二叉树
    }
    BiTree(char  str[])
    {
        int  index  =  0;
        root  =  creat(root,str,index);    //有参构造函数，利用已有的串构建二叉树
    }
    ~BiTree()
    {
        release(root);
    }
    BiNode*  getRoot()
    {
        return  root;
    }
    void  setRoot(BiNode*  bt)
    {
        root  =  bt;
    }
    BiNode*  creat(BiNode  *bt,  char  str[],  int  &index);  //构造函数调用

    void  release(BiNode  *bt);    //析构函数调用，释放树的存储空间
    void  inOrder(BiNode  *bt);    //中序遍历函数调用
};

/**利用已有的字符串前序构建二叉树*/
BiNode  *BiTree::creat(BiNode  *bt,  char  str[],  int  &index)
{
    if(str[index]=='#'||str[index]=='\0')
    {
        bt=NULL;
        if(str[index]=='\0')
        {
            index--;
        }
    }
    else
    {
        bt=new BiNode;
        bt->data=str[index];
        index++;
        bt->lchild=creat(bt->lchild,str,index);
        index++;
        bt->rchild=creat(bt->rchild,str,index);
    }
    return bt;
    //以下注释掉的是一个差不多的写法
    /*
    if(str[index]=='\0'){
    bt=NULL;}
    else if(str[index]=='#'){
    index++;
    bt=NULL;}
    else{
     bt=new BiNode;
            bt->data=str[index];
            index++;
     bt->lchild=creat(bt->lchild,str,index);
            bt->rchild=creat(bt->rchild,str,index);
        }
    return bt;
    */
}

/**后序释放二叉树节点*/
void  BiTree::release(BiNode  *bt)
{
    if(bt==NULL)
    {
        return;
    }
    else
    {
        release(bt->lchild);
        release(bt->rchild);
    }
}

/**中序遍历*/
void  BiTree::inOrder(BiNode  *  bt)
{
    if(bt==NULL)
    {
        return;
    }
    else
    {
        inOrder(bt->lchild);
        cout<<bt->data;
        inOrder(bt->rchild);
    }
}

int  main()
{
    //cout<<"输入前序字符串:";
    char  str[MAX];
    cin  >>  str;
    BiTree  tree(str);

    tree.inOrder(tree.getRoot());

    return  0;
}

设计算法复制一棵二叉树（给定前序，复制，输出中序）

【问题描述】

编写代码复制一棵二叉树。首先给定一组扩展二叉树的前序序列，构建一棵二叉树。然后编写代码复制这棵二叉树，并输出目标二叉树的中序遍历序列。

【输入形式】

输入扩展二叉树的前序序列。

【输出形式】

分两行输出两棵二叉树的中序遍历序列

【样例输入】

ab##cd##e##

【样例输出】

Copy Finished!

InOrder:badce

【题目要求】

要求创建名为source的二叉树对象，输入扩展二叉树的前序序列，构建一棵二叉树；然后创建名为dest的空树(输入#，则创建空树)；然后在指定的函数框架中填写二叉树的复制代码，最后目标二叉树进行中序遍历。

【题解代码】

/**用复制一棵树，用字符串构建树*/
#include<iostream>
#include<stdio.h>
#include<string.h>
const  int  MAX=1000;
using  namespace  std;
struct  BiNode
{
    char  data;//数据域
    BiNode    *lchild,  *rchild;//左右儿子指针
};

class  BiTree
{
private:
    BiNode  *root;                            //指向根结点的头指针

public:
    BiTree()                //无参构造函数，创建空的二叉树
    {
        root  =  NULL;
    }
    BiTree(char  str[])        //有参构造函数，利用已有的串构建二叉树
    {
        int  index  =  0;
        root  =  creat(root,str,index);
    }
    ~BiTree()
    {
        release(root);
    }
    BiNode*  getRoot()                         //getter
    {
        return  root;
    }
    void  setRoot(BiNode*  bt)           //setter
    {
        root  =  bt;
    }
    void  inOrder()
    {
        inOrder(root);
    }

private:
    BiNode*  creat(BiNode  *bt,  char  str[],  int  &index);  //构造函数调用
    void  release(BiNode  *bt);    //析构函数调用，释放树的存储空间
    void  inOrder(BiNode  *bt);    //中序遍历函数调用
};

/**利用已有的字符串前序构建二叉树*/
BiNode  *BiTree::creat(BiNode  *bt,  char  str[],  int  &index)   //跟上一个题一样
{
    if(str[index]=='#'||str[index]=='\0')
    {
        bt=NULL;
        if(str[index]=='\0')
        {
            index--;
        }
    }
    else
    {
        bt=new BiNode;
        bt->data=str[index];
        index++;
        bt->lchild=creat(bt->lchild,str,index);
        index++;
        bt->rchild=creat(bt->rchild,str,index);
    }
    return bt;
}

/**后序释放二叉树节点*/
void  BiTree::release(BiNode  *bt)
{
    if(bt==NULL)
    {
        return;
    }
    else
    {
        release(bt->lchild);
        release(bt->rchild);
    }
}

/**中序遍历*/
void  BiTree::inOrder(BiNode  *  bt)
{
    if(bt==NULL)
    {
        return;
    }
    else
    {
        inOrder(bt->lchild);
        cout<<bt->data;
        inOrder(bt->rchild);
    }
}

/*//------------分割线  普通函数------------------//*/

/*  复制一棵树
//  参数说明：传入源树和目的树的根节点指针
      注意，这里dest这个指针的值需要传出去，因此采用引用&，否则不能传回。

*/
void  copyTree(BiNode  *source,  BiNode*  &dest)
{
    if (source == NULL)
    {
        dest = NULL;
        return;
    }
    dest = new BiNode;
    dest->data = source->data;
    copyTree(source->lchild, dest->lchild);
    copyTree(source->rchild, dest->rchild);
}

int  main()
{
    char  str[MAX];
    BiNode  *dest=NULL,*source=NULL;    //指向两棵树的根节点的指针

//        cout  <<  "请输入一棵树：（形式为：ABD##E##CF###）"<<endl;
    cin  >>  str;
    BiTree  sourceTree(str);
    source  =  sourceTree.getRoot();

    BiTree  destTree;      //创建一棵空树

    copyTree(source,dest);

    destTree.setRoot(dest);        //把复制后的树的指针存储到destTree类中

    cout  <<"Copy  Finished!"<<endl;
    cout  <<"InOrder:";
    destTree.inOrder();

    return  0;
}

判断两棵二叉树是否结构相同（给定前序，构建二棵二叉树，判断是否相同）

【问题描述】

给定两组扩展二叉树的前序序列，构建两棵二叉树。判断这两棵二叉树结构是否相同？

【输入形式】

分两行分别输入两棵扩展二叉树的前序序列。

【输出形式】

如果两个二叉树结构相同，输出“Same structure.”；如果两个二叉树结构不相同，输出“Different structure.”

【样例输入】

ab##cd##e##

AF##DE##K##

【样例输出】

Same structure.

【题目要求】

要求创建二叉树，然后用函数判断两棵二叉树是否相同。

【题解代码】

/**字符串建树判断两棵二叉树是否结构相同*/
#include<iostream>
#include<stdio.h>
using  namespace  std;
struct  BiNode
{
    char  data;//数据域
    BiNode    *lchild,  *rchild;//左右儿子指针
};

class  BiTree
{
private:
    BiNode  *root;                            //指向根结点的头指针

public:
    BiTree()
    {
        root  =  NULL;
        root  =  creat(root);//调函数构建二叉树
    }
    ~BiTree()
    {
        release(root);
    }
    BiNode  *  getRoot()
    {
        return  root;
    }
    BiNode  *creat(BiNode  *bt);  //构造函数调用
    void  release(BiNode  *bt);    //析构函数调用，释放树的存储空间

};
/**前序构建二叉树*/
BiNode  *BiTree::creat(BiNode  *bt)
{
    char  ch;
    cin>>ch;
    if(ch=='#')
        bt  =  NULL;
    else
    {
        bt  =  new  BiNode;
        bt->data  =  ch;
        bt->lchild  =  creat(bt->lchild);
        bt->rchild  =  creat(bt->rchild);
    }
    return  bt;
}
/**后序释放二叉树节点*/
void  BiTree::release(BiNode  *bt)
{
    if(bt==NULL)
    {
        return;
    }
    else
    {
        release(bt->lchild);
        release(bt->rchild);
    }
}
/*
    isSameStructure函数
    功能：接收两棵树的根节点指针，用来判断两棵树的结构是否相同
*/
bool  isSameStructure(BiNode  *  bt1,  BiNode  *  bt2)
{

    if (bt1 == NULL && bt2 == NULL)
    {
        return true;
    }
    if (bt1 == NULL || bt2 == NULL)
    {
        return false;
    }
    return isSameStructure(bt1->lchild, bt2->lchild) && isSameStructure(bt1->rchild, bt2->rchild);  //这里分开写更好看
    //bool left=isSameStructure(bt1->lchild, bt2->lchild) ;
    //bool right=isSameStructure(bt1->rchild, bt2->rchild);
    //return (left&&right);
}

int  main()
{
    BiNode  *root1,*root2;

    BiTree  tree1;
    root1  =  tree1.getRoot();
    BiTree  tree2;
    root2  =  tree2.getRoot();

    if(isSameStructure(root1,root2))
    {
        cout  <<  "Same  structure."<<  endl;
    }
    else
    {
        cout  <<  "Different  structure."  <<endl;
    }

    return  0;
}

菜包小姐的先生
关注
  • 9
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
二叉树习题篇
m0_51205150的博客
12-08 412
1.折半查找（二分查找） 在有序表L中查找关键字为key的元素，若有则返回吗其位置，没有则返回-1 int Binary_Search(Sqlist L,ElemType key) { int low=0, high=L.length-1,mid; while(low<=high) { mid=(low+high)/2; if(L.elem[mid]==key) return mid; else if(L.elem[mid]>key) high=mid-1; else low=mid+1;
二叉树专题
Destiny_159的博客
05-01 365
Base on : 代码随想录 二叉树的属性 226. 翻转二叉树 /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val,.
二叉树面试题
08-28
这个demo里面主要介绍了有关二叉树的算法面试题,希望可以帮助需要的同学.
【数据结构】第八周研讨题
Lemon Sun
07-12 1003
一、研讨题目： 1.后序后继线索二叉树中找结点p的后继（并不知道二叉树的根）。算法思想，对存储结构的要求，算法实现。 2.中序全线索二叉树中插入一课以结点x为根且只有左子树的中序全线索二叉树，作为结点p的左子树。若p原来有左子树，则其变为x的右子树。插入后保持全线索。算法思想，算法实现。 3.二叉链表表示的二叉树，复制二叉树的非递归算法。算法思想和算法实现。 二、内容整理： 1.后序后继
二叉树
adityasaber的博客
10-23 3225
暂时先写了这八个方法 二叉树增加成员方法 BinaryTree二叉树类增加以下成员方法，public权限。 （1）成员方法，递归算法 6-1 BinaryTree(T prelist[], T inlist[]) //以先根和中根序列构造二叉树 6-2 BinaryTree create(T inlist[], T postlist[]) ...
【数据结构】第七周研讨题
Lemon Sun
07-12 449
*这篇整理很多都是从研讨课同学的PPT上la
先序线索二叉树、中序线索二叉树和后序线索二叉树
01-01
对先序线索二叉树、中序线索二叉树和后序线索二叉树进行了 C 语言实现，主要包括线索二叉树的建立和遍历过程。
erchashu.txt.tar.gz_二叉树_二叉树的复制
09-14
实现二叉树链表表示的二叉树： 建立一棵二叉树； 按先序、中序和后序遍历二叉树； 按层次遍历； 求一棵二叉树的高度； 交换一棵二叉树的左右子树； 复制一棵二叉树。
AVL.rar_二叉树 线索化_线索二叉树
09-24
中序线索化的二叉树 能够对二叉树先线索化然后再中序排列 并且输出
线索二叉树_线索二叉树_
10-01
线索二叉树的c++实现，代码实现部分都在压缩包里
二叉树(线索二叉树、链式二叉树、有序二叉树) 常见操作代码实现
04-08
内容概要：用c代码完成链式二叉树、有序二叉树、线索二叉树的的常见操作。其中包括构建、销毁、前序/后序/中序遍历、高度、密度、添加、删除、查询等操作 适合人群：具备一定编程基础，尤其是c语言基础，并很好地...
java算法：冒泡排序
weixin_45832694的博客
06-13 597
然而，尽管这些优化方法可以减少比较和交换的次数，冒泡排序的时间复杂度仍然是O(n^2)，因此对于大规模数据集来说，并不是最优的排序算法选择。传统的冒泡排序是从左到右逐个比较并交换相邻元素的位置，而鸡尾酒排序是交替进行从左到右和从右到左的遍历，将较大的元素从末端冒泡到首端，再将较小的元素从首端冒泡到末端。在每一趟遍历中，通过记录最后一次交换的位置，将该位置作为下一趟遍历的边界。为了优化冒泡排序，可以引入一个标志变量来记录是否发生了交换操作，如果某一趟遍历中没有发生交换，就说明数组已经有序，可以提前结束排序。
【C++进阶】深入STL之 栈与队列：数据结构探索之旅
EterNity_TiMe_的计算机学习之路
06-10 1599
在编程的世界里，数据结构是构建高效、可靠程序的基础。它们就像是我们编程工具箱中的精密工具，帮助我们解决各种复杂的问题。而在C++的STL中，栈（Stack）和队列（Queue）是两种非常重要的数据结构，它们以不同的方式管理和操作数据，为我们的程序提供了极大的灵活性，为了真正掌握它们，我们需要深入学习它们在STL中的实现方式，理解它们背后的原理和机制，以及学习如何在实际编程中有效地使用它们，让我们一起踏上学习STL栈与队列的旅程吧！
数据结构错题答案汇总
weixin_40290845的博客
06-13 387
比如二叉树和二叉排序树，二叉排序树可以采用二叉树的逻辑表示和存储方式，前者通常用于表示层次关系，而后者通常用于排序和查找。虽然它们的运算都有建立树、插入结点、/删除结点和查找结点等功能，但对于二叉树和二叉排序树，这些运算的定义是不同的，以查找结点为例，二叉树的时间复杂度为O(n)而二叉排序树的时间复杂度为O(logn)。数据的逻辑结构是从面向实际问题的角度出发的，只采用抽象表达方式，独立于存储结构，数据的存储方式有多种不同的选择;而数据的存储结构是逻辑结构在计算机上的映射，它不能独立于逻辑结构而存在。
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 1027
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
c++ 6.11
Johan1111的博客
06-11 271
(5)另外， RMB 类还包含一个静态整型成员变量 count，用于记录当前已创建的 RMB 对象的数量。每当创建一个新的 RMB 对象时，count 应该自增 1；(1)重载算术运算符 + 和 -，使得可以对两个 RMB 对象进行加法和减法运算，并返回一个新的 RMB 对象作为结果。(2)重载关系运算符 >，判断一个 RMB 对象是否大于另一个 RMB 对象，并返回 true 或 false。(3)重载前置减减运算符 --，使得每次调用时 RMB 对象的 yuan、jiao 和 fen 分别减 1。
【C++提高编程-05】----C++之Deque容器实战
一伦明悦的博客
06-15 894
Deque（双端队列）是C++ STL中的一种序列容器
C语言猜输赢游戏
最新发布
qq_69383179的博客
06-15 1409
这里有关于C语言猜输赢游戏的程序
【C语言】一维数组（详解）
lrq13965748542的博客
06-11 1002
有了下标引用操作符，我们可以轻松访问到数组中的元素了，比如我们访问下标为7的元素，我们就可以使用 arr[7]，想要访问下标为3的元素，就使用 arr[3]。我们知道数组中所有元素的类型都是相同的，那只要计算出一个元素所占字节的个数，数组的元素个数就能计算出来。以后在代码中需要数组元素个数的地方就不用固定写死了，使用上面的计算，不管数组怎样变化，计算出的大小也就随着变化了。数组也是有类型的，数组算是一种自定义类型，去掉数组名留下的就是数组的类型。实现了数组的访问，现在我们也可以实现对数组中进行数据的输入。
由字符串构建二叉树，字符串序列的顺序与二叉树先序序列一致是否正确
05-23
是的，可以通过字符串构建二叉树，其中字符串序列的顺序与二叉树先序序列一致。具体构建方法如下： 1. 从字符串中取出第一个字符作为根节点； 2. 如果下一个字符不是空格，将其作为根节点的左子节点，继续递归构建...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值