二叉树的代码实现-高级数据结构

最新推荐文章于 2024-06-06 20:24:49 发布
最新推荐文章于 2024-06-06 20:24:49 发布
阅读量1.7k 收藏 5
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iMEANT/article/details/81056619
版权

头文件：

#include<assert.h>
#include<stack>
#include<queue>
#include<iostream>
using namespace std;

定义二叉树的结点类型：

typedef char ELemType;
#define END '#'
typedef struct BtNode
{
    BtNode *leftchild;
    BtNode *rightchild;
    ElemType data;
}BtNode,*BinaryTree;

构造树结点：

BtNode *Buynode()
{
    BtNode *p=(BtNode*)malloc(sizeof(BtNode));
    p->leftchild=NULL;
    p->rightchild=NULL;
    p->data=0;
}

二叉树的三种遍历方式：

//先序
void PreOrder(BtNode *p)
{
    if(p!=NULL)
    {
        cout<<p->data<<" ";
        PreOrder(p->leftchild);
        PreOrder(p->rightchild);
    }
}
//中序
void InOrder(BtNode *p)
{
    if(p!=NULL)
    {
        InOrder(p->leftchild);
        cout<<p->data<<" ";
        InOrder(p->rightchild);
    }
}
//后序
void PastOrder(BtNode *p)
{
    if(p!=NULL)
        {
            PastOrder(p->leftchild);
            PastOrder(p->rightchild);
            cout<<p->data<<“ ”；
        }
}

二叉树的实现方法：

//1.输入结点+#号
BtNode* CreateTree1()
{
    ElemType item;
    cin>>item;
    BtNode*p=NULL;
    if(item!=END)
    {
        p=Buynode();
        p->data=item;
        p->leftchild=CreateTree1();
        p->rightchild=CreateTree1();
    }
        return p;
}
//2.
BtNode* CreateTree2(char *str)
{
    BtNode *p = NULL;
    if (str != NULL && *str != END)
    {
       p = Buynode();
       p->data = *str;
       p->leftchild = CreateTree2(++str);
       p->rightchild = CreateTree2(++str);
    }
    return p;
}
//3.
BtNode *CreateTree3(ElemType ** const pstr)
{
     BtNode *s = NULL;
     if (pstr != NULL && *pstr != NULL && **pstr != END)
     {
          s = Buynode();
          s->data = **pstr;
          s->leftchild = CreateTree3(&++*pstr);//*pstr->++*pstr->&++*pstr
          s->rightchild = CreateTree3(&++*pstr);
     }
     return s;
}
//4.已知先序和中序，求后序
int FindIs(ElemType *is, ElemType ps, int n)
{
     for (int i = 0; i < n; ++i)
     {
          if (is[i] == ps)
          {
              return i;
          }
     }
     return -1;
}
BtNode *CreatePI(ElemType *ps, ElemType *is, int n)
{
     BtNode *s = NULL;
     if (n > 0)
     {
          s = Buynode();
          s->data = ps[0];
          int pos = FindIs(is, ps[0], n);
          if (pos == -1)
          {
              exit(1);
          }
          s->leftchild = CreatePI(ps + 1, is, pos);
          s->rightchild = CreatePI(ps + pos + 1, is + pos  + 1, n - pos - 1);
     }
     return s;
}
BtNode *CreateTreePI(ElemType *ps, ElemType *is, int n)
{
     if (ps == NULL && is == NULL && n < 1)
     {
          return NULL;
     }
     else
     {
          return CreatePI(ps, is, n);
     }
}
//5、已知中序和后序，求先序
int FindIL(ElemType *is, ElemType ls, int n)
{
     for (int i = 0; i < n; ++i)
     {
          if (is[i] == ls)
          {
              return i;
          }
     }
     return -1;
}
BtNode *CreateIL(ElemType *is, ElemType *ls, int n)
{
     BtNode *s = NULL;
     if (n > 0)
     {
          s = Buynode();
          s->data = ls[n - 1];
          int pos = FindIL(is, ls[n - 1], n);
          if (pos == -1)
          {
              exit(1);
          }
          s->leftchild = CreatePI(is, ls, pos);
          s->rightchild = CreatePI(is + pos + 1, ls + pos,  n - pos - 1);
     }
     return s;
}
BtNode *CreateTreeIL(ElemType *is, ElemType *ls, int n)
{
     if (is == NULL && ls == NULL && n < 1)
     {
          return NULL;
     }
     else
     {
          return CreateIL(is, ls, n);
     }
}
//6、
void Tree6(int *ar, int i, int n)
{
     if (i<n)
     {
          Tree6(ar, i * 2 + 1, n);
          cout << ar[i] << " ";
          Tree6(ar, i * 2 + 2, n);
     }
}
void CreateTree6(int *ar, int n)
{
     if (ar == NULL || n < 1)
     {
          return;
     }
     else
     {
          Tree6(ar, 0, n);
     }
}
//7、数组转换成二叉树
BtNode *Create(int *ar, int i, int n)
{
     BtNode *s = NULL;
     if (i < n)
     {
          s = Buynode();
          s->data = ar[i];
          s->leftchild = Create(ar, i * 2 + 1, n);
          s->rightchild = Create(ar, i * 2 + 2, n);
     }
     return s;
}
BtNode *CreateAr(int *ar, int n)
{
     if (ar == NULL || n < 1)
     {
          return NULL;
     }
     else
     {
          return Create(ar, 0, n);
     }
}
//8、二叉树转换成数组
void Link_to_Ar(BtNode *ptr, int *buff, int i)
{
     if (ptr != NULL)
     {
          buff[i] = ptr->data;
          Link_to_Ar(ptr->leftchild, buff, i * 2 + 1);
          Link_to_Ar(ptr->rightchild, buff, i * 2 + 2);
     }
}
void CreateLink(BtNode *ptr, int *buff)
{
     if (ptr == NULL || buff == NULL)
     {
          return;
     }
     Link_to_Ar(ptr, buff, 0);
}
//9.树的结点个数
int Size_Tree(BtNode *ptr)
{
     if (ptr == NULL)
     {
          return 0;
     }
     else return Size_Tree(ptr->leftchild) +  Size_Tree(ptr->rightchild) + 1;
}
//10.树的深度
int Depth_Tree(BtNode *ptr)
{
     if (ptr == NULL)
     {
          return 0;
     }
     else return Depth_Tree(ptr->leftchild) >  Depth_Tree(ptr->rightchild) ? Depth_Tree(ptr->leftchild)  + 1 : Depth_Tree(ptr->rightchild) + 1;
}
//11.找节点
BtNode *FindValue(BtNode *ptr, ElemType x)
{
     if (ptr == NULL || ptr->data == x)
     {
          return ptr;
     }
     else
     {
          BtNode *p = FindValue(ptr->leftchild, x);
          if (NULL == p)
          {
              p = FindValue(ptr->rightchild, x);
          }
          return p;
     }
}
//12.非递归的前序
void NicePreOrder(BtNode *ptr)
{
     if (ptr == NULL) return;
     stack<BtNode*> st;
     st.push(ptr);
     while (!st.empty())
     {

          ptr = st.top(); st.pop();
          cout << ptr->data << " ";
          if (ptr->rightchild != NULL)
          {
              st.push(ptr->rightchild);
          }
          if (ptr->leftchild)
          {
              st.push(ptr->leftchild);
          }
     }
     cout << endl;
}
//13.非递归的中序遍历（引入栈是为了模拟二叉树的递归调用)
void NiceInOrder(BtNode *ptr)
{
     if (ptr == NULL) return;
     stack<BtNode*> st;
     while (ptr != NULL || !st.empty())
     {
          while (ptr != NULL)
          {
              st.push(ptr);
              ptr = ptr->leftchild;
          }
          ptr = st.top(); st.pop();
          cout << ptr->data << " ";
          ptr = ptr->rightchild;
     }
}
//14.非递归的后序
void NicePastOrder(BtNode *ptr)
{
     if (ptr == NULL) return;
     stack<BtNode*> st;
     BtNode * tag = NULL;
     while (ptr != NULL || !st.empty())
     {
          while (ptr != NULL)
          {
              st.push(ptr);
              ptr = ptr->leftchild;
          }
          ptr = st.top(); st.pop();
          if (ptr->rightchild == NULL || ptr->rightchild  == tag)
          {
              cout << ptr->data << " ";
              tag=ptr;
              ptr = NULL;
          }
          else
          {
              st.push(ptr);
              ptr = ptr->rightchild;
          }
     }
     cout << endl;
}
//15.非递归的层次，广度遍历
void NiceLeveOrder(BtNode* ptr)
{
     if (ptr == NULL) return;
     queue<BtNode*> sq;
     sq.push(ptr);
     while (!sq.empty())
     {
          ptr=sq.front();
          sq.pop();
          cout << ptr->data << " ";
          if (ptr->leftchild != NULL)
          {
              sq.push(ptr->leftchild);
          }
          if (ptr->rightchild != NULL)
          {
              sq.push(ptr->rightchild);
          }
     }
        cout<<endl;
}
//16.递归的层次，广度遍历
void Print_K(BtNode *ptr,int k)
{
      if(ptr != NULL && k == 0)
      {
            cout<<ptr->data<<" ";
      }
      else if(ptr != NULL)
      {
            Print_K(ptr->leftchild,k-1);
            Print_K(ptr->rightchild,k-1);
      }
}
void Print_K_Item(BtNode *ptr,int k)//打印第k层结点
{
      if(ptr == NULL || k < 0)
            return ;
      Print_K(ptr,k);
      cout<<endl;
}
void LevelOrder(BtNode *ptr)
{
      int n = Depth(ptr);
      for(int i = 0;i<n;++i)
      {
            Print_K_Item(ptr,i);
      }
}
//17.根据结点
bool Is_Full_BinaryTree1(BtNode *ptr)
{
     int h = Depth_Tree(ptr);
     int total = Size_Tree(ptr);
     if (total = pow(2, h + 1) - 1)
     {
          return true;
     }
}
//18.根据高度
bool Is_Full_BinaryTree2(BtNode* ptr)
{
     return (ptr == NULL) ||
          (Is_Full_BinaryTree2(ptr->leftchild) &&  
           Is_Full_BinaryTree2(ptr->rightchild)&&
          Depth_Tree(ptr->leftchild) ==  Depth_Tree(ptr->rightchild));
}
//19.层次
bool Is_Full_BinaryTree3(BtNode* ptr)
{
     bool res = true;
     if (ptr == NULL){ return true; }
     queue<BtNode*> sq;
     int n = 1;
     sq.push(ptr);
     while (!sq.empty())
     {
          for (int i = 0; i < n&&!sq.empty(); ++i)
          {
              BtNode*p= sq.front();
              sq.pop();
              if (p->leftchild != NULL)
              {
                   sq.push(p->leftchild);
              }
              if (p->rightchild != NULL)
              {
                   sq.push(p->rightchild);
              }
              if (i < n)
              {
                   res = false;
                   break;
              }
          }

          n += n;

     }
        return res;
}
//20.寻找最近双亲
BtNode *FindNearParent();
//21.寻找双亲（都打印）
BtNode* Find(BtNode* ptr, BtNode* child)
{
     if (ptr == NULL || ptr->leftchild == child ||  ptr->rightchild == child)
     {
          return ptr;
     }
     else
     {
          BtNode* p = Find(ptr->leftchild, child);
          if (NULL == p)
          {
              p = Find(ptr->rightchild, child);
          }
          return p;
     }


}
BtNode *FindParent(BtNode *ptr, BtNode *child)
{
     if (ptr == NULL||child==NULL||ptr == child){return  NULL;}
     else return Find(ptr,child);
}
//22.判断是不是完全二叉树
bool Is_Comp_BinaryTree(BtNode *ptr)
{
     bool res = true;
     if (ptr == NULL){ return true; }
     queue<BtNode*> sq;
     sq.push(ptr);
     while (!sq.empty())
     {
          BtNode*p= sq.front();
          sq.pop();
          if (p == NULL)
          {
              break;
          }
          sq.push(p->leftchild);
          sq.push(p->rightchild);
     }
     while (!sq.empty())
     {
          BtNode*q = sq.front;
          sq.pop();
          if (q != NULL)
          {
              res = false;
              break;
          }
     }
     return res;
}

总结：代码不是很繁琐，主要在于思想，加油！

iMEANT
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构-第五期——二叉树（Python）
荷叶田田的博客
12-21 3919
二叉树满足条件：1、本身是有序树 2、树中包含的各个节点的度不能超过 2，即只能是 0、1 或者 2；
邓俊辉-数据结构，python实现.zip
06-17
在这个zip文件中，"ljg_resource1"可能是邓教授提供的一个或多个资料，如讲义、代码示例或者练习题，用于帮助学习者理解并实践数据结构的Python实现。 数据结构是计算机科学中的重要概念，它研究如何在计算机中组织...
《数据结构C语言版》——二叉树详解(图文并茂)
青春无问西东 岁月自成芳华
05-20 1万+
C语言版本的数据结构详解，讲解树、二叉树及其对应的定义、建立、性质
【数据结构】二叉树的实现
m0_72651735的博客
05-02 32
而第二种情况是队列不为空，但在访问队头节点时访问到了 NULL，这时我们需要再次进行循环，若队列不为空，就进入循环逐个查找并删除队头的节点，若发现不为空的节点，说明节点间有 NULL 相隔，即该二叉树不是完全二叉树，返回false。设二叉树的根节点所在层数为 1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第 2 层上的节点，接着是第三层的节点，以此类推。若节点不为空，但节点的值不是我们要查找的值，就查找节点的左子树，如果查找的结果不为空，就返回该节点。
数据结构----二叉树
m0_74319933的博客
06-06 689
树是一种模拟具有层次关系的数据集合的非线性数据结构。它由节点和连接节点的边组成，具有一个称为根的起始节点，每个节点可以有零个或多个子节点，但只能有一个父节点。二叉树是树的一种特殊形式，其中每个节点最多有两个子节点，分别称为左子节点和右子节点。这种结构限制使得二叉树在搜索、排序和许多其他算法中非常有用。本文详细介绍了树和二叉树的基本概念、结构特点以及C语言实现。此外，还探讨了一些高级二叉树概念，如完全二叉树、二叉搜索树、平衡二叉树等，并通过代码示例展示了它们的实现。
Java初阶数据结构二叉树实现+练习完整（工程文件后序会进行上传）
cjmyydsds的博客
03-16 1464
（1）链表存储是用一个节点一个节点来引用起来的，常见的有二叉和三叉表示方式（2）双孩子双亲表示法就是红黑树那些，我们会在高级数据结构中进行讲解我们的初级数据结构中使用的就是孩子表示法5.2 二叉树链表式存储实现（孩子表示法）代码实现定义三个类测试类节点类二叉树类（1）这三个类会整体实现这个二叉树（2）定义一个一般的二叉树的节点类型（3）接下来我会用穷举的方法来实现二叉树，因为不这样搞你们看不懂图解我会定义这些节点然后用手动的方式拼接起来。
高级前端必备--数据结构
越努力越幸运
11-18 1645
数据结构 时间空间复杂度 一个是运行时间的长短，一个是占用内存空间的大小。衡量程序好坏的重要因素 逻辑结构和物理结构 逻辑结构 线性结构 （顺序表、栈、队列…） 非线性结构 （二叉树、图…） 物理结构 顺序存储结构（数组） 链式存储结构（链表） 数组的访问速度最快，直接访问下标就行。 链表 单向链表 双向链表 查找元素的时候，链表不像数组可以通过下标，快速定位，只能从头结点一个个往下找。 数组在内存中是顺序存储，所以可以直接用下标查找，而链表是乱序存储，只能通过next指针一个个往下找
数据结构与算法-树与二叉树
2401_84046635的博客
04-21 702
既然选择这个行业，选择了做一个程序员，也就明白只有不断学习，积累实战经验才有资格往上走，拿高薪，为自己，为父母，为以后的家能有一定的经济保障。学习时间都是自己挤出来的，短时间或许很难看到效果，一旦坚持下来了，必然会有所改变。不如好好想想自己为什么想进入这个行业，给自己内心一个答案。面试大厂，最重要的就是夯实的基础，不然面试官随便一问你就凉了；其次会问一些技术原理，还会看你对知识掌握的广度，最重要的还是你的思路，这是面试官比较看重的。
数据结构学习，二叉树
好好学习的博客
02-06 1943
创建一颗空二叉树 创建一颗二叉树，其中根结点的值为e，L和R分别为左子树和右子树 销毁二叉树 对二叉树判空 将一颗二叉树T分解成根，左子树，右子树3个部分 替换左子树，若T非空，则用LT替换T的左子树，并用LT返回T的原有左子树 替换右子树，若T非空，则用RT替换T的右子树，并用RT返回T的原有右子树 先序遍历二叉树 中序遍历二叉树 后序遍历二叉树 返回二叉树深度 用count对二叉树T的叶子计数 先序构造二叉树 层次遍历 先序非递归遍历 中序非递归遍历 后序非递归遍历
二叉树动态查找----python版
weixin_55816481的博客
03-15 1769
二叉搜索树
超硬核十万字！全网最全 数据结构 代码，随便秒杀老师/面试官，我说的
热门推荐
少说，多做。
04-20 11万+
本文代码实现基本按照《数据结构》课本目录顺序，外加大量的复杂算法实现，一篇文章足够。能换你一个收藏了吧？
exp3-BinaryTree.zip_二叉树的C语言实现_数据结构
09-20
同时，理解和掌握二叉树的各种操作对学习其他高级数据结构如平衡二叉树、B树等也大有裨益。 通过实践和理解二叉树及其线索化，你不仅能提升C语言编程能力，还能深化对数据结构和算法的理解，这对于成为一名优秀的IT...
数据结构实验 二叉树遍历与路径查找
07-18
在IT领域，数据结构是计算机科学的基础，而二叉树作为一种重要的数据...对于进一步学习高级数据结构和算法，如平衡二叉树、红黑树等，以及在计算机科学中的各种应用，如文件系统、编译器设计等，都有着坚实的基础作用。
数据结构-代码（C#实现）
04-18
本篇将详细探讨在C#中实现的数据结构，包括链表、栈、队列、二叉树、图、二分查找以及排序算法。 首先，链表是线性数据结构的一种，分为单链表、双向链表和循环链表。单链表每个节点仅包含指向下一个节点的指针；...
高级数据结构代码 红黑树 二叉树 B树
02-28
本资源包含关于三种高级数据结构的代码实现：红黑树、二叉树和B树。这些数据结构在实际编程中有着广泛的应用，尤其在算法设计、数据库系统、内存管理等领域。 首先，我们来看二叉树，它是数据结构中最基础也是最...
chromedriver-mac-arm64_126.0.6474.0.zip
07-31
chromedriver-mac-arm64_126.0.6474.0.zip
chromedriver-mac-arm64_128.0.6548.0.zip
最新发布
07-31
chromedriver-mac-arm64_128.0.6548.0.zip
MySQL查询加速器：利用Query Cache提升效率
07-31
MySQL是一个流行的开源关系型数据库管理系统（RDBMS），广泛用于Web应用程序的后端数据存储。它基于结构化查询语言（SQL）来管理数据，并且是LAMP（Linux, Apache, MySQL, PHP/Python/Perl）技术栈的一部分，这个技术栈常用于构建动态网站和Web应用程序。 MySQL的特点包括： - **开放源代码**：MySQL的源代码是公开的，任何人都可以自由使用和修改。 - **跨平台**：MySQL可以在多种操作系统上运行，包括Linux、Windows、macOS等。 - **高性能**：MySQL以其快速的查询处理和良好的性能而闻名。 - **可靠性**：MySQL提供了多种机制来确保数据的完整性和可靠性，包括事务支持、备份和恢复功能。 - **易于使用**：MySQL提供了简单直观的界面和丰富的文档，便于用户学习和使用。 - **可扩展性**：MySQL支持从小型应用到大型企业级应用的扩展。 - **社区支持**：由于其广泛的使用，MySQL拥有一个活跃的开发者社区，提供大量的资源和支持。 MySQL被广泛应用于各种场景，包括在线事务处理（OL
数据结构与算法-动态数据结构：二叉树遍历解析
在数据结构的学习中，理解和掌握二叉树的遍历是至关重要的，因为它们是许多高级算法和复杂数据处理的基础。通过熟练运用二叉树遍历，开发者可以更有效地处理和操作大量数据，提高代码的效率和可读性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值