test

/*
深度优先搜索用栈（stack）来实现，整个过程可以想象成一个倒立的树形：
1、把根节点压入栈中。
2、每次从栈中弹出一个元素，搜索所有在它下一级的元素，把这些元素压入栈中。并把这个元素记为它下一级元素的前驱。
3、找到所要找的元素时结束程序。
4、如果遍历整个树还没有找到，结束程序。
广度优先搜索使用队列（queue）来实现，整个过程也可以看做一个倒立的树形：
1、把根节点放到队列的末尾。
2、每次从队列的头部取出一个元素，查看这个元素所有的下一级元素，把它们放到队列的末尾。并把这个元素记为它下一级元素的前驱。
3、找到所要找的元素时结束程序。
4、如果遍历整个树还没有找到，结束程序
*/

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <stack>
#include <queue>
#include <iostream>

using namespace std;
#define T char;
int index = 0;

struct Node{
char data;
int pre;
struct Node *lchild;
struct Node *rchild;
};

int TreeBrand(Node* root)
{
queue<Node*>Nodequeue;
root->pre = 0;
Nodequeue.push(root);
Node * TreeNode;
int brand[100] = { 0 };
while (Nodequeue.size() != 0)
{
TreeNode = Nodequeue.front();
Nodequeue.pop();
brand[TreeNode->pre]++;
if (TreeNode->lchild)
{
TreeNode->lchild->pre = TreeNode->pre + 1;
Nodequeue.push(TreeNode->lchild);
}
if (TreeNode->rchild)
{
TreeNode->rchild->pre = TreeNode->pre + 1;
Nodequeue.push(TreeNode->rchild);
}
}

int max = 0;
for (int i = 0; i < 100; i++)
{
if (brand[i]> max)
max = brand[i];
}
return max;
}
void  TreeNodeConstruct(Node* &root, char Data[])//(Node* root, char Data[])不能通过，root指针未初始化
{
char value = Data[index++];
if (value == '#')
root = NULL;
else
{
root = (Node*)malloc(sizeof(Node));//申请sizeof(Node)大小的Node类型的内存空间，并将这连续的存储单元的首地址赋给root
root->data = value;
TreeNodeConstruct(root->lchild, Data);//递归构建左子树
TreeNodeConstruct(root->rchild, Data);//递归构建右子树
}
}

void DFS(Node* root)
{
stack<Node*> NodeStack;//stl模板,存的是Node类型的指针
NodeStack.push(root);
Node * TreeNode;
while (!NodeStack.empty())
{
TreeNode = NodeStack.top();//取栈顶元素
cout << TreeNode->data << endl;//遍历根节点
NodeStack.pop();//栈顶元素出栈
if (TreeNode->rchild)//将右孩子压栈，先进后出，右节点后遍历
NodeStack.push(TreeNode->rchild);
if (TreeNode->lchild)
NodeStack.push(TreeNode->lchild);
}
}

void BFS(Node* root)
{
queue<Node*> NodeQueue;//stl模板
NodeQueue.push(root);
Node* TreeNode;
while (!NodeQueue.empty())
{
TreeNode = NodeQueue.front();
cout << TreeNode->data << endl;
NodeQueue.pop();
if (TreeNode->lchild)
NodeQueue.push(TreeNode->lchild);//队列，将左子树入队列，左子树先遍历
if (TreeNode->rchild)
NodeQueue.push(TreeNode->rchild);
}

}
void InOrder_Tree_Search(Node* root)
{
if (root != NULL)
{
InOrder_Tree_Search(root->lchild);
cout << root->data << endl;
InOrder_Tree_Search(root->rchild);
}
}

int TreeDepth(Node * root)
{
if (root == NULL)
return 0;
int nLeft = TreeDepth(root->lchild);
int nRight = TreeDepth(root->rchild);

return (nLeft > nRight) ? (nLeft + 1) : (nRight + 1);
}

void main()
{
char Data[15] = { 'A', 'B', 'D', '#', '#', 'E', '#', '#', 'C', 'F', '#', '#', 'G', '#', '#' };
Node * root;
TreeNodeConstruct(root, Data);//此时对root指针没有初始化，但是在调用函数中加入&引用变量，就可以通过？？？
cout << "Depth First Search" << endl;
DFS(root);
cout << "Brand First Search" << endl;
BFS(root);
cout << "InOder Tree_Search" << endl;
InOrder_Tree_Search(root);
cout << TreeDepth(root) << endl;
cout << TreeBrand(root) << endl;

}