二叉树操作实现

最新推荐文章于 2023-10-29 22:13:28 发布
最新推荐文章于 2023-10-29 22:13:28 发布
阅读量588 收藏 3
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/easygoing45/article/details/120981595
版权

二叉树操作实现

什么是二叉树？

树是常用的一种非线性数据结构。

树有很多衍生分类，其中，二叉树便是最为常见的一种。

二叉树的定义是以递归形式给出的：一棵二叉树是结点的一个有限集合，该集合可能为空，或则是由一个根节点加上两棵分别称为左子树、右子树的、互不相交的二叉树组成。

二叉树的特点是每个结点最多有两个子女，分别image-20211026211620558称为该节点的左子树和右子树。

在二叉树中不存在度大于2的结点，并且二叉树的字子树有左子树、右子树之分，其子树的次序不能颠倒。

二叉树是分支数最大不超过2的有根有序树。

二叉树的性质

image-20211024150453728

二叉树的基本操作？

二叉树的基本操作有：

  • 创建二叉树
  • 前序遍历
  • 中序遍历
  • 后序遍历
  • 层序遍历
  • 求结点个数
  • 求二叉树的深度
  • 销毁二叉树
  • 前/中/后序遍历的非递归实现
  • 求叶子结点个数
  • 求某结点的双亲结点
  • 删除某节点的子树

二叉树相关算法的基本模式

由于树本身的定义就是递归定义的，

所以二叉树的基本操作多半基于递归思想实现。

二叉树结点结构体的设计

//结点结构体的定义
struct BiNode
{
    /* data */
    int data;
    BiNode *lchild; //左孩子
    BiNode *rchild; //右孩子
};

二叉树类的设计

我在设计类的时候，将涉及到对于结点root进行操作的递归调用过程的权限置为了private，并在public权限下设计了对外接口，这样做的目的是避免外界直接对根节点进行操作，是一种保护行为。

本质是函数重载和递归思想的实现。

class BiTree
{
private:
    /* data */
    int IsRoot=0;
    BiNode *Creat();                //构造函数调用
    void Release(BiNode *bt);       //析构函数调用
    void PreOrder(BiNode *bt);      //前序遍历函数调用
    void InOrder(BiNode *bt);       //中序遍历函数调用
    void PostOrder(BiNode *bt);     //后序遍历函数调用过程
    int Size(BiNode *bt);           //获取结点个数调用过程
    int Leaf(BiNode *bt);           //求叶子结点个数的调用过程
    void Parent(BiNode *bt);        //求双亲结点调用过程
    int Height(BiNode *bt);         //获取二叉树高度的调用过程
    int DelX(BiNode *bt,int x,int flag);    //删除子树的递归调用过程
    BiNode *root;                   //指向根节点的头指针
    int target;
public:
    //BiNode *root;
    BiTree(){this->root=Creat();}   //构造函数  建立一棵二叉树
    ~BiTree(){Release(root);}       //析构函数，释放各结点的存储空间
    void PreOrder(){PreOrder(root);}    //前序遍历二叉树
    void InOrder(){InOrder(root);}      //中序遍历二叉树
    void PostOrder(){PostOrder(root);}  //后序遍历二叉树
    int Size(){return Size(root);}      //获取二叉树结点个数
    int Leaf(){return Leaf(root);}      //获取二叉树中叶子结点个数
    int Height(){return Height(root);}  //获取二叉树的高度(深度)
    void PreOrderN();                   //前序遍历算法非递归实现
    void InOrderN();                    //中序遍历算法非递归实现
    void Parent(int x);                 //寻找双亲结点
    void DelX(int x,int flag){DelX(root,x,flag);}   //删除值为x的结点的子树
    void LevelOrder();                  //层序遍历
};

二叉树类的各算法实现

创建二叉树

创建时需要自己指定规则

image-20211026211639901

BiNode *BiTree::Creat()
{
    //可以采用广义表的方法去建立二叉树
    // if(IsRoot==0)
    // {
    //     cout<<"请输入根结点数据域(0表示空)"
    // }
    BiNode *bt;
    int da; //临时变量
    cout << "请输入该结点数据域（0表示空）:";
    cin >> da;
    if (da == 0)
    {
        bt = nullptr;
    }
    else
    {
        bt = new BiNode;
        bt->data = da;
        bt->lchild = Creat(); //递归调用创建结点方法
        bt->rchild = Creat(); //递归调用创建结点方法
    }
    return bt; //返回总树及每一棵子树的根节点root
}

销毁二叉树

销毁二叉树实际是后序遍历的一种操作

void BiTree::Release(BiNode *bt)
{
    //析构函数的调用过程
    cout << "析构" << endl;
    //和后续遍历的思想一致
    //左子树  右子树  根节点

    //递归终止条件
    if (bt == nullptr)
    {
        return;
    }
    else
    {
        Release(bt->lchild); //递归调用释放左子树
        Release(bt->rchild); //递归调用释放右子树
        delete bt;
    }
    cout << "析构成功" << endl;
}

前序遍历（递归）

前/中/后序遍历的递归算法基本一致，在此只对前序遍历进行说明。

void BiTree::PreOrder(BiNode *bt)
{
    //递归调用的终止条件
    if (bt == nullptr)
    {
        return;
    }
    else
    {
        //前序遍历： 根节点  左子树  右子树
        cout << bt->data << " "; //输出数据域
        PreOrder(bt->lchild);
        PreOrder(bt->rchild);
    }
}

求二叉树的总结点个数

递归

int BiTree::Size(BiNode *bt)
{
    if (bt == nullptr)
    {
        return 0;
    }
    return 1 + Size(bt->lchild) + Size(bt->rchild);
}

求叶子结点个数

递归

int BiTree::Leaf(BiNode *bt)
{
    //递归实现
    if (bt == nullptr)
    {
        return 0;
    }
    if (bt->lchild == nullptr && bt->rchild == nullptr)
    {
        return 1;
    }
    return Leaf(bt->lchild) + Leaf(bt->rchild); //递归调用子函数，求子树中叶子结点的个数
}

求二叉树的深度

int BiTree::Height(BiNode *bt)
{
    //求二叉树的高度(深度)
    if (bt == nullptr)
    {
        return 0;
    }
    int i = Height(bt->lchild);
    int j = Height(bt->rchild);
    return i < j ? j + 1 : i + 1;
}

前序遍历非递归实现

基于顺序栈

void BiTree::PreOrderN()
{
    //前序遍历算法的非递归实现
    BiNode *bt = this->root;
    BiNode *S[100]; //顺序栈 直接基于数组实现
    int top = -1;   //顺序栈初始化
    while (bt != nullptr || top != -1)
    {
        //终止条件：是空树且栈为空栈
        while (bt != nullptr)
        {
            cout << bt->data << " ";
            S[++top] = bt; //根指针入栈
            bt = bt->lchild;
        }
        if (top != -1)
        {
            bt = S[top--];
            bt = bt->rchild;
        }
    }
}

求某结点的双亲

void BiTree::Parent(int x)
{
    //int重载
    this->target = x; //更改靶子的值
    Parent(root);     //开始寻找双亲
}

void BiTree::Parent(BiNode *bt)
{
    if (bt != nullptr)
    {
        if (bt->lchild != nullptr && bt->lchild->data == target)
        {
            cout << "值为" << target << "的结点的双亲结点的值为" << bt->data << endl;
            return;
        }
        if (bt->rchild != nullptr && bt->rchild->data == target)
        {
            cout << "值为" << target << "的结点的双亲结点的值为" << bt->data << endl;
            return;
        }
        else
        {
            Parent(bt->lchild);
            Parent(bt->rchild);
        }
    }
}

删除以某结点为根的子树

int BiTree::DelX(BiNode *bt, int x, int flag)
{
    //删除值为x的结点的子树  递归方法实现  flag为标志 用于记录并判断
    if (bt == nullptr)
    {
        return 0;
    }
    else
    {
        if (bt->data == x) //如果当前结点的值为x，则更改标志，并将标志向下传递
        {
            flag = 1;
        }

        int leftFlag = DelX(bt->lchild, x, flag);  //递归左子树
        int rightFlag = DelX(bt->rchild, x, flag); //递归右子树

        if (1 == flag) //若flag为1，则说明其先祖结点有值为x，该子结点需要被删除
        {
            if (bt->data == x) //若其数据域为x，则应向上传递标志为1，以便赋空
            {
                return 1;
            }
            delete bt;
        }
        else
        {
            if (1 == leftFlag)
            {
                bt->lchild = nullptr; //从子结点接受收的信息，即如果其子结点为x，需要将其指针域赋空
            }

            if (1 == rightFlag)
            {
                bt->rchild == nullptr; //从子结点接受收的信息，即如果其子结点为x，需要将其指针域赋空
            }
        }
    }
    return 0;
}

层序遍历

基于队列

void BiTree::LevelOrder()
{
    //层序遍历 基于队列
    BiNode *Q[100]; //所需队列
    BiNode *q = nullptr;

    int front = -1, rear = -1; //队列初始条件
    if (root == nullptr)
    {
        //空树不操作
        return;
    }

    Q[++rear] = root; //根指针入队
    while (front != rear)
    {
        //遍历条件：当队列非空时
        q = Q[++front]; //出队
        cout << q->data << " ";
        if (q->lchild != nullptr)
            Q[++rear] = q->lchild;
        if (q->rchild != nullptr)
            Q[++rear] = q->rchild;
    }
}

源代码

BiTree.h

/*
二叉树
树结构本身是递归定义的
在这里，我们整个数据结构的定义和实现也大多基于递归
与欢行
*/

#include<iostream>
#include"queue"
using namespace std;

//结点结构体的定义
struct BiNode
{
    /* data */
    int data;
    BiNode *lchild; //左孩子
    BiNode *rchild; //右孩子
};

class BiTree
{
private:
    /* data */
    int IsRoot=0;
    BiNode *Creat();                //构造函数调用
    void Release(BiNode *bt);       //析构函数调用
    void PreOrder(BiNode *bt);      //前序遍历函数调用
    void InOrder(BiNode *bt);       //中序遍历函数调用
    void PostOrder(BiNode *bt);     //后序遍历函数调用过程
    int Size(BiNode *bt);           //获取结点个数调用过程
    int Leaf(BiNode *bt);           //求叶子结点个数的调用过程
    void Parent(BiNode *bt);        //求双亲结点调用过程
    int Height(BiNode *bt);         //获取二叉树高度的调用过程
    int DelX(BiNode *bt,int x,int flag);    //删除子树的递归调用过程
    BiNode *root;                   //指向根节点的头指针
    int target;
public:
    //BiNode *root;
    BiTree(){this->root=Creat();}   //构造函数  建立一棵二叉树
    ~BiTree(){Release(root);}       //析构函数，释放各结点的存储空间
    void PreOrder(){PreOrder(root);}    //前序遍历二叉树
    void InOrder(){InOrder(root);}      //中序遍历二叉树
    void PostOrder(){PostOrder(root);}  //后序遍历二叉树
    int Size(){return Size(root);}      //获取二叉树结点个数
    int Leaf(){return Leaf(root);}      //获取二叉树中叶子结点个数
    int Height(){return Height(root);}  //获取二叉树的高度(深度)
    void PreOrderN();                   //前序遍历算法非递归实现
    void InOrderN();                    //中序遍历算法非递归实现
    void Parent(int x);                 //寻找双亲结点
    void DelX(int x,int flag){DelX(root,x,flag);}   //删除值为x的结点的子树
    void LevelOrder();                  //层序遍历
};

BiTree.cpp

#include "BiTree.h"

BiNode *BiTree::Creat()
{
    //可以采用广义表的方法去建立二叉树
    // if(IsRoot==0)
    // {
    //     cout<<"请输入根结点数据域(0表示空)"
    // }
    BiNode *bt;
    int da; //临时变量
    cout << "请输入该结点数据域（0表示空）:";
    cin >> da;
    if (da == 0)
    {
        bt = nullptr;
    }
    else
    {
        bt = new BiNode;
        bt->data = da;
        bt->lchild = Creat(); //递归调用创建结点方法
        bt->rchild = Creat(); //递归调用创建结点方法
    }
    return bt; //返回总树及每一棵子树的根节点root
}

void BiTree::Release(BiNode *bt)
{
    //析构函数的调用过程
    cout << "析构" << endl;
    //和后续遍历的思想一致
    //左子树  右子树  根节点

    //递归终止条件
    if (bt == nullptr)
    {
        return;
    }
    else
    {
        Release(bt->lchild); //递归调用释放左子树
        Release(bt->rchild); //递归调用释放右子树
        delete bt;
    }
    cout << "析构成功" << endl;
}

void BiTree::PreOrder(BiNode *bt)
{
    //递归调用的终止条件
    if (bt == nullptr)
    {
        return;
    }
    else
    {
        //前序遍历： 根节点  左子树  右子树
        cout << bt->data << " "; //输出数据域
        PreOrder(bt->lchild);
        PreOrder(bt->rchild);
    }
}

void BiTree::InOrder(BiNode *bt)
{
    //中序遍历
    if (bt == nullptr)
    {
        return;
    }
    else
    {
        //中序遍历： 左子树  根节点 右子树
        InOrder(bt->lchild);
        cout << bt->data << " ";
        InOrder(bt->rchild);
    }
}

void BiTree::PostOrder(BiNode *bt)
{
    //后序遍历
    if (bt == nullptr)
    {
        return;
    }
    else
    {
        //后序遍历：左子树 右子树 根节点
        PostOrder(bt->lchild);
        PostOrder(bt->rchild);
        cout << bt->data << " ";
    }
}

int BiTree::Size(BiNode *bt)
{
    if (bt == nullptr)
    {
        return 0;
    }
    return 1 + Size(bt->lchild) + Size(bt->rchild);
}

int BiTree::Leaf(BiNode *bt)
{
    //递归实现
    if (bt == nullptr)
    {
        return 0;
    }
    if (bt->lchild == nullptr && bt->rchild == nullptr)
    {
        return 1;
    }
    return Leaf(bt->lchild) + Leaf(bt->rchild); //递归调用子函数，求子树中叶子结点的个数
}

int BiTree::Height(BiNode *bt)
{
    //求二叉树的高度(深度)
    if (bt == nullptr)
    {
        return 0;
    }
    int i = Height(bt->lchild);
    int j = Height(bt->rchild);
    return i < j ? j + 1 : i + 1;
}

void BiTree::PreOrderN()
{
    //前序遍历算法的非递归实现
    BiNode *bt = this->root;
    BiNode *S[100]; //顺序栈 直接基于数组实现
    int top = -1;   //顺序栈初始化
    while (bt != nullptr || top != -1)
    {
        //终止条件：是空树且栈为空栈
        while (bt != nullptr)
        {
            cout << bt->data << " ";
            S[++top] = bt; //根指针入栈
            bt = bt->lchild;
        }
        if (top != -1)
        {
            bt = S[top--];
            bt = bt->rchild;
        }
    }
}

void BiTree::InOrderN()
{
    //中序遍历算法的非递归实现
    BiNode *bt = this->root;
    BiNode *S[100]; //顺序栈 直接基于数组实现
    int top = -1;   //顺序栈初始化
    while (bt != nullptr || top != -1)
    {
        //终止条件：是空树且栈为空栈
        while (bt != nullptr)
        {
            S[++top] = bt; //根指针入栈
            bt = bt->lchild;
        }
        if (top != -1)
        {
            bt = S[top--];
            cout << bt->data << " ";
            bt = bt->rchild;
        }
    }
}

void BiTree::Parent(int x)
{
    //int重载
    this->target = x; //更改靶子的值
    Parent(root);     //开始寻找双亲
}

void BiTree::Parent(BiNode *bt)
{
    if (bt != nullptr)
    {
        if (bt->lchild != nullptr && bt->lchild->data == target)
        {
            cout << "值为" << target << "的结点的双亲结点的值为" << bt->data << endl;
            return;
        }
        if (bt->rchild != nullptr && bt->rchild->data == target)
        {
            cout << "值为" << target << "的结点的双亲结点的值为" << bt->data << endl;
            return;
        }
        else
        {
            Parent(bt->lchild);
            Parent(bt->rchild);
        }
    }
}

int BiTree::DelX(BiNode *bt, int x, int flag)
{
    //删除值为x的结点的子树  递归方法实现  flag为标志 用于记录并判断
    if (bt == nullptr)
    {
        return 0;
    }
    else
    {
        if (bt->data == x) //如果当前结点的值为x，则更改标志，并将标志向下传递
        {
            flag = 1;
        }

        int leftFlag = DelX(bt->lchild, x, flag);  //递归左子树
        int rightFlag = DelX(bt->rchild, x, flag); //递归右子树

        if (1 == flag) //若flag为1，则说明其先祖结点有值为x，该子结点需要被删除
        {
            if (bt->data == x) //若其数据域为x，则应向上传递标志为1，以便赋空
            {
                return 1;
            }
            delete bt;
        }
        else
        {
            if (1 == leftFlag)
            {
                bt->lchild = nullptr; //从子结点接受收的信息，即如果其子结点为x，需要将其指针域赋空
            }

            if (1 == rightFlag)
            {
                bt->rchild == nullptr; //从子结点接受收的信息，即如果其子结点为x，需要将其指针域赋空
            }
        }
    }
    return 0;
}

void BiTree::LevelOrder()
{
    //层序遍历 基于队列
    BiNode *Q[100]; //所需队列
    BiNode *q = nullptr;

    int front = -1, rear = -1; //队列初始条件
    if (root == nullptr)
    {
        //空树不操作
        return;
    }

    Q[++rear] = root; //根指针入队
    while (front != rear)
    {
        //遍历条件：当队列非空时
        q = Q[++front]; //出队
        cout << q->data << " ";
        if (q->lchild != nullptr)
            Q[++rear] = q->lchild;
        if (q->rchild != nullptr)
            Q[++rear] = q->rchild;
    }
}

main.cpp

#include<iostream>
#include"BiTree.h"
using namespace std;

int main()
{
    cout<<"基于链式存储结构的二叉树"<<endl;
    BiTree b1;
    cout<<"前序遍历(递归)：";
    b1.PreOrder();
    cout<<endl;

    cout<<"前序遍历(非递归)：";
    b1.PreOrderN();
    cout<<endl;

    cout<<"中序遍历(递归)：";
    b1.InOrder();
    cout<<endl;

    cout<<"中序遍历(非递归)：";
    b1.InOrderN();
    cout<<endl;

    cout<<"后序遍历：";
    b1.PostOrder();
    cout<<endl;

    cout<<"层序遍历：";
    b1.LevelOrder();
    cout<<endl;

    int fl=0;
    b1.DelX(2,fl);
    cout<<"前序遍历(递归)：";
    b1.PreOrder();
    cout<<endl;

    b1.Parent(4);
    cout<<"当前二叉树共有"<<b1.Leaf()<<"个叶子结点"<<endl;
    cout<<"当前二叉树共有"<<b1.Size()<<"个结点"<<endl;
    cout<<"当前二叉树的高度(深度)为"<<b1.Height()<<endl;
    system("pause");
    return 0;
}

测试

main.cpp

int main()
{
    cout<<"基于链式存储结构的二叉树"<<endl;
    BiTree b1;
    cout<<"前序遍历(递归)：";
    b1.PreOrder();
    cout<<endl;

    cout<<"前序遍历(非递归)：";
    b1.PreOrderN();
    cout<<endl;

    cout<<"中序遍历(递归)：";
    b1.InOrder();
    cout<<endl;

    cout<<"中序遍历(非递归)：";
    b1.InOrderN();
    cout<<endl;

    cout<<"后序遍历：";
    b1.PostOrder();
    cout<<endl;

    cout<<"层序遍历：";
    b1.LevelOrder();
    cout<<endl;

    int fl=0;
    b1.DelX(2,fl);
    cout<<"前序遍历(递归)：";
    b1.PreOrder();
    cout<<endl;

    b1.Parent(4);
    cout<<"当前二叉树共有"<<b1.Leaf()<<"个叶子结点"<<endl;
    cout<<"当前二叉树共有"<<b1.Size()<<"个结点"<<endl;
    cout<<"当前二叉树的高度(深度)为"<<b1.Height()<<endl;
    system("pause");
    return 0;
}

我们创建这样的一棵树

image-20211026212602746

image-20211026212134006

CTENET
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
查找二叉排序树的双亲节点，并输出路径project
04-25
查找二叉排序树的双亲节点，并输出路径project
二叉树基本操作
04-30
以二叉链表作存储结构，编写程序，实现如下的功能： 1、根据输入的数据建立一个二叉树； 2、分别采用前序、中序、后序的遍历方式显示输出二叉树的遍历结果 3、采用非递归的编程方法，分别统计二叉树的节点个数、度为...
【数据结构】【算法】二叉树、二叉排序树、树的相关操作
强我强国
05-13 1405
二叉树或者为空，或者由一个根节点加上根节点的左子树和右子树组成。要求左子树和右子树互不相交，且同为二叉树。显然，这个定义式是递归形式的。二叉树的每个节点至多有两个孩子节点，其中左边的孩子节点被称为左孩子，右边的孩子节点被称为右孩子。
二叉树查找双亲结点
热门推荐
qq_43527713的博客
11-15 1万+
//递归实现查找双亲结点 void Find_Father(BiTNode *(&T),ElemType data) { if(T ==NULL) return; if(T->lchild != NULL)//当左孩子存在的时候才进行判断，否则程序出错 { if(T->lchild->data == data)...
设计一个求结点x在二叉树中的双亲结点算法
qq_53943186的博客
08-22 2282
如果 x 不是根节点，检查根节点的左子树和右子树是否存在 x 节点。若左子树中找到了 x 节点，则返回根节点作为 x 的双亲节点。首先检查根节点是否为空或者根节点是否就是要查找的节点 x，若是，则说明 x 没有双亲节点，返回空（或者其他适合的标识）。否则，在右子树中找到了 x 节点，则同样返回根节点作为 x 的双亲节点。是要查找其双亲节点的节点。是当前子树的根节点，
查找二叉排序树的双亲节点，并输出路径
qq_42295590的博客
04-25 2661
查找二叉排序树的双亲节点，并输出路径 题目 设计算法查找二叉排序树中某特定值的双亲结点。如果找到，输出从根结点到该值结点的双亲结点的路径。找不到这样的结点或根结点就等于该特定值就返回一个未找到的提示。例如下图，查找17，就输9，18，16。查找19，就输出未找到。 算法思想 ① 特定结点值等于当前节点值或者当前结点为空，返回空，表示未找到特定值。 若特定结点值不等于当前节点值，执行②。 ② 如果特定结点不等于当前结点左孩子或者右孩子的值，输出当前结点值， 如果特定结点值小于当前结点值，将当
实验四 二叉树操作实现.docx
10-27
实验四 二叉树操作实现.docx实验四 二叉树操作实现.docx
实验四 二叉树操作实现.pdf
10-27
实验四 二叉树操作实现.pdf实验四 二叉树操作实现.pdf
实验四-二叉树操作实现.pdf
07-03
。。。
实验四-二叉树操作实现.doc
10-12
实验四-二叉树操作实现.doc
关于二叉查找树如何获取其双亲结点的方法
ye_little_white的博客
12-16 4913
关于二叉查找树如何获取其双亲结点的方法 二叉树结构体的定义如下 struct binaryTree; typedef struct binaryTree { int value; binaryTree* LeftChild; binaryTree* RightChild; }TreeNode; 以下是如何获取双亲结点的具体代码 TreeNode* Parent_LinkedList(TreeNode* node) {
编写算法求二叉树结点x的双亲
最新发布
weixin_45999886的博客
10-29 919
【代码】编写算法求二叉树结点x的双亲。
求一个结点x在在二叉树中的双亲结点算法
qq_51691366的博客
10-18 6677
该算法的实现是借助二叉树的先序遍历。递归遍历二叉树，每一次递归调用首先利用先序遍历判断当前根节点是否存在左右孩子，若是存在并且左右中的数值就是所给参数的孩子结点，那么当前父节点肯定是所给孩子结点的父亲节点，直接使用return返回当前参数结点的父亲节点，强行退出递归调用栈，程序执行完毕！否则继续递归调用二叉树，直到查找成功或者失败！使用先序递归遍历思想完成算法设计。首先判断节点的左右孩子是否存在，若存在，并且左右孩子中有一个符合查找要求，则返回元素！否则，继续递归查找，直到成功或者找不到符合要求的结点！
二叉树：设计一个求结点x在二叉树中的双亲结点算法。用c语言
qq_53943186的博客
10-17 1002
【代码】二叉树：设计一个求结点x在二叉树中的双亲结点算法。用c语言。
C++查找二叉树中指定值的双亲节点
jmxyqrx的博客
11-17 2321
这里写自定义目录标题题目与思路代码 题目与思路 题目：假设二叉树中所有结点值为单个字符且均不相同，采用二叉链存储结构存储。设计一个算法求二叉树b中指定值为x的结点的双亲节点p，提示：根节点的双亲节点为NULL，若在b中未找到值为x的结点，p也为NULL；并用相关数据进行测试。 思路：在创建二叉树时直接将各个节点的parent节点保存起来。 代码 去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片. #include <iostream> using namespace s
【二叉树】45 二叉树：结点个数
windyuan~
02-25 496
问题描述 : 内容：（1）请参照链表的ADT模板，设计二叉树并逐步完善的抽象数据类型。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。参考教材、课件，以及网盘中的链表ADT原型文件，自行设计二叉树的ADT。） 注意：二叉树ADT的基本操作的算法设计很多要用到递归的程序设计方法。 （2）基本操作17：在二叉树的二叉链表存储形式建立的基础上，使用递归的程序设计方法，设计并完成统计结点个数的算法。完成后将其加入到二.
数据结构实验——查找实验
qq_65814357的博客
07-05 1703
一实验内容编写算法实现下列问题的求解。(1) 对下列数据表，分别采用二分查找算法实现查找，给出查找过程依次所比较的元素（的下标），并以二分查找的判定树来解释。 第一组测试数据：数据表为 (1,2,3,4,6,7,8,9,10,11,12,13,17,18,19,20,24,25,26,30,35,40,45,50,,100)查找的元素分别为： 2，8，20, 30，50，5，15，33，110 第二组数据：数据表为 (2,3,5,7,8,10,12,15,18,20,22,25,30,35,40,
[数据结构]【C++】实验七 查找实验 7.1 实验目的(1) 掌握顺序表的查找方法，尤其是二分查找方法。(2) 掌握二叉排序树的建立及查找。 查找是软件设计中的最常用的运算，查找所涉
m0_73952999的博客
06-19 471
首先，如前面的任务一样，根据文件读写到的数据查找二叉排序树中的对应节点，在传入数据中，利用lu_all来记录查找的次数。前者可通过顺序排序后进行二分查找的方法进行查找。此题我有两种实现方法，首先第一种通过输入的各个元素值，构建正确的二叉排序树，通过返回对应的二叉树根节点指针与题中所给的数据挨个元素经行对比，进行中序遍历，与题中数据对比后，若有数据不同则二叉排序树并非正确。测试数据：在任务(1)中第一组测试数据所构造的二叉排序树中，分别查找下列元素： 150，70，160，190，10，55，175。
二叉排序树（BST）的算法分析以及基本操作（结点的查询，插入，删除）
jungleirim的博客
09-13 677
二叉排序树，又称二叉查找树（BST，Binary Search Tree)默认不允许两个结点的关键字相同。
二叉树操作代码实现c语言
09-19
下面是一个使用C语言实现二叉树操作的代码示例： ```c #include #include // 定义二叉树节点结构体 typedef struct TreeNode { int value; struct TreeNode* left; struct TreeNode* right; } TreeNode; // ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值