Cracking The Coding Interview 4.4

//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;
}