二叉树相关操作2

// TREE.cpp : 定义控制台应用程序的入口点。
//

#include "stdio.h"
#include "stdlib.h"
#include "iostream"
#include "stack"
#include "vector"

using namespace std;

typedef struct Node
{
	int data;
	struct Node * lc;
	struct Node * rc;
}TreeNode;

typedef struct Tree
{
	struct Node * root;
};

// for char
typedef struct Node_c
{
	char data;
	struct Node_c * lc;
	struct Node_c * rc;
}TreeNode_c;

typedef struct Tree_c
{
	struct Node_c * root;
};


void CreateTree(Node * &root);
void CreateTree(Node * &root, int &index);
void PreOrder(Node * root);
void InOrderTraverse(Node * root);
void Traverse(char * ps, char * pn, char * &p, Node_c * &root);
void PostOrder(Node_c * root);

int elements[] = {1,2,4,8,-1,-1,9,-1,-1,5,-1,-1,3,6,-1,-1,7,-1,-1};
static int index = 0;
vector<char> post;
int main(int argc, char * argv[])
{

	Tree tree;
	tree.root = NULL;

	CreateTree(tree.root, index);
	PreOrder(tree.root);

	cout<<"//"<<endl;

	cout<<"in order traverse"<<endl;
	InOrderTraverse(tree.root);

	char * preOrder = "ABDEHCFG";  
    char * inOrder = "DBEHAFCG";
	char * ps = inOrder;  
    char * pn;  
  
    char * temp = inOrder;  
    while(*temp != '\0')  
    {  
        pn = temp;  
        temp++;  
    }


	Tree_c t2;
	t2.root = NULL;
	Traverse(ps, pn, preOrder, t2.root);

	cout<<endl;
	PostOrder(t2.root);

	system("pause");
	return 0;
}

// 先序建立二叉树
void CreateTree(Node * &root)
{
	int data;
	scanf("%d", &data);
	if(data == -1)
		return; // 叶子节点

	root = new Node;

	root->data = data;
	root->lc = NULL;
	root->rc = NULL;

	CreateTree(root->lc);
	CreateTree(root->rc);
}

// 先序建立二叉树
void CreateTree(Node * &root, int &index)
{
	int data = elements[index];
	if(data == -1)
		return; // 叶子节点

	root = new Node;
	root->data = data;
	root->lc = NULL;
	root->rc = NULL;

	CreateTree(root->lc, ++index);
	CreateTree(root->rc, ++index);
}

// 先序遍历
void PreOrder(Node * root)
{
	if(root)
	{
		printf("%3d", root->data);
		PreOrder(root->lc);
		PreOrder(root->rc);
	}
}

// 后序遍历
void PostOrder(Node_c * root)
{
	if(root)
	{
		PostOrder(root->lc);
		PostOrder(root->rc);
		printf("%3c", root->data);
	}
}

void InOrderTraverse(Node * root)
{
	stack<Node *> s;
	s.push(root);

	while(!s.empty())
	{
		Node * p = s.top();
		while( p != NULL )
		{
			s.push(p->lc);
			p = s.top();
		}

		s.pop();

		if(!s.empty())
		{
			Node * t = s.top();
			s.pop();
			printf("%3d", t->data);
			s.push(t->rc);
		}
	}
}



void Traverse(char * ps, char * pn, char * &p, Node_c * &root)
{  
    if(pn < ps)
    {     
        // 没有左子树的情况  
        return;  
    }  
  
    if(ps > pn)  
    {  
        // 没有右子树  
        return;  
    }

	root = new Node_c;
	root->lc = NULL;
	root->rc = NULL;
  
    char node = *p;  
    if(ps == pn)  
    {  
        // 遍历到叶子节点，相当于左右子树都为空  
        post.push_back(node);
		root->data = node;
        return;  
    }
  
    char * pc = ps;
    while(*pc != *p)  
    {  
        pc++;  
    }  
  
  
    if(pc > ps)  
    {  
        // pc == ps的情况下，当前节点没有左子树，所以不用递归遍历  
        p++;  
		Traverse(ps, pc - 1, p, root->lc);  
    }  
  
    if(pc < pn)  
    {  
        p++;  
		Traverse(pc + 1, pn, p, root->rc);  
    }  
    // 递归返回  
    post.push_back(node);
	root->data = node;
}