三叉链表实现-二叉树

二叉树节点：

#ifndef BINARYTREENODE_H
#define BINARYTREENODE_H
template <class T> class binaryTreeNode
{
 T data;
 binaryTreeNode<T> * leftChild;
 binaryTreeNode<T> * rightChild;
 binaryTreeNode<T> * parent;
public:
 binaryTreeNode(): data(-1),leftChild(NULL),rightChild(NULL),parent(NULL){}
 binaryTreeNode(const T value):data(value),leftChild(NULL),rightChild(NULL),parent(NULL){}
 ~binaryTreeNode(){cout<<"destroy:"<<getData()<<endl;}
 T & getData()
 {
  return data;
 }
 binaryTreeNode<T> * getLeftChild()
 {
  return leftChild;
 }
 binaryTreeNode<T> * getRightChild()
 {
  return rightChild;
 }
 binaryTreeNode<T> * getParent()
 {
  return parent;
 }
 void setData(T value)
 {
  data=value;
 }
 void setLeftChild(binaryTreeNode<T> * newLeftChild)
 {
  leftChild=newLeftChild;
 }
 void setRightChild(binaryTreeNode<T> * newRightChild)
 {
  rightChild=newRightChild;
 }
/* bool isLeftChild()
 {
   return this==parent->getLeftChild()?true:false;
 }
 bool isRightChild()
 {
  return this==parent->getRightChild()?true:false;
 } */
 bool isRoot()
 {
  return this-> getParent()==NULL?true:false;
 }

 void setParent(binaryTreeNode<T> * newParent)
 {
 // if(isRightChild())
 // {
   //parent->setLeftChild(NULL);
   parent=newParent;
 //  parent->setRightChild(this);
 // }
 // else{
     //parent->setRightChild(NULL);
 //  parent=newParent;
 //  parent->setLeftChild(this);
 // }
  

 }

};
#endif

 

二叉树的实现：

#ifndef BINARYTREE_H
#define BINARYTREE_H
#include"binaryTreeNode.h"
#include<queue>
template <class T> class binaryTree
{
 
 binaryTreeNode<T> * root;
public:
 binaryTree(): root(NULL){}
 binaryTree(const T value)
 {
  root=new binaryTreeNode<T>(value);
 }
 virtual ~binaryTree();
  bool isEmpty() const //判断树是否为空
 {
  return root ==NULL ?true:false;
 }
 bool isLeftChild(binaryTreeNode<T> * p)//判断当前节点是否为左孩子
 {
  return p==(getParent(p))->getLeftChild()?true:false;
 }
 bool isRightChild(binaryTreeNode<T> * p)//判断当前节点是否为右孩子
 {
  return p==(getParent(p))->getRightChild()?true:false;
 }
 binaryTreeNode<T> * getRoot()//返回根节点
 {
  return root;
 }
 binaryTreeNode<T> *leftChild(binaryTreeNode<T> *p)//返回当前节点的左孩子
 {
  return p==NULL?NULL:p->getLeftChild();
 }
 binaryTreeNode<T> *rightChild(binaryTreeNode<T> *p)//返回当前节点的右孩子
 {
  return p==NULL?NULL:p->getRightChild();
 }
 binaryTreeNode<T> *leftSibling(binaryTreeNode<T> *p)//返回当前节点的左兄弟
 {
  binaryTreeNode<T> * parent=p->getParent();
  return parent->getLeftChild();
 }

 binaryTreeNode<T> *rightSibling(binaryTreeNode<T> *p)//返回当前节点的右兄弟
 {
  binaryTreeNode<T> * parent=p->getParent();
     return p->getRightChild();
 }
 T retrieve(binaryTreeNode<T> *p) const //返回当前节点的数据
 {
  return p->getData();
 }
 void assign(binaryTreeNode<T> * p, const T value)//对当前节点数据进行重置
 {
  p->setData(value);
 } 
 void insertLeftChild(binaryTreeNode<T> * p, const T value);//在当前节点插入一个左孩子
 void insertLeftChild(binaryTreeNode<T> * p, binaryTreeNode<T> * leftChild);//重载在当前节点插如一个左孩子，该插入可以连接两棵树
 void insertRightChild(binaryTreeNode<T> * p, const T value);//在当前节点插入一个右孩子
 void insertRightChild(binaryTreeNode<T> * p, binaryTreeNode<T> * rightChild);//重载在当前节点插如一个右孩子，该插入可以连接两棵树
 void deleteRightChild(binaryTreeNode<T> *p)//删除右孩子
 {
  destroy(p->getRightChild());
 }
 void deleteLeftChild(binaryTreeNode<T> *p)//删除左孩子
 {
  destroy(p->getLeftChild());
 }
 virtual void preOrderTraverse(binaryTreeNode<T> *root) const ;//前序遍历
 virtual void inOrderTraverse(binaryTreeNode<T> *root) const ;//中序遍历
 virtual void postOrderTraverse(binaryTreeNode<T> *root) const ;//后序遍历
    virtual void leverOrderTraverse(binaryTreeNode<T> *root) const ;//层次遍历
protected:
 void destroy(binaryTreeNode<T> *);//删除以当前节点为根的树
};
template <class T> binaryTree<T>:: ~binaryTree()
{
 destroy(root);
 root=NULL;
}
/*template <class T> void binaryTree<T>::destroy(binaryTreeNode<T> *p) //用递归实现销毁树
{
 if(p!=NULL)
 {
  destroy(p->getLeftChild());
  destroy(p->getRightChild());
        delete p;
 }
}*/
template <class T> void binaryTree<T>::destroy(binaryTreeNode<T> *root)//用非递归实现销毁树
{

  queue< binaryTreeNode<T> * > q;
  if(NULL!=root)
   q.push(root);
 
  while(!q.empty())
  {
   root=q.front();
   q.pop();
   cout<<root->getData();
   if(root->getLeftChild())
    q.push(root->getLeftChild());
   if(root->getRightChild())
    q.push(root->getRightChild());
   delete root;
  }
       
 
}
template <class T> void binaryTree<T>:: insertLeftChild(binaryTreeNode<T> * p, const T value)
{
 binaryTreeNode<T> * add=new binaryTreeNode<T>(value);
 add->setLeftChild(p->getLeftChild());
 p->setLeftChild(add);
 add->setParent(p);

}
template <class T> void binaryTree<T>::  insertLeftChild(binaryTreeNode<T> * p, binaryTreeNode<T> * leftChild)
{
 p->setLeftChild(leftChild);
 leftChild->setParent(p);

}
template <class T> void binaryTree<T>:: insertRightChild(binaryTreeNode<T> * p, const T value)
{
 binaryTreeNode<T> * add=new binaryTreeNode<T>(value);
 add->setRightChild(p->getRightChild());
 p->setRightChild(add);
 add->setParent(p);

}
template <class T> void binaryTree<T>::  insertRightChild(binaryTreeNode<T> * p, binaryTreeNode<T> * rightChild)
{
 p->setRightChild(rightChild);
 rightChild->setParent(p);

}
template <class T> void binaryTree<T>::preOrderTraverse(binaryTreeNode<T> *root) const// 用递归实现
{
 if(root!=NULL)
 {
  cout<<root->getData();
  preOrderTraverse(root->getLeftChild());
  preOrderTraverse(root->getRightChild());

 }
}
template <class T> void binaryTree<T>::inOrderTraverse(binaryTreeNode<T> *root) const
{
 if(root!=NULL)
 {
  
  inOrderTraverse(root->getLeftChild());
  cout<<root->getData();
  inOrderTraverse(root->getRightChild());
 }
}
template <class T> void binaryTree<T>:: postOrderTraverse(binaryTreeNode<T> *root) const
{
 if(root!=NULL)
 {
  
  postOrderTraverse(root->getLeftChild());
  postOrderTraverse(root->getRightChild());
  cout<<root->getData();
 }
}
 template <class T> void binaryTree<T>:: leverOrderTraverse(binaryTreeNode<T> *root) const
{
  queue< binaryTreeNode<T> * > q;
  if(NULL!=root)
   q.push(root);
 
  while(!q.empty())
  {
   root=q.front();
   q.pop();
   cout<<root->getData();
   if(root->getLeftChild())
    q.push(root->getLeftChild());
   if(root->getRightChild())
    q.push(root->getRightChild());
  }
}
#endif

测试：

#include<iostream>
#include"binaryTreeNode.h"
#include"binaryTree.h"
using namespace std;
void main()
{
 binaryTreeNode<int> *t2=new binaryTreeNode<int>(5),*t1,*t3;
 //t4=&t2;
 cout<<t2->getData()<<endl;
 cout<<t2->getLeftChild()<<endl;
 cout<<t2->getRightChild()<<endl;
 cout<<t2->getParent()<<endl;
     binaryTree<int> tree1(1);
 t1=tree1.getRoot();
 tree1.insertLeftChild(t1,2);
 tree1.insertRightChild(t1,3);

 tree1.insertLeftChild(t2,t1);

 tree1.preOrderTraverse(t2);
// tree2.leverOrderTraverse(t3);
 //tree.deleteLeftChild(t1);

}