二叉树的完整操作

#include <iostream>
using namespace std;
#include <queue>
#include <stack>
#include <list>

template<class T>
struct BinaryTreeNode
{
BinaryTreeNode(const T& data)
: _data(data)
, _pLeft(NULL)
, _pRight(NULL)
{}

T _data;
BinaryTreeNode<T>* _pLeft;    // 左孩子
BinaryTreeNode<T>* _pRight;   // 右孩子
};

template<class T>
class BinaryTree
{
typedef BinaryTreeNode<T> Node;
public:
BinaryTree()
: _pRoot(NULL)
{}

//构造二叉树
BinaryTree(const T array[], size_t size, const T& invalid)
{
// 创建树
size_t index = 0;
_CreateTree(_pRoot, array, size, index, invalid);
}

//拷贝二叉树
BinaryTree(const BinaryTree<T>& t)
{
_pRoot = _CopyBinaryTree(t._pRoot);
}

//二叉树的赋值函数
BinaryTree<T>& operator=(const BinaryTree<T>& t)
{
if(this != NULL)
{
_DestroyTree(_pRoot);
_pRoot = _CopyBinaryTree(t._pRoot);

return *this;
}

}

// 递归前序遍历：访问根结点-->左子树-->右子树
void PreOrder()
{
cout<<"递归前序遍历：";
_PreOrder(_pRoot);
cout<<endl<<endl;
}

// 非递归前序遍历：访问根结点-->左子树-->右子树
void PreOrder_Nor()
{
cout<<"非递归前序遍历：";
if(_pRoot == NULL)//空树
return;

stack<Node*> s;
s.push(_pRoot); //根节点入栈

while(!s.empty())
{
Node* pCur = s.top(); //取当前节点
cout<<pCur->_data<<" "; //访问当前节点
s.pop(); //出栈

if(pCur->_pRight)
s.push(pCur->_pRight); //右子树先入栈

if(pCur->_pLeft)
s.push(pCur->_pLeft); //左子树再入栈
}

cout<<endl<<endl;
}

// 递归中序遍历：访问左子树-->根结点-->右子树
void InOrder()
{
cout<<"中序遍历：";
_InOrder(_pRoot);
cout<<endl<<endl;
}

// 非递归中序遍历：访问左子树-->根结点-->右子树
void InOrder_Nor()
{
cout<<"非递归中序遍历：";
if(_pRoot == NULL)
return;  //空树

Node* pCur = _pRoot;
stack<Node*> s;

while(!s.empty() || pCur)
{
//找最左边节点，并保存该路径上的所有节点
while(pCur)
{
s.push(pCur);
pCur = pCur->_pLeft;
}

pCur = s.top(); //取栈顶
cout<<pCur->_data<<" "; //访问
s.pop(); //出栈

pCur = pCur->_pRight;
}

cout<<endl<<endl;
}

// 后序遍历：访问左子树-->右子树-->根节点
void PostOrder()
{
cout<<"后序遍历：";
_PostOrder(_pRoot);
cout<<endl<<endl;
}

// 后续遍历的非递归版本：访问左子树-->右子树-->根节点
void PostOrder_Nor()
{
cout<<"非递归中序遍历：";
if(_pRoot == NULL)
return;

Node* pCur = _pRoot;
Node* prev = NULL;
stack<Node*> s;

while(!s.empty() || pCur)
{
//找最左边节点并保存路径上所有节点
while(pCur)
{
s.push(pCur);
pCur = pCur->_pLeft;
}

pCur = s.top(); //取栈顶
if(pCur->_pRight == NULL || prev == pCur->_pRight)
{
cout<<pCur->_data<<" "; //访问
prev = pCur; //标记
s.pop();
pCur = NULL;
}

else
{
pCur = pCur->_pRight;
}
}

cout<<endl<<endl;
}

// 层序遍历
void LevelOrder()
{
cout<<"层序遍历：";
_LevelOrder(_pRoot);
cout<<endl<<endl;
}

~BinaryTree()
{
_DestroyTree(_pRoot);
_pRoot = NULL;
}

//找到节点的双亲节点
Node* GetParent(Node* x)
{
return _GetParent(_pRoot,x);
}

//找到结点的左孩子
Node* GetLeftChild(Node* pCur)
{
return pCur->_pLeft;
}

//找到结点的右孩子
Node* GetRightChild(Node* pCur)
{
return pCur->_pRight;
}

//在二叉树中查找某个节点
Node* Find(const T& value)
{
return _Find(_pRoot, value);
}

//二叉树的高度
size_t Height()
{
return _Height(_pRoot);
}

//叶子结点的个数
size_t GetLeefNode()
{
return _GetLeefNode(_pRoot);
}

//第K层有几个节点
size_t GetKLevelNode(size_t k)
{
return _GetKLevelNode(_pRoot, k);
}

// 求二叉树的镜像：非递归
void GetBinaryMirror_Nor()
{
queue<Node *> q;
Node *pointer = _pRoot;//当前处理的节点为根节点
while (pointer)
{
swap(pointer->_pLeft, pointer->_pRight);//交换当前处理节点的孩子
if (pointer->_pLeft)//左孩子不为空
q.push(pointer->_pLeft);

if (pointer->_pRight)//右孩子不为空
q.push(pointer->_pRight);

if (!q.empty())
{
pointer = q.front();
q.pop();
}
else
{
break;
}
}
}

// 求二叉树的镜像：递归版本
void GetBinaryMirror()
{
return _GetBinaryMirror(_pRoot);
}

// 利用层序遍历来处理--> 关键：找第一个度不为2的结点-->后续结点
// 如果有孩子则不是完全二叉树
// 否则：是
bool IsCompleteBinaryTree()
{
if(_pRoot == NULL)
return true;
Node* pCur = NULL;
queue<Node*> q;
q.push(_pRoot);

int flag = false;

while(!q.empty())
{
pCur = q.front();
q.pop();

if(flag == true)
{
if(pCur->_pLeft != NULL || pCur->_pRight != NULL)
return false;
return true;
}
else
{
if(pCur->_pLeft != NULL && pCur->_pRight != NULL)
{
q.push(pCur->_pLeft);
q.push(pCur->_pRight);
}
else if(pCur->_pRight!= NULL)
{
return false;
}
else if(pCur->_pLeft != NULL)
{
q.push(pCur->_pLeft);
flag = true;
}
else
{
flag = true;
}
}
}
return false;
}

// 求二叉树中两个节点的最近公共祖先节点
Node* GetLastCommonParent(Node* Node1, Node* Node2)
{
return _GetLastCommonParent(_pRoot, Node1, Node2);
}

// 由前序遍历序列和中序遍历序列重建二叉树
Node* RebuildBinaryTree(char* PreOrder, char* InOrder, int length)
{
//int len1 = sizeof(PreOrder/PreOrder[0]);
//int len2 = sizeof(InOrder/InOrder[0]);

//if(len1 != len2)
//return NULL;

if(PreOrder == NULL || InOrder == NULL || length < 0)
return NULL;

// 前序遍历的第一个数据就是根节点数据
Node* _pRoot = new BinaryTreeNode<char>(PreOrder[0]);

// 查找根节点在中序遍历中的位置,中序遍历中,根节点左边为左子树,右边为右子树
int rootPositionInOrder = -1;
for(int i = 0; i < length; i++)
{
if(InOrder[i] == _pRoot->_data)
{
rootPositionInOrder = i;
break;
}
}

// 重建左子树
int nodeNumLeft = rootPositionInOrder;
char* pPreOrderLeft = PreOrder + 1;
char* pInOrderLeft = InOrder + nodeNumLeft;
_pRoot->_pLeft = RebuildBinaryTree(pPreOrderLeft, pInOrderLeft, nodeNumLeft);

// 重建右子树
int nodeNumRight = length - nodeNumLeft - 1;
char* pPreOrderRight = PreOrder + 1 + nodeNumLeft;
char* pInOrderRight = InOrder + nodeNumLeft + 1;
_pRoot->_pRight = RebuildBinaryTree(pPreOrderRight, pInOrderRight, nodeNumRight);
return _pRoot;
}

private:
void _CreateTree(Node*& pRoot, const T array[],
size_t size, size_t& index, const T& invalid)
{
if(index < size && (array[index] != invalid))//两个顺序不可调换，否则会导致越界访问
{
//创建根节点
pRoot = new Node(array[index]);

//创建根结点左子树
_CreateTree(pRoot->_pLeft, array, size, ++index, invalid);

//创建根结点左子树
_CreateTree(pRoot->_pRight, array, size, ++index, invalid);
}
}

Node* _CopyBinaryTree(Node* pRoot)
{
if(pRoot)
{
Node* pNewNode = new Node(pRoot->_data);
pNewNode->_pLeft = _CopyBinaryTree(pRoot->_pLeft);
pNewNode->_pRight = _CopyBinaryTree(pRoot->_pRight);
return pNewNode;
}
return NULL;
}

void _DestroyTree(Node* &pRoot)
{
if(pRoot)
{
_DestroyTree(pRoot->_pLeft);
_DestroyTree(pRoot->_pRight);
delete pRoot;
pRoot = NULL;
}
}

void _PreOrder(Node* pRoot)
{
if(pRoot)
{
cout<<pRoot->_data<<" ";
_PreOrder(pRoot->_pLeft);
_PreOrder(pRoot->_pRight);
}
}

void _InOrder(Node* pRoot)
{
if(pRoot)
{
_InOrder(pRoot->_pLeft);
cout<<pRoot->_data<<" ";
_InOrder(pRoot->_pRight);
}

}

void _PostOrder(Node* pRoot)
{
if(pRoot)
{
_PostOrder(pRoot->_pLeft);
_PostOrder(pRoot->_pRight);
cout<<pRoot->_data<<" ";
}
}

void _LevelOrder(Node* pRoot)
{
if(pRoot == NULL)
return;
queue<Node*> q;
q.push(pRoot);
Node* pCur = NULL;

while(!q.empty())
{
pCur = q.front();
cout<<pCur->_data<<" ";
if(pCur->_pLeft)
q.push(pCur->_pLeft);
if(pCur->_pRight)
q.push(pCur->_pRight);
q.pop();
}
}

Node* _GetParent(Node* pRoot, Node* x)
{
if(pRoot == NULL || x ==  NULL || x == pRoot)
return NULL;

if(pRoot->_pLeft == x || pRoot->_pRight == x)
return pRoot;

Node* parent = NULL;
if(parent = _GetParent(pRoot->_pLeft, x))
return parent;

if(parent = _GetParent(pRoot->_pRight, x))
return parent;

return NULL;
}

Node* _Find(Node* pRoot, const T& value)
{
if(pRoot == NULL)  //空树
return NULL;

if(pRoot->_data == value)
return pRoot;

Node* pCur = NULL;//如果不用返回值接收需要再调用一次函数
if(pCur = _Find(pRoot->_pLeft, value))
return pCur;

if(pCur = _Find(pRoot->_pRight, value))
return pCur;
}

size_t _Height(Node* pRoot)
{
if(pRoot == NULL)  //空树
return 0;

if(pRoot->_pLeft == NULL || pRoot->_pRight == NULL)
return 1;   //只有一个根节点的树

size_t lefthHight = _Height(pRoot->_pLeft);
size_t rightHeight = _Height(pRoot->_pRight);

return (lefthHight>rightHeight) ? (lefthHight+1) : (rightHeight+1);
}

size_t _GetLeefNode(Node* pRoot)
{
if(pRoot == NULL) //空树
return 0;

if(pRoot->_pLeft == NULL && pRoot->_pRight == NULL)
return 1;  //只有一个根节点的树

return _GetLeefNode(pRoot->_pLeft) + _GetLeefNode(pRoot->_pRight);
}

size_t _GetKLevelNode(Node* pRoot, size_t k)
{
if(pRoot == NULL || k<1 || k>_Height(pRoot))
return 0;

if(k == 1)
return 1;

size_t left = _GetKLevelNode(pRoot->_pLeft, k-1);
size_t right = _GetKLevelNode(pRoot->_pRight, k-1);

return left + right;
}

void _GetBinaryMirror(Node* pRoot)
{
if(pRoot == NULL)
return ;

if(pRoot->_pLeft == NULL && pRoot->_pRight == NULL)
return ;

swap(pRoot->_pLeft, pRoot->_pRight);

if(pRoot->_pLeft)
_GetBinaryMirror(pRoot->_pLeft);

if(pRoot->_pRight)
_GetBinaryMirror(pRoot->_pRight);
}

bool GetNodePath(Node* pRoot, Node* pNode, list<Node*>& path)
{
if(pRoot == pNode)
{
path.push_back(pRoot);
return true;
}

if(pRoot == NULL)
return false;

path.push_back(pRoot);
bool found = false;

found = GetNodePath(pRoot->_pLeft, pNode, path);  //在左子树中寻找

if(!found)  //在左子树中没有找到，在右子树中寻找
found = GetNodePath(pRoot->_pRight, pNode, path);

if(!found)   //没有找到该节点
path.pop_back();
return found;
}

Node* _GetLastCommonParent(Node* pRoot, Node* Node1, Node* Node2)
{
if(pRoot == NULL || Node1 == NULL || Node2 == NULL)
return NULL;

list<Node*> l1;
bool Result1 = GetNodePath(pRoot, Node1, l1);

list<Node*> l2;
bool Result2 = GetNodePath(pRoot, Node2, l2);

if(!Result1 || !Result2)
return NULL;

Node * pLast = NULL;
list<Node*>::const_iterator iter1 = l1.begin();
list<Node*>::const_iterator iter2 = l2.begin();

while(iter1 != l1.end() && iter2 != l2.end())
{
if(*iter1 == *iter2)
pLast = *iter1;
else
break;
iter1++;
iter2++;
}
return pLast;
}

private:
BinaryTreeNode<T>* _pRoot;
};

void FunTest()
{
char array[] = "124##5##36##7##";
BinaryTree<char> tree(array, strlen(array), '#');
BinaryTree<char> t(tree);
BinaryTree<char> t1;
t1 = t;

BinaryTreeNode<char>* pCur = NULL;
pCur = t.GetParent(t.Find('1')); //找到节点的双亲节点
if(pCur)
cout<<"结点1的双亲结点为："<<pCur->_data<<endl;

pCur = t.GetParent(t.Find('2'));
if(pCur)
cout<<"结点2的双亲结点为："<<pCur->_data<<endl;

pCur = t.GetParent(t.Find('5'));
if(pCur)
cout<<"结点5的双亲结点为："<<pCur->_data<<endl;

pCur = t.GetLeftChild(t.Find('1')); //找到结点的左孩子
if(pCur)
cout<<"结点1的左孩子为："<<pCur->_data<<endl;

pCur = t.GetLeftChild(t.Find('3'));
if(pCur)
cout<<"结点2的左孩子为："<<pCur->_data<<endl;

pCur = t.GetLeftChild(t.Find('6'));
if(pCur)
cout<<"结点6的左孩子为："<<pCur->_data<<endl;

pCur = t.GetRightChild(t.Find('1')); //找到结点的右孩子
if(pCur)
cout<<"结点1的右孩子为："<<pCur->_data<<endl;

pCur = t.GetRightChild(t.Find('2'));
if(pCur)
cout<<"结点2的右孩子为："<<pCur->_data<<endl;

pCur = t.GetRightChild(t.Find('5'));
if(pCur)
cout<<"结点5的右孩子为："<<pCur->_data<<endl;

cout<<"二叉树的高度:"<<t.Height()<<endl;
cout<<"二叉树的叶子节点:"<<t.GetLeefNode()<<endl;
cout<<"二叉树第三层的节点数："<<t.GetKLevelNode(3)<<endl;
cout<<"二叉树第二层的节点数："<<t.GetKLevelNode(2)<<endl;
cout<<"二叉树第一层的节点数："<<t.GetKLevelNode(1)<<endl;
cout<<"二叉树第四层的节点数："<<t.GetKLevelNode(4)<<endl;

tree.PreOrder();
t.PreOrder_Nor();

tree.InOrder();
t.InOrder_Nor();

tree.PostOrder();
tree.PostOrder_Nor();

tree.LevelOrder();

tree.GetBinaryMirror_Nor();
tree.GetBinaryMirror();

cout<<"二叉树是不是完全二叉树："<<t.IsCompleteBinaryTree()<<endl;
pCur = tree.GetLastCommonParent(tree.Find('2'), tree.Find('6'));
if(pCur)
cout<<"结点2和5的公共祖先是"<<pCur->_data<<endl;

char str1[] = {'1', '2', '4', '5', '3', '6', '7'};
char str2[] = {'4', '2', '5', '1', '6', '3', '7'};
tree.RebuildBinaryTree(str1, str2, 7);
}

int main()
{
FunTest();
system("pause");

return 0;
}