//Given a binary search tree, design an algorithm which creates a linked list of all the nodes at each depth (i.e., if you have a tree with depth D, you’ll have D linked lists).
//
// 译文：
//
// 给定一棵二叉查找树，设计算法，将每一层的所有结点构建为一个链表(也就是说， 如果树有D层，那么你将构建出D个链表)
#include <iostream>
#include <string>
#include <queue>
#include <stack>
#include <list>
using namespace std;
struct treenode
{
char data;
treenode * left;
treenode * right;
};
class tree
{
public:
tree()
{
//root = create();
root = NULL;
index = 0;
}
/***输入扩展层次遍历序列，#表示该节点为空***/
tree(char *s)
{
root = NULL;
index = 0;
if (s == NULL)
{
return;
}
int size = strlen(s);
create(&root,s,0,size);
}
~tree()
{
/***清空二叉树***/
}
/***二叉排序树：插入。***/
void insert(char *s)
{
if (s == NULL)
{
return;
}
int size = strlen(s);
for (int i = 0; i<size; i++)
{
insert(&root, s[i]);
}
}
void createBanlance(char *s)
{
int size = strlen(s);
createB(&root, s, 0, size-1);
cout<<"End"<<endl;
}
void levelOrder()
{
queue<treenode *> q;
if (root != NULL)
{
q.push(root);
}
while(!q.empty())
{
treenode *t = q.front();
cout<<t->data<<endl;
q.pop();
if (t->left != NULL)
{
q.push(t->left);
}
if (t->right != NULL)
{
q.push(t->right);
}
}
}
/***
方法同hawstein
***/
vector<list<treenode *>> createList()
{
vector<list<treenode *>> l;
int level = 0;
list<treenode *>li;
li.push_back(root);
l.push_back(li);
while(!l[level].empty())
{
list<treenode *>t;
for (list<treenode *>::iterator it = l[level].begin(); it != l[level].end(); it++)
{
treenode *n = *it;
if (n->left){t.push_back(n->left);}
if (n->right){t.push_back(n->right);}
}
level++;
l.push_back(t);
}
return l;
}
/***
使用一个栈、两个队列来实现
***/
vector<list<treenode *>> createlist()
{
vector<list<treenode *>>l;
int i = 0;
stack<treenode *>st;
queue<treenode *>qa,qb;
st.push(root);
while(!st.empty())
{
while(!st.empty())
{
treenode *n = new treenode;
n->data = st.top()->data;
n->left = st.top()->left;
n->right = st.top()->right;
qa.push(n);
qb.push(n);
st.pop();
}
//i++;
list<treenode *>li;
while(!qa.empty())
{
treenode *t = new treenode;
t->data = qa.front()->data;
t->left = qa.front()->left;
t->right = qa.front()->right;
// l[i].push_back(t);
li.push_back(t);
qa.pop();
}
l.push_back(li);
while(!qb.empty())
{
if (qb.front()->left)
{
treenode *t = new treenode;
t->data = qb.front()->left->data;
t->left = qb.front()->left->left;
t->right = qb.front()->left->right;
st.push(t);
}
if (qb.front()->right)
{
treenode *tb = new treenode;
tb->data = qb.front()->right->data;
tb->left = qb.front()->right->left;
tb->right = qb.front()->right->right;
st.push(tb);
}
qb.pop();
}
}
return l;
}
bool isBanlance(int size)
{
int *s = new int[size];
depth(root,s,size,0);
s[index+1] = '\0';
int i = 0;
int max = s[0];
int min = s[0];
while(s[i]!='\0')
{
if (s[i]>max)
{
max = s[i];
}
if (s[i]<min)
{
min = s[i];
}
i++;
}
return ((max - min)>1? 0:1);
}
void preOrder(){ pOrder(root);}
void inOreder(){ zOrder(root);}
void postOreder(){ hOrder(root);}
private:
treenode *root;
int index;
void insert(treenode **p, char s)
{
if (((*p) == NULL) && s != '\0')
{
*p = new treenode;
(*p)->data = s;
(*p)->left = NULL;
(*p)->right = NULL;
}
else
{
if ((*p)->data > s)
{
insert(&((*p)->left) , s);
}
else
{
insert(&((*p)->right) , s);
}
}
}
/**取begin,end中间值做根节点，两值相等相等为叶节点，大于为空**/
void createB(treenode **p, char *s, int begin, int end)
{
if (begin>end)
{
*p = NULL;
return;
}
else if (begin == end)
{
*p = new treenode;
(*p)->data = s[end];
(*p)->left = (*p)->right = NULL;
}
else
{
*p = new treenode;
int mid = (begin + end)/2;
(*p)->data = s[mid];
cout<<s[mid]<<endl;
createB(&((*p)->left), s, begin, mid -1);
createB(&((*p)->right), s, mid +1, end);
}
}
void depth(treenode *s, int *str,int size,int k)
{
if (s==NULL)
{
return;
}
if (s->left == NULL && s->right == NULL)
{
str[index]= k;
index++;
}
else
{
depth(s->left,str, size, k+1);
depth(s->right,str, size, k+1);
}
}
treenode* create()
{
treenode *p;
char t;
cout<<"请输入："<<endl;
t = getchar();
if (t=='#')
{
p = NULL;
}
else
{
p = new treenode;
p->data = t;
cout<<"create tree node: "<<t<<endl;
p->left = create();
p->right = create();
}
return p;
}
void create(treenode **p, char *str, int i, int size)
{
if (i>size-1 || str[i] == '\0')
{
*p = NULL;
return;
}
if (str[i] == '#')
{
*p=NULL;
}
else
{
*p = new treenode;
(*p)->data = str[i];
create(&((*p)->left),str,2*i+1,size);
create(&((*p)->right),str,2*i+2,size);
}
}
void pOrder(treenode *p)
{
if (p==NULL)
{
return;
}
cout<<p->data<<" "<<endl;
pOrder(p->left);
pOrder(p->right);
}
void zOrder(treenode *p)
{
if (p==NULL)
{
return;
}
zOrder(p->left);
cout<<p->data<<" "<<endl;
zOrder(p->right);
}
void hOrder(treenode *p)
{
if (p==NULL)
{
return;
}
hOrder(p->left);
cout<<p->data<<" "<<endl;
hOrder(p->right);
}
};
int main()
{
/***扩展层次序列简立树***/
//char t[9] = "ABCDE#FG";
//tree s(t);
//s.preOrder();
/***建立二叉排序树***/
//tree s;
//char t[8] = "3289654";
//s.insert(t);
// s.postOreder();
/**4.1*************************/
//cout<<"is Banlance? "<<s.isBanlance(8)<<endl;
/**4.3*************************/
/*tree s;
char t[9] = "12345678";
s.createBanlance(t);
s.preOrder();
*/
/**非递归层次遍历*************************/
tree s;
char t[8] = "3289654";
s.insert(t);
//s.levelOrder();
/**4.4*************************/
//vector<list<treenode *>>l=s.createList();//hawstein的方法
vector<list<treenode *>>l=s.createlist();//一个栈、两个队列
cout<<"Over"<<endl;
for (int i = 0; i<l.size(); i++)
{
for (list<treenode *>::iterator j = l[i].begin(); j != l[i].end(); j++)
{
cout<< (*j)->data;
}
cout<<endl;
}
return 0;
}
