数据结构实验--二叉树(C++实现)_数据结构实验二叉树c++-优快云博客

本文介绍了一种二叉树的非递归实现方法，包括创建、遍历及销毁等操作，并提供了完整的源代码示例。文章通过具体的C++实现展示了如何构造二叉树并进行不同类型的遍历。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

下面是源代码：

-----------------------------------------------------------

//二叉树的非递归实现，慢慢体会~！
#include <iostream>
using namespace std;

typedef char TElemType;

typedef struct BTNode
{
struct BTNode *_lchild;
TElemType _data;
struct BTNode *_rchild;
}BTNode,*BTNodePtr;

bool Put(TElemType e)
{
cout << e;
return true;
}

class BiTree
{
private:
BTNodePtr _root;
int n;                                 //结点数
int depth;                             //树深
public:
BiTree();
~BiTree();
bool CreateBiTree();                                          //构造新二叉树
bool DestroyTree(BTNodePtr T);                                //删除二叉树
bool PreOrderCreateBiTree(BTNodePtr& T);                      //按先序序列构造二叉树
bool VisitTraverse(bool visit(TElemType e));       //遍历二叉树
bool PreOrderTraverse(BTNodePtr T,bool visit(TElemType e));    //按先序序列遍历二叉树
bool InOrderTraverse(BTNodePtr T,bool visit(TElemType e));     //按先序序列遍历二叉树
bool PostOrderTraverse(BTNodePtr T,bool visit(TElemType e));   //按先序序列遍历二叉树
BTNodePtr GetRoot();                              //获取根节点
bool TreeEmpty();
int TreeDepth();
bool ExTreeDepth(BTNodePtr T,int dep);
bool ChangePtr();
bool PreChange(BTNodePtr T);
};

BiTree::~BiTree()
{
DestroyTree(_root->_lchild);
_root->_lchild=NULL;
}

bool BiTree::DestroyTree(BTNodePtr T)
{
if (T)
{
  DestroyTree(T->_lchild);
  DestroyTree(T->_rchild);
  delete T;
  return true;
}
return false;
}

BiTree::BiTree()
{
_root = new BTNode;
_root->_lchild = NULL;
_root->_rchild = NULL;
n = 0;
depth = 0;
}

bool BiTree::CreateBiTree()
{
cin.sync();
cout<<"请输入二叉树结点序列（按照先序序列构造）：";
if (PreOrderCreateBiTree(_root->_lchild))
{
return true;
}
else
return false;
}

bool BiTree::PreOrderCreateBiTree(BTNodePtr& T)
{
char ch;
ch = getchar();
if ( ch == ' ' )
{
  T = NULL;
}
else
{
  if ( !(T = new BTNode))
  {
   exit(1);
  }
  n++;
  T->_data = ch;
  PreOrderCreateBiTree( T->_lchild );
  PreOrderCreateBiTree( T->_rchild );
}
return true;
}

bool BiTree::VisitTraverse(bool visit(TElemType e))
{
cout<<"请选择遍历二叉树的方式："<<endl;
cout<<"1：按先序序列遍历"<<endl;
cout<<"2：按中序序列遍历"<<endl;
cout<<"3：按后序序列遍历"<<endl;
int choice;
cin>>choice;
switch (choice)
{
case 1:
  {
   PreOrderTraverse(_root->_lchild,visit);
   break;
  }
case 2:
  {
   InOrderTraverse(_root->_lchild,visit);
   break;
  }
case 3:
  {
   PostOrderTraverse(_root->_lchild,visit);
   break;
  }
default:
  return false;
}
return true;
}

bool BiTree::PreOrderTraverse(BTNodePtr T,bool visit(TElemType e))
{
if (T)
{
  if (visit(T->_data))
  {
   if (PreOrderTraverse(T->_lchild,visit))
   {
    if (PreOrderTraverse(T->_rchild,visit))
    {
     return true;
    }
    else
     return false;
   }
   else
    return false;
  }
  else
   return false;
}
else
  return true;
}

bool BiTree::InOrderTraverse(BTNodePtr T,bool visit(TElemType e))
{
if (T)
{
  if (InOrderTraverse(T->_lchild,visit))
  {
   if (visit(T->_data))
   {
    if (InOrderTraverse(T->_rchild,visit))
    {
     return true;
    }
    else
     return false;
   }
   else
    return false;
  }
  else
   return false;
}
else
  return true;
}

bool BiTree::PostOrderTraverse(BTNodePtr T,bool visit(TElemType e))
{
if (T)
{
  if (PostOrderTraverse(T->_lchild,visit))
  {
   if (PostOrderTraverse(T->_rchild,visit))
   {
    if (visit(T->_data))
    {
     return true;
    }
    else
     return false;
   }
   else
    return false;
  }
  else
   return false;
}
return true;
}

BTNodePtr BiTree::GetRoot()
{
return _root;
}

bool BiTree::TreeEmpty()
{
return _root!=NULL;
}

int BiTree::TreeDepth()
{
if (depth == 0&&n == 0)
{
  return depth;
}
else if (depth == 0 && n > 0)
{
  if (ExTreeDepth(_root->_lchild,0))
  {
   return depth;
  }
}
else
  return depth;
return -1;
}

bool BiTree::ExTreeDepth(BTNodePtr T,int dep)
{
if (T)
{
  dep++;
  if (T->_lchild == NULL &&T->_rchild ==NULL)
  {
   if (depth<dep)
   {
    depth=dep;
   }
  }
  if (ExTreeDepth(T->_lchild,dep))
  {
   if (ExTreeDepth(T->_rchild,dep))
   {
    return true;
   }
   else
    return false;
  }
  else
   return false;
}
else
  return true;
}

bool BiTree::ChangePtr()
{
if (PreChange(_root->_lchild))
{
return true;
}
else
return false;
}

bool BiTree::PreChange(BTNodePtr T)
{
if (T)
{
  if (PreChange(T->_lchild))
  {
   BTNodePtr pTemp=T->_rchild;
   T->_rchild=T->_lchild;
   T->_lchild=pTemp;
   if (PreChange(T->_lchild))
   {
    return true;
   }
   else
    return false;
  }
  else
   return false;
}
else
  return true;
}

int main()
{
BiTree temp;
temp.CreateBiTree();
int depth=temp.TreeDepth();
cout<<depth<<endl;
temp.VisitTraverse(Put);
cout<<endl;
temp.ChangePtr();
temp.VisitTraverse(Put);
cout<<endl;
return true;
}

//初步测试功能正确，未发现异常，待进一步调试~！