1、二叉树的构造
#include <iostream>
#include <cassert>
#include <queue>
#include <stack>
using namespace std;
template <class T>
struct TreeNode
{
TreeNode(const T& value = T())
:_value(value)
,_lchild(0)
,_rchild(0)
{}
T _value;//节点的值
TreeNode<T>* _lchild;//左孩子
TreeNode<T>* _rchild;//右孩子
};
template <class T>
class BinaryTree
{
public:
typedef TreeNode<T> Node;
BinaryTree()//无参构造函数
:_root(NULL)
{}
BinaryTree(const T* a,size_t size,const T& invalid)//构造函数
{
assert(a);
size_t index = 0;
_root = CreatTree(a,size,invalid,index);
}
BinaryTree(const BinaryTree<T>& b)//拷贝构造
{
_root = Copy(b._root);
}
//现代写法的赋值运算符重载1
BinaryTree& operator=(const BinaryTree<T>& b)
{
if (this != &b)
{
Node* tmp = Copy(b._root);
Destroy(_root) ;
_root = tmp;
//swap(_root,tmp);
}
return *this;
}
////现代写法的赋值运算符重载2
//BinaryTree& operator=(BinaryTree<T> b)
//{
// swap(b._root,_root);
// return *this;
//}
~BinaryTree()//析构
{
if (NULL != _root)
{
Destroy(_root);
_root = NULL;
}
}
protected:
//按照先序遍历递归建树
Node* CreatTree(const T* a,size_t size,const T& invalid,size_t& index)//注意index的传值方式
{
assert(a);
Node* root = NULL;
if (a[index] != invalid && index < size)//按先序遍历建树
{
root = new Node(a[index]);
root->_lchild = CreatTree(a,size,invalid,++index);
root->_rchild = CreatTree(a,size,invalid,++index);
}
return root;
}
//拷贝对象
Node* Copy(Node* root)
{
Node* tmp = NULL;
if(root)
{
tmp = new Node(root->_value);
tmp->_lchild = Copy(root->_lchild);
tmp->_rchild = Copy(root->_rchild);
}
return tmp;
}
//释放空间
void Destroy(Node*& root)
{
if(root)//用后序遍历方式释放空间
{
Destroy(root->_rchild);
Destroy(root->_lchild);
delete root;
root = NULL;
}
}
private:
Node* _root;//根节点
};2、遍历二叉树
二叉树的遍历方式一共分为四种：先序遍历、中序遍历、后序遍历和层序遍历，而前三种遍历又分为递归遍历和非递归遍历，层序遍历则是借助队列先进先出的特性来辅助完成。
【递归遍历二叉树】
void preorder(Node* root)//先序遍历打印树的各个节点
{
if (root)
{
cout<<root->_value<<" "; //访问当前节点的值
preorder(root->_lchild); //递归遍历左子树
preorder(root->_rchild); //递归遍历右子树
}
}
void inorder(Node* root)//中序遍历打印树的各个节点
{
if (root)
{
preorder(root->_lchild); //递归遍历左子树
cout<<root->_value<<" "; //访问当前节点的值
preorder(root->_rchild); //递归遍历右子树
}
}
void postorder(Node* root)//后序遍历打印树的各个节点
{
if (root)
{
preorder(root->_lchild); //递归遍历左子树
preorder(root->_rchild); //递归遍历右子树
cout<<root->_value<<" "; //访问当前节点的值
}
}
void levelorder(Node* root)//层序遍历打印树的各个节点
{
queue<Node*> q;
if (root)
{
q.push(root);//将根节点插进队列
}
while(!q.empty())
{
Node* front = q.front();
q.pop();
cout<<front->_value<<" ";
if (front->_lchild)
{
q.push(front->_lchild);
}
if (front->_rchild)
{
q.push(front->_rchild);
}
}
} 【非递归遍历二叉树】
提供给外部的接口：
public:
void PreOrder()//先序遍历打印树的各个节点
{
cout<<"先序遍历:";
preorderR(_root);
cout<<endl;
}
void InOrder()//中序遍历打印树的各个节点
{
cout<<"中序遍历:";
inorderR(_root);
cout<<endl;
}
void PostOrder()//后序遍历打印树的各个节点
{
cout<<"后序遍历:";
postorderR(_root);
cout<<endl;
}
void LevelOrder()//层序遍历打印树的各个节点
{
cout<<"层序遍历:";
levelorder(_root);
cout<<endl;
}算法实现：
void preorderR(Node* root)//先序遍历打印树的各个节点
{
Node* cur = root;
stack<Node*> s;
while (!s.empty() || cur)//只要当前节点和栈不同时为空，就说明树没遍历完
{
while(cur)//先序遍历，遇到树根节点直接访问数据并将其压栈
{
cout<<cur->_value<<" ";
s.push(cur);
cur = cur->_lchild;
}
Node* top = s.top();//取出栈顶元素，到此说明此节点以及其左子树已经访问过了
s.pop();
cur = top->_rchild;//以子问题的方式去访问右子树
}
cout<<endl;
}
void inorderR(Node* root)//中序遍历打印树的各个节点
{
Node* cur = root;
stack<Node*> s;
while(!s.empty() || cur)//只要当前节点和栈不同时为空，就说明树没遍历完
{
while(cur)//中序遍历，遇到树根节点直接将其压栈
{
s.push(cur);
cur = cur->_lchild;
}
Node* top = s.top();//取出栈顶元素，到此说明此节点的左子树已经访问过了
cout<<top->_value<<" ";//访问栈顶元素（即根节点）
s.pop();
cur = top->_rchild;//以子问题的方式去访问右子树
}
cout<<endl;
}
void postorderR(Node* root)//后序遍历打印树的各个节点
{
Node* cur = root;
Node* prev = NULL;//上一个访问过的数据
stack<Node*> s;
while(!s.empty() || cur)//只要当前节点和栈不同时为空，就说明树没遍历完
{
//后序遍历，遇到树根节点直接将其压栈
while(cur)
{
s.push(cur);
cur = cur->_lchild;
}
Node* top = s.top();//取栈顶元素，但不一定能访问
//当节点右子树为空或已经访问过时对其直接进行访问
if (top->_rchild==NULL || top->_rchild==prev)
{
cout<<top->_value<<" ";
prev = top;//将prev更新为已经访问的节点
s.pop();
}
else//以子问题的方式去访问右子树
{
cur = top->_rchild;
}
}
cout<<endl;
}
void levelorder(Node* root)//层序遍历打印树的各个节点
{
queue<Node*> q;
if (root)
{
q.push(root);//将根节点插进队列
}
while(!q.empty())
{
Node* front = q.front();
q.pop();
cout<<front->_value<<" ";
if (front->_lchild)
{
q.push(front->_lchild);
}
if (front->_rchild)
{
q.push(front->_rchild);
}
}
}3、求二叉树的高度（深度）
外部接口：
size_t Depth()//求树的深度
{
cout<<"depth:";
return depth(_root);
}算法实现：
size_t depth(Node* root)//求树的深度
{
if (NULL == root)
{
return 0;
}
else
{
return depth(root->_lchild)>depth(root->_rchild)?
(depth(root->_lchild)+1):(depth(root->_rchild)+1);
}
}4、求二叉树中节点的个数
外部接口：
size_t Size()//求树中的节点个数
{
cout<<"size:";
return size(_root);
}算法实现：
size_t size(Node* root)//求树中的节点个数
{
size_t count = 0;
if (NULL == root)
{
count = 0;
}
else
{
//当前节点 = 左子树节点 + 右子树节点 + 1
count = size(root->_lchild) + size(root->_rchild)+ 1;
}
return count;
}5、求二叉树中叶子节点的个数
外部接口：
size_t GetLeafSize()
{
cout<<"leaf_size:";
return getleafsize(_root);
}算法实现：
size_t getleafsize(Node* root)//求叶节点的个数
{
if (NULL == root)//空树
{
return 0;
}
if (NULL == root->_lchild && NULL == root->_rchild)//左叶节点右节点均为空，即
{
return 1;
}
else//左子树的叶节点+右子树的叶节点
{
return getleafsize(root->_lchild)+getleafsize(root->_rchild);
}
}6、求二叉树第K层的节点个数（假设根节点为第1层）
外部接口：
size_t GetKLevelSize(size_t k)//树中第k层的节点个数
{
cout<<k<<"_level_size:";
return getklevelsize(_root,k);
}算法实现：
size_t getklevelsize(Node* root,size_t k)//树中第k层的节点个数
{
assert(k>0);
size_t count = 0;
if (NULL == root)
{
return 0;
}
if (k == 1)
{
count++;
}
else
{
count = getklevelsize(root->_lchild,k-1)
+ getklevelsize(root->_rchild,k-1);
}
return count;
}7、判断一个节点是否在二叉树中
外部接口：
bool Find(const T& data) //判断一个值为的节点是否在当前二叉树中
{
return _Find(_root,data);
}算法实现：
bool _Find(Node* root,const T& data) //查找指定数据的节点
{
if (NULL == root)
{
return false;
}
else if (root->_data == data)
{
return true;
}
else
{
bool isIn = false;
if (root->_left && !isIn)
isIn = _Find(root->_left,data);
if (root->_right && !isIn)
isIn = _Find(root->_right,data);
return isIn;
}
}8、求两个节点的最近公共祖先
外部接口：
Node* sameAncester(Node* n1,Node* n2) //求两个节点的最近公共祖先
{
//return _sameAncester1(_root,n1,n2);
//return _sameAncester2(_root,n1,n2);
return _sameAncester3(_root,n1,n2);
}算法实现：
Node* _sameAncester1(Node*& root,Node* n1,Node* n2)//求两个节点的最近公共祖先(时间复杂度：O(N^2))
{
assert(n1 && n2);
//保证两个节点都在当前树中,且当前树不为空
if (root && Find(n1->_data) && Find(n2->_data))
{
//其中一个节点为根节点，直接返回根节点
if (root->_data == n1->_data || root->_data == n2->_data)
{
return root;
}
//两个节点：1、都在左子树 2、都在右子树 3、一个在左子树，一个在右子树
else
{
Node* cur = root;
//在当前树的左子树去找n1和n2节点，如果没找到就一定在右子树
bool tmp1 = _Find(cur->_left,n1->_data);
bool tmp2 = _Find(cur->_left,n2->_data);
//n1和n2都在左子树
if (tmp1 && tmp2)
{
return _sameAncester1(cur->_left,n1,n2);
}
//n1和n2都在右子树
else if(!tmp1 && !tmp2)
{
return _sameAncester1(cur->_right,n1,n2);
}
//n1与n2一个在左子树一个在右子树
else
{
return root;
}
}
}
return NULL;
}
bool _GetPath2(Node* root,Node* cur,stack<Node*>& s)//在根为root的树中查找节点cur的路径
{
if (NULL == root || NULL == cur)//树为空
return false;
s.push(root); //将当前节点入栈
if (cur->_data == root->_data) //找到路径
{
return true;
}
if (_GetPath2(root->_left,cur,s))//在左子树中找路径
{
return true;
}
if (_GetPath2(root->_right,cur,s))//在右子树中找路径
{
return true;
}
s.pop();
return false;
}
Node* _sameAncester2(Node*& root,Node* n1,Node* n2)//求两个节点的最近公共祖先(时间复杂度：O(N))
{
//树为空
if (NULL == root)
{
return NULL;
}
stack<Node*> s1;
stack<Node*> s2;
//用栈s1和s2分别保存节点n1和节点n2的路径
_GetPath2(root,n1,s1);
_GetPath2(root,n2,s2);
//将多余的路径删除
while (s1.size() > s2.size())
{
s1.pop();
}
while(s1.size() < s2.size())
{
s2.pop();
}
//找s1与s2中不同的节点
while(s1.top() != s2.top())
{
s1.pop();
s2.pop();
}
return s1.top();
}
bool _GetPath3(Node* root,Node* cur,vector<Node*>& v)
{
if (NULL == root || NULL == cur)//树为空
return false;
v.push_back(root);
if (cur->_data == root->_data) //找到路径
{
return true;
}
else
{
bool ret = false;
if (root->_left && !ret)//在左子树中找路径
{
ret = _GetPath3(root->_left,cur,v);
}
if (root->_right && !ret)//在右子树中找路径
{
ret = _GetPath3(root->_right,cur,v);
}
if (ret == false && v.size() != 0)//如果不是正确路径上的节点，就去除该节点
{
v.pop_back();
}
return ret;
}
}
Node* _sameAncester3(Node*& root,Node* n1,Node* n2)
{
//树为空
if (NULL == root)
{
return NULL;
}
//定义容器
vector<Node*> v1;
vector<Node*> v2;
//用容器v1和v2分别保存节点n1和节点n2的路径
_GetPath3(root,n1,v1);
_GetPath3(root,n2,v2);
////从下往上找
////定义指向查找节点的迭代器指针
//vector<Node*>::iterator it1 = --v1.end();
//vector<Node*>::iterator it2 = --v2.end();
////将多余的路径节点删除掉
//while(v1.size() > v2.size())
//{
// --it1; //相应的迭代器要向前移
// v1.pop_back();
//}
//while(v2.size() > v1.size())
//{
// --it2; //相应的迭代器要向前移
// v2.pop_back();
//}
////找v1与v2中不同的节点
//while(it1 >= v1.begin() && it2 >= v2.begin())
//{
// if (*it1 == *it2)
// {
// return *it1;
// }
// --it1;
// --it2;
//}
//从上往下找
//定义指向查找节点的迭代器指针
vector<Node*>::iterator it1 = v1.begin();
vector<Node*>::iterator it2 = v2.begin();
//找v1与v2中不同的节点
while(it1 != v1.end() && it2 != v2.end())
{
if (*it1 != *it2)//找到第一个不相同的节点，返回前一个节点
{
return *(--it1);
}
++it1;
++it2;
}
//处理特殊情况，例如：v1:1->2->3 v2:1->2
if (it1 == v1.end() || it2 == v2.end())
return *(--it1);
return NULL;
}9、判断一棵二叉树是否是平衡二叉树
算法实现
bool IsCompleteBT()//判断一棵树是否是完全二叉树
{
bool flag = true;//判断一棵子树是否为一棵完全二叉树的标记
queue<Node*> q; //运用队列进行层序遍历
q.push(_root);
while(!q.empty())
{
Node* front = q.front();//保存队首节点
q.pop(); //将队首元素出队
/*如果队首元素的左树为空，将标志置为false,如果层序遍历\ \后面的节点还有子树，说明不是完全二叉树*/
if (NULL == front->_left)
{
flag = false;
}
else
{
/*如果flag为假，说明之前已经有节点的孩子为空，又因当前\ \节点的左孩子不为空，说明不是完全二叉树*/
if (flag == false)
{
return false;
}
q.push(front->_left);//继续向后探索
}
/*如果队首元素的右树为空，将标志置为false,如果层序遍历\ \后面的节点还有子树，说明不是完全二叉树*/
if (NULL == front->_right)
{
flag = false;
}
else
{
/*如果flag为假，说明之前已经有节点的孩子为空，又因当前\ \节点的右孩子不为空，说明不是完全二叉树*/
if (flag == false)
{
return false;
}
q.push(front->_right);//继续向后探索
}
}
return true;//能走到这里说明一定是完全二叉树
}10、求二叉树中最远的两个节点的距离
外部接口：
int RemoteDistance() //求二叉树中最远的两个节点的距离
{
int tmp = 0;
return _RemoteDistance1(_root,tmp);
}算法实现：
int _RemoteDistance1(Node* root,int& distance)
{
if (NULL == root)
{
return 0;
}
int tmp = _Depth(root->_left)+_Depth(root->_right);//递归去求每棵子树的最远距离
if (distance < tmp)//用全局变量保存每棵子树的最远距离，并不断更新
{
distance = tmp;
}
return distance;
}11、由前序遍历和中序遍历重建二叉树
外部接口：
Node* Rebuild(T* prevOrder,T* inOrder,int n) //根据前序序列和中序序列重建二叉树
{
assert(prevOrder && inOrder);
int prevIndex = 0; //指向前序序列指针的下标
int inBegin = 0; //中序序列的首位置的下标
int inEnd = n-1; //中序序列的末位置的下标(闭区间)
_root = _Rebuild(prevOrder,prevIndex,inOrder,inBegin,inEnd,n);
return _root;
}算法实现：
Node* _Rebuild(T* prevOrder,int& prevIndex,T* inOrder,int inBegin,int inEnd,int n)
{
Node* root = NULL;
if (prevIndex < n)//当前序序列的下标<n时才创建新结点
{
root = new Node(prevOrder[prevIndex]);
}
if (NULL == root)//递归的返回条件
{
return NULL;
}
if (inBegin == inEnd)//要重建树中只有一个节点
{
return root;
}
else
{
//在中序序列中找到前序序列中的根
int i = inBegin;
for ( ; i <= inEnd; ++i)
{
if (prevOrder[prevIndex] == inOrder[i])
break;
}
if (i > inEnd)//说明中序序列中没找到前序序列中的根，所给序列不匹配
{
throw invalid_argument("所给序列不匹配！");//直接抛异常
}
//将根节点作为分割线，将区间分为左右两部分，分别递归重建左右子树
root->_left = _Rebuild(prevOrder,++prevIndex,inOrder,inBegin,i-1,n);
root->_right = _Rebuild(prevOrder,++prevIndex,inOrder,i+1,inEnd,n);
return root;
}
}12、判断一棵树是否是完全二叉树
算法实现：
bool IsCompleteBT()//判断一棵树是否是完全二叉树
{
bool flag = true;//判断一棵子树是否为一棵完全二叉树的标记
queue<Node*> q; //运用队列进行层序遍历
q.push(_root);
while(!q.empty())
{
Node* front = q.front();//保存队首节点
q.pop(); //将队首元素出队
/*如果队首元素的左树为空，将标志置为false,如果层序遍历\ \后面的节点还有子树，说明不是完全二叉树*/
if (NULL == front->_left)
{
flag = false;
}
else
{
/*如果flag为假，说明之前已经有节点的孩子为空，又因当前\ \节点的左孩子不为空，说明不是完全二叉树*/
if (flag == false)
{
return false;
}
q.push(front->_left);//继续向后探索
}
/*如果队首元素的右树为空，将标志置为false,如果层序遍历\ \后面的节点还有子树，说明不是完全二叉树*/
if (NULL == front->_right)
{
flag = false;
}
else
{
/*如果flag为假，说明之前已经有节点的孩子为空，又因当前\ \节点的右孩子不为空，说明不是完全二叉树*/
if (flag == false)
{
return false;
}
q.push(front->_right);//继续向后探索
}
}
return true;//能走到这里说明一定是完全二叉树
}13、求二叉树的镜像
外部接口：
void GetMirrorTree()//求二叉树的镜像
{
_GetMirrorTree(_root);
}算法实现：
void _GetMirrorTree(Node* root)//求二叉树的镜像
{
if (NULL == root)
{
return;
}
swap(root->_left,root->_right);//交换左右子树
_GetMirrorTree(root->_left); //递归遍历左子树
_GetMirrorTree(root->_right);//递归遍历右子树
}14、将二叉搜索树转换为一个已排序的双向链表。要求不能创建任何新的节点，只能调整树中节点指针的指向
外部接口：
void MakeSearchToList()/*将二叉搜索树转换成一个排序的双向链表。\ 要求不能创建任何新的结点，只能调整树中结点指针的指向。*/
{
Node* cur = _root;
//寻找最左节点
while (cur->_left)
{
cur = cur->_left;
}
Node* prev = NULL;
_MakeSearchToList1(_root,prev);
//_MakeSearchToList2(_root);
while(cur)//打印链表(树的结构变了之后析构会死循环)
{
cout<<cur->_data<<"<->";
cur = cur->_right;
}
cout<<"null";
}算法实现：
void _MakeSearchToList1(Node* root,Node*& prev)
{
if (NULL == root)//如果当前树为空，则直接返回
return;
_MakeSearchToList1(root->_left,prev);//递归左子树
//进行转换
root->_left = prev;//root第一次指向最左节点
if (prev)//如果上一个节点不为空，就将上一个节点的右指针指向当前节点root
{
prev->_right = root;
}
prev = root;//更新保存上一个节点
_MakeSearchToList1(root->_right,prev);//递归右子树
}
void _InOrderList(Node* root,queue<Node*>& q)//将树的中序遍历的节点入到队列中
{
if (NULL == root)
return;
_InOrderList(root->_left,q);//递归左子树
q.push(root); //将当前节点入队
_InOrderList(root->_right,q);//递归右子树
}
void _MakeSearchToList2(Node* root)
{
if (NULL == root)//如果当前树为空则直接返回
return;
queue<Node*> q;
_InOrderList(root,q);//将所给树的中序序列push到队列q中
Node* head = q.front();//将队首节点（即所给树的最左节点）保存起来
q.pop();
head->_left = NULL;//将队首节点的左指针置空
Node* prev = head;//用prev保存当前节点
while(!q.empty())//当队列不空时进入循环
{
Node* front = q.front();//获取队首节点
q.pop(); //将队首节点出队
prev->_right = front; //将前一个节点的右指针指向队首节点
front->_left = prev; //将队首节点的左指针指向上一个节点
front->_right = NULL; //将队首节点的右指针置空
prev = front; //更新保存上一个节点
}
}