#include <iostream>
#include <cstdlib>
#include <cassert>
#include <stack>
#include <cmath>
#include <queue>
#include <list>
using namespace std;
//面试经典二叉树算法
typedef char ElemType;
#define END '#'
template <typename T>
const T & Max(const T& a,const T & b)
{
return a>b?a:b;
}
typedef struct BtNode
{
//BtNode *parent;
BtNode *leftchild;
BtNode *rigthchild;
ElemType data;
}BtNode , *BinaryTree;
BtNode * _Buynode()
{
BtNode *s = (BtNode *)malloc(sizeof(BtNode));
if(NULL == s) exit(1);
memset(s,0,sizeof(BtNode));
return s;
}
void _Freenode(BtNode *p)
{
free(p);
}
//利用出栈的顺序进行遍历
struct StkNode
{
BtNode * Btnode;
int PopNum;
public:
StkNode(BtNode * ptr = NULL)
:Btnode(ptr),PopNum(0)
{}
};
//中序
void IsTree_struct_pop_num(BtNode *ptr)
{
if(ptr == NULL)
{
return ;
}
stack<StkNode> st;
st.push(StkNode(ptr));
while (!st.empty())
{
StkNode p = st.top();
st.pop();
p.PopNum++;
if( p.PopNum == 2 )
{
cout<<p.Btnode->data<< " ";
if( p.Btnode->rigthchild != NULL )
{
st.push(StkNode(p.Btnode->rigthchild));
}
} else {
st.push(StkNode(p));
if(p.Btnode->leftchild != NULL) {
st.push(StkNode(p.Btnode->leftchild));
}
}
}
}
//后序
void PassTree_struct_pop_num(BtNode *ptr)
{
if(ptr == NULL)
{
return ;
}
stack<StkNode> st;
st.push(StkNode(ptr));
while (!st.empty())
{
StkNode pt = st.top();
st.pop();
pt.PopNum++;
if(pt.PopNum == 3) //第三次出栈，打印
{
cout<<pt.Btnode->data<<" ";
}
else
{
st.push(ptr);
if(pt.PopNum == 1 && pt.Btnode->leftchild != NULL)
{
st.push(StkNode(pt.Btnode->leftchild));
}
else if(pt.PopNum == 2 && pt.Btnode->rigthchild != NULL)
{
st.push(StkNode(pt.Btnode->rigthchild));
}
}
}
}
//创建二叉树
BtNode* Create_Tree(const char * &str)
{
BtNode * s = NULL;
if(str == NULL)
{
return NULL;
}
if(*str != END)
{
s = _Buynode();
s->data = *str;
s->leftchild = Create_Tree(++str);
s->rigthchild = Create_Tree(++str);
}
return s;
}
//前序递归
void PreTree(BtNode *ptr)
{
if(ptr == NULL)
{
return ;
}
else
{
cout<<ptr->data<<" ";
PreTree(ptr->leftchild);
PreTree(ptr->rigthchild);
}
}
//前序非递归
void PreOrder2(BtNode *ptr)
{
if(ptr == NULL)
{
return;
}
stack<BtNode *>st;
st.push(ptr);
while (!st.empty())
{
ptr = st.top();
st.pop();
cout <<ptr->data<<" ";
if(ptr->rigthchild != NULL) //right
{
st.push(ptr->rigthchild);
}
if(ptr->leftchild != NULL)//left
{
st.push(ptr->leftchild);
}
}
}
//前序非递归
void PreOrder1(BtNode *ptr)
{
if(ptr == NULL)
{
return;
}
stack<BtNode*> st;
while (ptr != NULL || !st.empty())
{
while (ptr != NULL)
{
cout<<ptr->data<<" ";
st.push(ptr);
ptr = ptr->leftchild;
}
ptr = st.top();
st.pop();
ptr = ptr->rigthchild;
}
}
//中序非递归
void IsOrder(BtNode * ptr)
{
if(ptr == NULL)
{
return;
}
stack<BtNode *> st;
while(ptr != NULL || !st.empty())
{
while(ptr != NULL)
{
st.push(ptr);
ptr = ptr->leftchild;
}
ptr = st.top();
st.pop();
cout<<ptr->data<<" ";
ptr = ptr->rigthchild;
}
}
//后续非递归
void PassOrder(BtNode *ptr)
{
if(ptr == NULL)
{
return;
}
stack<BtNode*> st;
BtNode *flag = NULL;
while (ptr != NULL || !st.empty())
{
while (ptr != NULL)
{
st.push(ptr);
ptr = ptr->leftchild;
}
ptr = st.top();
st.pop();
if(ptr->rigthchild == NULL || flag == ptr->rigthchild)
{
cout<<ptr->data<<" ";
flag = ptr;
ptr = NULL; //如果已经访问了的数据节点，则此节点将会失去生命周期，没有意义
}
else
{
st.push(ptr); //他的右子树还没有访问
ptr = ptr->rigthchild;
}
}
cout<<endl;
}
//树高
int Hight_Tree(BtNode *ptr)
{
if(ptr == NULL)
{
return 0;
}
if(ptr->leftchild == NULL && ptr->rigthchild == NULL)
{
return 1;
}
int lefthight = Hight_Tree(ptr->leftchild);
int righthight = Hight_Tree(ptr->rigthchild);
return Max(lefthight,righthight)+1;
}
//节点个数
int Size_Tree(BtNode *ptr)
{
if(ptr == NULL)
{
return 0;
}
return Size_Tree(ptr->leftchild)+Size_Tree(ptr->rigthchild)+1;
}
//叶节点个数
int leave_Tree(BtNode *ptr)
{
if(ptr == NULL)
{
return 0;
}
if(ptr->leftchild == NULL && ptr->rigthchild == NULL)
{
return 1;
}
return leave_Tree(ptr->rigthchild)+leave_Tree(ptr->leftchild)+1;
}
//完全二叉树
bool Is_Comp_Binary_Tree(BtNode *ptr)
{
if(ptr == NULL)
{
return true;
}
queue<BtNode *> qu;
qu.push(ptr);
bool result = true;
bool flag = false;
while (!qu.empty())
{
ptr = qu.front();
qu.pop();
if(flag)
{
if(ptr->leftchild != NULL || ptr->rigthchild !=NULL)
{
result = false;
break;
}
}
if(ptr->leftchild != NULL && ptr->rigthchild == NULL)
{
qu.push(ptr->leftchild);
flag = true;
}
if(ptr->leftchild == NULL && ptr->rigthchild == NULL)
{
flag = true;
}
if(ptr->leftchild == NULL && ptr->rigthchild != NULL)
{
result = false;
break;
}
if(ptr->leftchild != NULL && ptr->rigthchild !=NULL)
{
qu.push(ptr->leftchild);
qu.push(ptr->rigthchild);
}
}
return result;
}
//满二叉树
bool Is_Full_Binary_Tree(BtNode *ptr)
{
if(ptr == NULL)
{
return true;
}
int higth = Hight_Tree(ptr);
int sizecount = Size_Tree(ptr);
int leave = leave_Tree(ptr);
if((sizecount == pow(2,higth)-1) && leave == pow(2,higth-1))
{
return true;
}
else
{
return false;
}
}
//树节点
int GetNumTree(BtNode *ptr)
{
if(ptr == NULL)
{
return 0;
}
return GetNumTree(ptr->leftchild)+GetNumTree(ptr->rigthchild)+1;
}
//打印倒数第k个
void PrintCompBTree(BtNode *ptr, int k)//倒数第k个节点
{
assert(ptr != NULL);
int len = GetNumTree(ptr);
if(ptr == NULL ||k < 0 || k > len)
{
return;
}
int k1 = len-k;
int i = 0;
queue<BtNode*> queue;
queue.push(ptr);
while (!queue.empty())
{
ptr = queue.front();
queue.pop();
i++;
if( i == k1)
{
cout<<"倒数第"<<k<<"个节点:"<<ptr->data<<endl;
break;
}
if(ptr->leftchild != NULL)
{
queue.push(ptr->leftchild);
}
if(ptr->rigthchild != NULL)
{
queue.push(ptr->rigthchild);
}
}
}
int GetBinaryTreeLevel(BtNode *ptr, int k)
{
if(ptr == NULL || k < 0)
{
return 0;
}
if(k == 1)
{
return 1;
}
int leftcount = GetBinaryTreeLevel(ptr->leftchild,k-1);
int rightcount = GetBinaryTreeLevel(ptr->rigthchild,k-1);
return leftcount+rightcount;
}
//平衡二叉树
bool IsBalance_BinaryTree(BtNode *ptr,int &hight)
{
if(ptr == NULL)
{
hight = 0;
return false;
}
if(ptr->leftchild == NULL && ptr->rigthchild != NULL)
{
return false;
}
if(ptr->rigthchild != NULL && ptr->leftchild == NULL)
{
return false;
}
int lefthight = 0;
int righthight = 0;
bool boolleft = IsBalance_BinaryTree(ptr->leftchild,lefthight);
bool boolright = IsBalance_BinaryTree(ptr->rigthchild,righthight);
return boolright && boolleft && (abs(lefthight - righthight) <=1);
}
//查找节点
bool FindNode_Tree(BtNode *ptr,BtNode *child)
{
if(ptr == NULL || child == NULL)
{
return false;
}
if(ptr == child)
{
return true;
}
bool flag = FindNode_Tree(ptr->leftchild ,child);
if(!flag)
{
flag = FindNode_Tree(ptr->rigthchild,child);
}
return flag;
}
//寻找相同祖父
BtNode * FindComParent(BtNode *ptr, BtNode *child1,BtNode *child2)
{
if(ptr == NULL || child1 == NULL || child2 == NULL)
{
return NULL;
}
if(FindNode_Tree(ptr->leftchild,child1)) // 左右 ----
{
if(FindNode_Tree(ptr->rigthchild,child2))
{
return ptr;
}
else
{
return FindComParent(ptr->leftchild,child1,child2);
}
}
if(FindNode_Tree(ptr->rigthchild,child1))//not else //may be no this child in ptr
{
if(FindNode_Tree(ptr->leftchild,child2)) //右左
{
return ptr;
}
else
{
return FindComParent(ptr->rigthchild,child1,child2);
}
}
return NULL;
}
//2
bool Get_Child_Tree_Path(BtNode *ptr,BtNode *child,list<BtNode*>& path)
{
if(ptr == NULL || child == NULL )
{
return false;
}
if(ptr == child)
{
path.push_back(ptr);
return true;
}
path.push_back(ptr);
bool found = false;
found = Get_Child_Tree_Path(ptr->leftchild,child,path);
if(!found)
{
found = Get_Child_Tree_Path(ptr->rigthchild,child,path);
}
if(!found)
{
path.pop_back();
}
return found;
}
BtNode * FindComParent2(BtNode *ptr, BtNode *child1,BtNode *child2)
{
if(NULL == ptr || NULL == child1 || NULL == child2)
{
return NULL;
}
list<BtNode *>path1;
list<BtNode *>path2;
bool boolchild1 = Get_Child_Tree_Path(ptr,child1,path1);
bool boolchild2 = Get_Child_Tree_Path(ptr,child2,path2);
BtNode * last = NULL;
if(boolchild1 && boolchild2)
{
list<BtNode *>::iterator it1 = path1.begin();
list<BtNode *>::iterator it2 = path2.begin();
while(it1 != path1.end() && it2 != path2.end())
{
if(*it1 == *it2)
{
last = *it1;
}
else
{
break;
}
++it1;
++it2;
}
}
else
{
last = NULL;
}
return last;
}
//转换成双链表
BtNode * BinaryTreeToList(BtNode *ptr)
{
if(ptr == NULL )
{
return NULL;
}
BtNode *head = NULL;
stack<BtNode*> st;
while (ptr != NULL || !st.empty() )
{
while (ptr!=NULL)
{
st.push(ptr);
ptr = ptr->leftchild;
}
BtNode *p = st.top();
ptr = p;
st.pop();
if(NULL == head)
{
head = p;
head->rigthchild = NULL;
head->leftchild = NULL;
}
else
{
BtNode *pre = head;
while (pre->rigthchild != NULL)
{
pre = pre->rigthchild;
}
pre->rigthchild = p;
p->leftchild = pre;
p->rigthchild = NULL;
}
ptr = ptr->rigthchild;
}
return head;
}
void BinaryTreeToList3(BtNode * &head,BtNode *&last)
{
if(head == NULL) return;
BinaryTreeToList3(head->leftchild,last);
head->leftchild = last;
if(last != NULL)
{
last->rigthchild = head;
}
last = head;
BinaryTreeToList3(head->rigthchild,last);
}
void BinaryTreeToList2(BtNode * ptr,BtNode *&first,BtNode *&last)
{
BtNode *pfirstleft;
BtNode *plastleft;
BtNode *pfirstright;
BtNode *plastright;
if(ptr == NULL)
{
first = NULL;
last = NULL;
return ;
}
if(ptr->leftchild == NULL)
{
first = ptr;
}
else
{
BinaryTreeToList2(ptr->leftchild,pfirstleft,plastleft);
first = pfirstleft;
//把根节点放置到在左子树中查找到的最后一个节点
ptr->leftchild = plastleft;
plastleft->rigthchild = ptr;
}
if(ptr->rigthchild == NULL)
{
last = ptr;
}
else
{
BinaryTreeToList2(ptr->rigthchild,pfirstright,plastright);
last = plastright;
ptr->rigthchild = pfirstleft;
pfirstleft->rigthchild = ptr;
}
}
int main()
{
//const char* p = "ABC##DE##F##G#H##";
//BtNode * root = Create_Tree(p);
//PreTree(root);
//cout<<endl;
//PreOrder2(root);
//cout<<endl;
//IsOrder(root);
//PassTree_struct_pop_num(root);
//int hight = 0;
//if(IsBalance_BinaryTree(root,hight))
//{
//cout<<"root is IsBalance_BinaryTree"<<endl;
//}
const char *str1 = "ABC##D##EF###";
const char *str2 = "ABCG###D##EF###";
BtNode *root = Create_Tree(str1);
IsOrder(root);
BtNode *p;
BtNode *q = NULL;
BinaryTreeToList3(root,q);
//BinaryTreeToList2(root,p,q);
for(p = root;p!=NULL;p = p->rigthchild)
{
cout<<p->data<<" ";
}
cout<<endl;
//cout<<p->data<<" "<<p->rigthchild->data<<" "<<p->rigthchild->rigthchild->data<<endl;
//for(;p!=q;p = p->rigthchild)
//{
// cout<<p->data<<" ";
//}
//BtNode *root2 = Create_Tree(str2);
////PreTree(root);
//
//cout<<endl;
//cout<<GetNumTree(root)<<endl;
//BtNode * p = BinaryTreeToList(root);
//cout<<endl;
//while (p!=NULL)
//{
// cout<<p->data<<" ";
// p = p->rigthchild;
//}
//PassOrder(root);
//if(Is_Comp_Binary_Tree(root))
//{
// cout<<"Ok Is_Comp_Binary_Tree"<<endl;
//}
//cout<<GetBinaryTreeLevel(root2,4)<<endl;
/*PreTree(root2); cout<<endl; PassOrder(root2); if(Is_Comp_Binary_Tree(root2)) { cout<<"Ok Is_Comp_Binary_Tree"<<endl; }*/
return 0;
}
//如果有什么错误，希望不吝赐教
