BST的生成和遍历PAT1043

delete []array; 只是将array所分配内存释放掉， 而并不置array为0, 而是置array一个随机的值，即所谓的野指针. 如果在程序中 你能保证执行完delete 之后不再引用array（ 比如在析构函数中），  那么array=0就没有什么必要了。   如果在其它函数中执行的delete []array, 那么这个时候执行array=0; 就很有必要了。
#include<string>
#include<vector>
#include<queue>
#include<iostream>
using namespace std;
typedef struct Node
{
int key;
Node* left;
Node* right;
Node(Node* _l=NULL,Node* _r=NULL,int k=-1):key=k,left=_l,right=_r{};//初始化
}Node;
//C++引用的用法  http://www.cnblogs.com/Mr-xu/archive/2012/08/07/2626973.html
【例1】：int a; int &ra=a; //定义引用ra,它是变量a的引用，即别名
【例2】：void swap(int &p1, int &p2) //此处函数的形参p1, p2都是引用


{ int p; p=p1; p1=p2; p2=p; }   在main中只需要swap(a,b);即可完成交换功能，引用传递相当于传递指针




//BST生成函数（插入节点）
void InsertTree(Node* &tree,int key){
Node **p = &tree;   //二级指针=指针的引用（即为指针的指针）
//采用二级指针传递动态内存
//*ppRoot = NULL;的意思是要将所有结点指针指向NULL，然后返回给主函数，那么二级指针就能达到这个作用，否则
//虽然结点内存释放了，但是所有的结点全部成为野指针，没有固定的指向
while((*p) != NULL){
if(key < (*p)->key)
p = &(*p)->left;
else
p = &(*p)->right;
}
(*p) = new Node;
(*p)->key = key;
}
//释放内存
void ReleaseTree(Node* tree)  
{  
    std::queue<Node*> q;  
    q.push(tree);  
    while(!q.empty())  
    {  
        Node* p = q.front();  
        q.pop();  
        if(p)  
        {  
            q.push(p->left);  
            q.push(p->right);  
            delete p;  
        }  
    }  
} 
//前序遍历BST
void TravelRootLR(Node* tree, std::vector<int>& v)  
{  
    if(tree == NULL) return;  
    v.push_back(tree->key);  
    TravelRootLR(tree->left, v);  
    TravelRootLR(tree->right, v);  
}  
void TravelRootRL(Node* tree, std::vector<int>& v)  
{  
    if(tree == NULL) return;  
    v.push_back(tree->key);  
    TravelRootRL(tree->right, v);  
    TravelRootRL(tree->left, v);  
}  
//后序遍历BST


void TravelLRRoot(Node* tree, std::vector<int>& v)  
{  
    if(tree == NULL) return;  
    TravelLRRoot(tree->left, v);  
    TravelLRRoot(tree->right, v);  
    v.push_back(tree->key);  
}  
void TravelRLRoot(Node* tree, std::vector<int>& v)  
{  
    if(tree == NULL) return;  
    TravelRLRoot(tree->right, v);  
    TravelRLRoot(tree->left, v);  
    v.push_back(tree->key);  
}  
 
int main()  
{  
    int n;  
    while(scanf("%d",&n)!=EOF)  
    {  
        std::vector<int> inputVec(n);  
        for(int i = 0; i < n; ++i)  
            scanf("%d",&inputVec[i]);  
        //build tree  
        Node* tree = NULL;  
        for(int i = 0; i < n; ++i)  
            InsertTree(tree, inputVec[i]);   //生成BST
        //get RootLR & RootRL & RLRoot  
        std::vector<int> t1, t2, t3;  
        TravelRootLR(tree, t1);  
        TravelRootRL(tree, t2);  
          
        //judge  
        //int size = (int)t3.size();  
        //if( IsSame(inputVec, t1) || IsSame(inputVec, t2) )  
        if(inputVec == t1)  //前序非mirror
        {  
            printf("YES\n");  
            TravelLRRoot(tree, t3);  
            int size = (int)t3.size();  
            for(int i = 0; i < size-1; ++i)  
                printf("%d ", t3[i]);  
            printf("%d\n", t3[size-1]);  
        }  
        else if(inputVec == t2)//前序mirror
  
        {  
            printf("YES\n");  
            TravelRLRoot(tree, t3);  
            int size = (int)t3.size();  
            for(int i = 0; i < size-1; ++i)  
                printf("%d ", t3[i]);  
            printf("%d\n", t3[size-1]);  
        }  
        else   
        {  
            printf("NO\n");  
        }  
        ReleaseTree(tree);  
    }  
    return 0;  
}