Binary Tree(二叉树)的二叉链表实现

BinaryTree.h

  1 #ifndef BINARYTREE_H
  2 #define BINARYTREE_H
  3 
  4 #include <queue>
  5 using namespace std;
  6 
  7 const int MAX_NODES_SIZE = 100;
  8 
  9 template <typename Type> class BinaryTree;
 10 
 11 template <typename Type> class BinTreeNode
 12 {
 13     friend class BinaryTree<Type>;
 14     public:
 15         BinTreeNode() : left(NULL), right(NULL) { }
 16         BinTreeNode(Type val, BinTreeNode<Type> *L = NULL, BinTreeNode<Type> *R = NULL) : data(val), left(L), right(R) {}
 17 
 18         Type getData() const { return data;    }
 19         BinTreeNode<Type> * getLeftChild() const { return left; }
 20         BinTreeNode<Type> * getRightChild() const { return right; }
 21         void setData(const Type &val) { data = val;    }
 22         void setLeftChild(BinTreeNode<Type> * L) { left = L;    }
 23         void setRightChild(BinTreeNode<Type> * R) { right = R; }
 24         void visit(){ cout << getData() << endl;}//访问的具体操作
 25 
 26     private:
 27         BinTreeNode<Type> *left, *right;
 28         Type data;
 29 };
 30 
 31 
 32 template <typename Type> class BinaryTree
 33 {
 34     public:
 35         BinaryTree() : root(NULL) {}
 36         BinaryTree(Type arr[], int size);//构造完全二叉树
 37         virtual ~BinaryTree() { destroy(root); }
 38         virtual int isEmpty() { return root == NULL ? 1 : 0; }
 39 
 40         //virtual BinTreeNode<Type> *parent(BinTreeNode<Type> *current);
 41         virtual BinTreeNode<Type> *leftChild(BinTreeNode<Type> *current) { return root != NULL ? current->getLeftChild() : NULL; }
 42         virtual BinTreeNode<Type> *rightChild(BinTreeNode<Type> *current) { return root != NULL ? current->getRightChild() : NULL; }
 43         const BinTreeNode<Type> *getRoot() const { return root;    }
 44         //virtual int insert(const Type &val);
 45         //virtual int find(const Type &val) const;
 46         void preOrderTraverse() { preOrderTraverse(root); }
 47         void inOrderTraverse() { inOrderTraverse(root); }
 48         void postOrderTraverse() { postOrderTraverse(root); }
 49         void levelOrderTraverse();
 50         void preOrderTraverse(BinTreeNode<Type> *current);
 51         void inOrderTraverse(BinTreeNode<Type> *current);
 52         void postOrderTraverse(BinTreeNode<Type> *current);
 53 
 54     private:
 55         BinTreeNode<Type> *root;
 56 
 57         void destroy(BinTreeNode<Type> *current);
 58         
 59 };
 60 
 61 template <typename Type>
 62 BinaryTree<Type>::BinaryTree(Type arr[], int size)
 63 {
 64     BinTreeNode<Type> *ptr[MAX_NODES_SIZE];
 65     
 66     for(int i = size; i >= 1; i--)
 67     {
 68         ptr[i] = new BinTreeNode<Type>(arr[i - 1]);
 69 
 70         if(2*i <= size)
 71             ptr[i]->left = ptr[2*i];
 72 
 73         if(2*i + 1 <= size)
 74             ptr[i]->right = ptr[2*i+1];
 75     }
 76 
 77     root = ptr[1];    
 78 }
 79 
 80 template <typename Type>
 81 void BinaryTree<Type>::destroy(BinTreeNode<Type> *current) 
 82 {
 83     if(current->left == NULL && current->right == NULL)
 84     {
 85         delete current;
 86         return;
 87     }
 88 
 89     if(current->left != NULL)
 90         destroy(current->left);
 91     if(current->right != NULL)
 92         destroy(current->right);
 93 }
 94 
 95 template <typename Type>
 96 void BinaryTree<Type>::preOrderTraverse(BinTreeNode<Type> *current)
 97 {
 98     if(current != NULL)
 99     {
100         current->visit();
101         preOrderTraverse(current->left);
102         preOrderTraverse(current->right);
103     }
104     
105 }
106 
107 template <typename Type>
108 void BinaryTree<Type>::inOrderTraverse(BinTreeNode<Type> *current)
109 {
110     if(current != NULL)
111     {
112         inOrderTraverse(current->left);
113         current->visit();
114         inOrderTraverse(current->right);
115     }
116 }
117 
118 template <typename Type>
119 void BinaryTree<Type>::postOrderTraverse(BinTreeNode<Type> *current)
120 {
121     if(current != NULL)
122     {
123         postOrderTraverse(current->left);
124         postOrderTraverse(current->right);
125         current->visit();
126     }
127 }
128 
129 template <typename Type>
130 void BinaryTree<Type>::levelOrderTraverse()
131 {
132     queue<BinTreeNode<Type> *> qu;
133     qu.push(root);
134     BinTreeNode<Type> *current;
135 
136     while(!qu.empty())
137     {    
138         current = qu.front();
139 
140         if(current->left != NULL)
141             qu.push(current->left);
142         if(current->right != NULL)
143             qu.push(current->right);
144 
145         current->visit();
146         qu.pop();
147     }
148     
149 }
150 
151 #endif

main.cpp

 1 #include <iostream>
 2 #include "BinaryTree.h"
 3 using namespace std;
 4 
 5 int main()
 6 {
 7     int arr[10] = { 25, 32, 8, 4, 7, 34, 63, 44, 35, 84};
 8     
 9     BinaryTree<int> BTree(arr, 10);
10 
11     BTree.preOrderTraverse();
12     cout << "========================" << endl;
13     BTree.inOrderTraverse();
14     cout << "========================" << endl;
15     BTree.postOrderTraverse();
16     cout << "========================" << endl;
17     BTree.levelOrderTraverse();
18 
19     //cout << BTree.getRoot()->getLeftChild()->getRightChild()->getLeftChild()->getData() << endl;
20 
21     return 0;
22 
23 }