基本代码:
#pragma once
#include <iostream>
#include <queue>
#include <assert.h>
#include <stack>
using namespace std;
template <class T>
struct BinaryTreeNode
{
T _data;
BinaryTreeNode<T>* _left;
BinaryTreeNode<T>* _right;
BinaryTreeNode(const T& x)
: _data(x)
,_left(NULL)
, _right(NULL)
{}
};
template <class T>
class BinaryTree
{
typedef BinaryTreeNode<T> Node;
public:
BinaryTree()
:_root(NULL)
{}
BinaryTree(T* a, size_t n, const T& invalid)
{
size_t index = 0;
_root = CreateTree(a, n, invalid, index);
}
Node* CreateTree(T* a, size_t n, const T& invalid, size_t& index)
{
Node* root = NULL;
if (index < n && a[index] != invalid )
{
root = new Node(a[index]);
root->_left = CreateTree(a, n, invalid, ++index);
root->_right = CreateTree(a, n, invalid, ++index);
}
return root;
}
~BinaryTree()
{
Destroy(_root);
}
void Destroy(Node* root) //后序删除
{
if (root == NULL)
{
return;
}
Destroy(root->_left);
Destroy(root->_right);
delete root;
}
//t2(t1)
BinaryTree(const BinaryTree<T>& t) //拷贝构造
{
_root = _Copy(t._root);
}
Node* _Copy(Node* root)
{
if (root == NULL)
{
return NULL;
}
Node* newRoot = new Node(root->_data);
newRoot->_left = _Copy(root->_left);
newRoot->_right = _Copy(root->_right);
return newRoot;
}
//传统写法
BinaryTree<T>& operator=(const BinaryTree<T>& t) //赋值运算符的重载
{
if (this != &t)
{
Destroy(_root);
_root = _Copy(t._root);
}
return *this;
}
//现代写法
/*BinaryTree<T>& operator=(BinaryTree<T> t)//调用拷贝构造函数拷贝t
{
swap(_root, t._root);
return *this;
}*/
void PrevOrder()
{
return _PrevOrder(_root);
}
void InOrder()
{
return _InOrder(_root);
}
void PostOrder()
{
return _PostOrder(_root);
}
void LevelOrder()
{
return _LevelOrder();
}
void PrevOrderNonR() //非递归<利用栈>
{
stack<Node*> s;
Node* cur = _root;
while (cur || !s.empty()) //入栈。栈里存的是节点的地址
{
while (cur)
{
cout << cur->_data << " ";
s.push(cur);
cur = cur->_left;
}
Node* Front = s.top();
s.pop();
//子问题的方式访问右树
cur = Front->_right;
}
}
void InOrderNonR()
{
stack<Node*> s;
Node* cur = _root;
while (cur || !s.empty())
{
while (cur)
{
s.push(cur);
cur = cur->_left;
}
Node* Front = s.top();
cout << Front->_data << " ";
s.pop();
//访问右树,子问题
cur = Front->_right;
}
}
void PostOrderNonR()
{
Node* cur = _root;
stack<Node*> s;
Node* prev = NULL;
while (cur || !s.empty())
{
while (cur)
{
s.push(cur);
cur = cur->_left;
}
Node* Front = s.top();
if (Front->_right == NULL || Front->_right== prev)
{
cout << Front->_data << " ";
prev = Front;
s.pop();
}
else
{
//子问题
cur = Front->_right;
}
}
cout << endl;
}
size_t GetKLevel(size_t k) //K层叶子节点数
{
assert(k>0);
return _GetKLevel(_root,k);
}
size_t Depth()
{
return _Depth(_root);
}
size_t Size()
{
return _Size(_root);
}
size_t LeafSize() //求叶子节点数
{
return _LeafSize(_root);
}
Node* Find(const T& x)
{
return _Find(_root, x);
}
protected:
void _PrevOrder(Node* root) //前序
{
if (root == NULL)
{
return ;
}
cout << root->_data << " ";
_PrevOrder(root->_left);
_PrevOrder(root->_right);
}
void _InOrder(Node* root) //中序
{
if (root == NULL)
{
return;
}
_InOrder(root->_left);
cout << root->_data << " ";
_InOrder(root->_right);
}
void _PostOrder(Node* root) //后序
{
if (root == NULL)
{
return;
}
_PostOrder(root->_left);
_PostOrder(root->_right);
cout << root->_data << " ";
}
//宽度
//大数
void _LevelOrder() // 层序//思想:用队列的先进先出//在写一遍
{
queue<Node*> q;
if (_root)
{
q.push(_root);
}
while (!q.empty())
{
Node* front = q.front();
cout << front->_data << " ";
if (front->_left)
{
q.push(front->_left);
}
if (front->_right)
{
q.push(front->_right);
}
q.pop();
}
cout << endl;
}
bool IsCompleteTree() //判断是否为完全树 // 层序//思想:用队列的先进先出//在写一遍
{
queue<Node*> q;
if (_root)
{
q.push(_root);
}
bool tag = true;
while (!q.empty())
{
Node* front = q.front();
q.pop();
if (front->_left)
{
if (tag == false)
{
return false;
}
q.push(front->_left);
}
else
{
tag = false;
}
if (front->_right)
{
if (tag == false)
{
return false;
}
q.push(front->_right);
}
else
{
tag = false;
}
}
}
size_t _GetKLevel(Node* root, size_t k) //第K层的节点数
{
if (root == NULL) //空树
{
return 0;
}
if (k == 1)
{
return 1;
}
return _GetKLevel(root->_left, k - 1) + _GetKLevel(root->_right, k - 1);
}
size_t _Depth(Node* root) //求二叉树的深度
{
if (root == NULL)
{
return 0;
}
if (root->_left == NULL && root->_right == NULL)
{
return 1;
}
size_t left = _Depth(root->_left);
size_t right = _Depth(root->_right);
return (left > right) ? left + 1 : right + 1;
}
size_t _Size(Node* root) //求总节点个数
{
if (root == NULL)
{
return 0;
}
return _Size(root->_left) + _Size(_root->_right) + 1;
}
size_t _LeafSize(Node* root) //求叶子节点数
{
if (root == NULL) //空树
{
return 0;
}
else //不是空树
{
if (root->_left == NULL && root->_right == NULL)
{
return 1;
}
return _LeafSize(root->_left) + _LeafSize(root->_right);
}
}
Node* _Find(Node* root, const T& x)
{
if (root == NULL)
{
return NULL;
}
if (root->_data == x)
{
return root;
}
Node* ret = _Find(root->_left, x);//要接受返回值
if (ret) //ret不等于空说明找到了
{
return ret;
}
else
{
return _Find(root->_right,x);
}
}
bool IsInTree(Node* root, const T& x) //思考
{
if (root == NULL)
{
return false;
}
if (root->_data == x)
{
return true;
}
/*if (IsInTree(root->_left,x))
{
return true;
}
return IsInTree(root->_right,x); */
//或者
return IsInTree(root->_left, x) || IsInTree(root->_right, x);
}
Node* _root;
};