PAT 1043 二叉查找树

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;

const int SIZE = 5000;

int g_preOrder[SIZE];
int g_preOrderImg[SIZE];
int g_postOrder[SIZE];
int g_index = 0;

struct BSNode
{
    BSNode *left;
    BSNode *right;
    int key;
};

//在一颗二叉查找树中添加一个节点。isImg为true，则表示生成的
//是二叉查找树的镜像；
void insertNode(BSNode* &p, int key,bool isImg)
{
    if(p == NULL)
    {
        p = new BSNode();
        p->left = NULL;
        p->right = NULL;
        p->key = key;
        return;
    }
    else
    {
        if(isImg)
        {
            if(p->key <= key)
                insertNode(p->left, key, isImg);
            else
                insertNode(p->right, key, isImg);
        }
        else
        {
            if(p->key > key)
                insertNode(p->left, key, isImg);
            else
                insertNode(p->right, key, isImg);
        }
    }
    
}


//创建一颗二叉查找树或其镜像。
void createBST(BSNode* &root, int arr[], int n,bool isImg)
{
    for(int i=0; i<n; i++)
    {
        insertNode(root, arr[i], isImg);
    }
}

void preOrder(BSNode* root,bool isImg)
{
    if(root == NULL)
        return;
    if(isImg)
        g_preOrderImg[g_index++] = root->key;
    else
        g_preOrder[g_index++] = root->key;
    if(root->left)
        preOrder(root->left,isImg);
    if(root->right)
        preOrder(root->right,isImg);
}

//二叉查找树或其镜像的输出结果。
void postOrder(BSNode* root)
{
    if(root == NULL)
        return;
    if(root->left)
        postOrder(root->left);
    if(root->right)
        postOrder(root->right);
    g_postOrder[g_index++] = root->key;
}

//检查两个数组的内容是否相同。
bool checkIsSame(int a[],int b[], int len)
{
    int i = 0;
    for(i=0; i<len; i++)
        if(a[i] != b[i])
            return false;
    return true;
}

//输出后序遍历的结果。
void printRes(int arr[], int len)
{
    bool isFirst = true;
    int i = 0;
    for(i=0; i<len; i++)
    {
        if(isFirst)
        {
            cout<<arr[i];
            isFirst = false;
        }
        else
        {    
            cout<<" "<<arr[i];
        }
        if(i == len-1)//最后一个元素要输出换行符
            cout<<endl;
    }
}

//释放一颗二叉树的节点
void freeNodes(BSNode *root)
{
    if(NULL == root->left && NULL == root->right)
        delete root;
    else if(root->left)
        freeNodes(root->left);
    else if(root->right)
        freeNodes(root->right);
}


int main()
{
    int i,j,N,arr[1003];
    while(cin>>N)
    {
        BSNode *root = NULL;
        BSNode *rootImg = NULL;
        for(i=0; i<N; i++)
        {
            cin>>arr[i];
        }
        createBST(root, arr, N, false);
        createBST(rootImg, arr, N, true);
        g_index = 0;
        preOrder(root,false);//得到二叉查找树的先序遍历结果
        if(checkIsSame(arr, g_preOrder, N))
        {
            cout<<"YES"<<endl;
            g_index = 0;
            postOrder(root);
            printRes(g_postOrder, N);
        }    
        else 
        {
            g_index = 0;
            preOrder(rootImg, true);//得到二叉查找树镜像的先序遍历结果
            if(checkIsSame(arr, g_preOrderImg, N))
            {
                cout<<"YES"<<endl;
                g_index = 0;
                postOrder(rootImg);
                printRes(g_postOrder,N);
            }
            else
                cout<<"NO"<<endl;            
        }
        
        freeNodes(root);
        freeNodes(rootImg);
    }
    
    return 0;
}