BTREE二叉树模板类C++

最新推荐文章于 2023-12-04 21:41:07 发布

姚军权

最新推荐文章于 2023-12-04 21:41:07 发布

阅读量1.7k

点赞数

分类专栏： 2.1结构与算法文章标签： null class insert delete file

本文链接：https://blog.csdn.net/chinayaosir/article/details/2969927

版权

2.1结构与算法专栏收录该内容

62 篇文章 2 订阅

订阅专栏

/*@file test.cpp*/
/*二叉树测试程序*/
#include <iostream>
#include "BinaryTree.h"
using namespace std;
int main(){
     int arr[12] = { 25, 32, 8, 4, 7, 34, 63, 44, 35, 84,65,99};
     BinaryTree<int> BTree(arr, 12);
cout <<"顺序输出**************************/n";
BTree.levelOrderTraverse();
     cout <<"/n/n前序遍历***************************/n";
     BTree.preOrderTraverse();
     cout <<"/n/n中序遍历***************************/n";
     BTree.inOrderTraverse();
     cout <<"/n/n后序遍历***************************/n";
     BTree.postOrderTraverse();
     cout <<"/n" <<endl;
     return 0;
}

/************************************************************/

运行结果

顺序输出**************************
25 32 8 4 7 34 63 44 35 84 65 99

前序遍历***************************
25 32 4 44 35 7 84 65 8 34 99 63

中序遍历***************************
44 4 35 32 84 7 65 25 99 34 8 63

后序遍历***************************
44 35 4 84 65 7 32 99 34 63 8 25

/************************************************************/

/*@file BinaryTree.h*/
/*功能：二叉树模板类*/
#ifndef BINARYTREE_H
#define BINARYTREE_H
const int MAX_NODES_SIZE = 100;
#include <queue>
using namespace std;
template <typename Type> class BinaryTree;

/*BinTreeNode二叉树结点类*/
template <typename Type>
class BinTreeNode
{
friend class BinaryTree<Type>;
    public:
         BinTreeNode() : left(NULL), right(NULL) { }
         BinTreeNode(Type val, BinTreeNode<Type> *L = NULL, BinTreeNode<Type> *R = NULL) : data(val), left(L), right(R) {}

         Type getData() const { return data;    }
         BinTreeNode<Type> * getLeftChild() const { return left; }
         BinTreeNode<Type> * getRightChild() const { return right; }
         void setData(const Type &val) { data = val;    }
         void setLeftChild(BinTreeNode<Type> * L) { left = L;    }
         void setRightChild(BinTreeNode<Type> * R) { right = R; }
         void visit(){ cout << getData() <<" ";}//访问的具体操作
     private:
         BinTreeNode<Type> *left, *right;
         Type data;
};

/*BinaryTree二叉树类*/
template <typename Type>
class BinaryTree
{
     public:
         BinaryTree() : root(NULL) {}
         BinaryTree(Type arr[], int size);//构造完全二叉树
         virtual ~BinaryTree() { destroy(root); }
         virtual int isEmpty() { return root == NULL ? 1 : 0; }

         //virtual BinTreeNode<Type> *parent(BinTreeNode<Type> *current);
         virtual BinTreeNode<Type> *leftChild(BinTreeNode<Type> *current) {
    return root != NULL ? current->getLeftChild() : NULL;
   }
         virtual BinTreeNode<Type> *rightChild(BinTreeNode<Type> *current) {
    return root != NULL ? current->getRightChild() : NULL;
   }
         const BinTreeNode<Type> *getRoot() const { return root;    }
         //virtual int insert(const Type &val);
         //virtual int find(const Type &val) const;
         void preOrderTraverse() { preOrderTraverse(root); }
         void inOrderTraverse() { inOrderTraverse(root); }
         void postOrderTraverse() { postOrderTraverse(root); }
         void levelOrderTraverse();
         void preOrderTraverse(BinTreeNode<Type> *current);
         void inOrderTraverse(BinTreeNode<Type> *current);
         void postOrderTraverse(BinTreeNode<Type> *current);
     private:
         BinTreeNode<Type> *root;
         void destroy(BinTreeNode<Type> *current);

};

template <typename Type>
BinaryTree<Type>::BinaryTree(Type arr[], int size){
     BinTreeNode<Type> *ptr[MAX_NODES_SIZE];
     for(int i = size; i >= 1; i--){
         ptr[i] = new BinTreeNode<Type>(arr[i - 1]);
         if(2*i <= size)     ptr[i]->left = ptr[2*i];
         if(2*i + 1 <= size) ptr[i]->right = ptr[2*i+1];
     }
     root = ptr[1];
}

template <typename Type>
void BinaryTree<Type>::destroy(BinTreeNode<Type> *current) {
     if(current->left == NULL && current->right == NULL)     {
         delete current;
         return;
     }
     if(current->left != NULL)         destroy(current->left);
     if(current->right != NULL)        destroy(current->right);
}

template <typename Type>
void BinaryTree<Type>::preOrderTraverse(BinTreeNode<Type> *current){
     if(current != NULL){
         current->visit();
         preOrderTraverse(current->left);
         preOrderTraverse(current->right);
    }

}

template <typename Type>
void BinaryTree<Type>::inOrderTraverse(BinTreeNode<Type> *current){
     if(current != NULL){
         inOrderTraverse(current->left);
         current->visit();
         inOrderTraverse(current->right);
     }
}

template <typename Type>
void BinaryTree<Type>::postOrderTraverse(BinTreeNode<Type> *current){
     if(current != NULL)
     {
         postOrderTraverse(current->left);
         postOrderTraverse(current->right);
         current->visit();
     }
}

template <typename Type>
void BinaryTree<Type>::levelOrderTraverse(){
     queue<BinTreeNode<Type> *> qu;
     qu.push(root);
     BinTreeNode<Type> *current;

     while(!qu.empty())
     {
         current = qu.front();

         if(current->left != NULL)
            qu.push(current->left);
         if(current->right != NULL)
             qu.push(current->right);

         current->visit();
         qu.pop();
     }
}
#endif