二叉搜索树

题目

题目描述：
判断两序列是否为同一二叉搜索树序列
输入：
开始一个数n，(1<=n<=20) 表示有n个需要判断，n= 0 的时候输入结束。
接下去一行是一个序列，序列长度小于10，包含(0~9)的数字，没有重复数字，根据这个序列可以构造出一颗二叉搜索树。
接下去的n行有n个序列，每个序列格式跟第一个序列一样，请判断这两个序列是否能组成同一颗二叉搜索树。
输出：
如果序列相同则输出YES，否则输出NO
样例输入：
2
567432
543267
576342
0
样例输出：
YES
NO

思路

二叉搜索树的特点

二叉查找树，对任何结点x，其左子树中的关键字最大不超过key[x],其右子树中的关键字最小小于key[x]。不同的二叉查找树可以表示同一组值。

内存分配

这道题目本身不难，但是我递归构建树时，却没将局部函数中指针指向malloc申请的内存空间的指针返回，导致gdb调试了好久，内存分配参考链接：http://blog.csdn.net/zinss26914/article/details/8687859

解题思路

1. 构建二叉搜索树
2. 构建前序遍历数组和中序遍历数组（前序遍历和中序遍历序列可唯一确定一颗二叉树）
3. 比较输入字符串构造的前序&&中序数组是否和原树的相同

AC代码

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
#define LEN 21
 
struct btree
{
    struct btree *lchild, *rchild;
    char data;
};
 
struct stack
{
    int top;
    struct btree* arr[LEN];
};
 
char order_str[LEN], pre_str[LEN], compare_order[LEN], compare_pre[LEN];
 
struct btree* create_searchtree(struct btree *t, char temp);
void order_traverse(struct btree *t, char *A);
void pre_traverse(struct btree *t, char *A);
void clean_searchtree(struct btree *t);
 
int main()
{
    int i, j, n, len, clen;
    char str1[LEN], str2[LEN];
 
    while (scanf("%d", &n) != EOF && n != 0) {
 
        // 接收客户端数据输入
        scanf("%s", str1);
        struct btree *t;
        for (i = 0, len = strlen(str1), t = NULL; i < len; i ++) {
            t = create_searchtree(t, str1[i]);
        }
 
        // 中序遍历二叉树
        order_traverse(t, order_str);
 
        // 前序遍历二叉树
        pre_traverse(t, pre_str);
             
 
        // 接收比较序列
        for (i = 0; i < n; i ++) {
            scanf("%s", str2);
            struct btree *r;
 
            for (j = 0, clen = strlen(str2), r = NULL; j < clen; j ++) {
                r = create_searchtree(r, str2[j]);
            }
 
            order_traverse(r, compare_order);
 
            if (strcmp(order_str, compare_order) != 0) {
                printf("NO\n");
            }else {
                pre_traverse(r, compare_pre);
                if (strcmp(pre_str, compare_pre) != 0) {
                    printf("NO\n");
                }else {
                    printf("YES\n");
                }
            }
            clean_searchtree(r);
        }
        clean_searchtree(t);
    }
 
    return 0;
}
 
/**
 * Description:构建二叉查找树
 */
struct btree* create_searchtree(struct btree *t, char temp)
{
    if (t == NULL) {    // 若当前树为空
        t = (struct btree *)malloc(sizeof(struct btree) * 1);
        if (t == NULL) {
            printf("内存分配失败!\n");
            exit(EXIT_FAILURE);
        }
        t->data = temp;
        t->lchild = NULL;
        t->rchild = NULL;
    }else if (t->data > temp) {   // 如果比当前结点小，则插入左子树
        t->lchild = create_searchtree(t->lchild, temp);
    }else if (t->data < temp){    // 如果比当前结点大，则插入右子树
        t->rchild = create_searchtree(t->rchild, temp);
    }
 
    return t;
}
 
void order_traverse(struct btree *t, char *A)
{
    struct stack *s = malloc(sizeof(struct stack));
    s->top = 0;
    struct btree *p = t;
    memset(A, 0, sizeof(A));
    int i = 0;
 
    while (s->top || p) {
        if (p) {
            s->arr[s->top ++] = p;
            p = p->lchild;
        } else {
            p = s->arr[-- s->top];
            A[i ++] = p->data;
            p = p->rchild;
        }
    }
}
 
void pre_traverse(struct btree *t, char *A)
{
    struct stack *s = malloc(sizeof(struct stack));
    s->top = 0;
    struct btree *p = t;
    memset(A, 0, sizeof(A));
    int i = 0;
 
    while (s->top || p) {
        if (p) {
            A[i ++] = p->data;
            s->arr[s->top ++] = p;
            p = p->lchild;
        } else {
            p = s->arr[-- s->top];
            p = p->rchild;
        }
    }
 
}
 
void clean_searchtree(struct btree *t)
{
    if (t) {
        clean_searchtree(t->lchild);
        clean_searchtree(t->rchild);
        free(t);
    }
}
/**************************************************************
    Problem: 1009
    User: wangzhengyi
    Language: C
    Result: Accepted
    Time:10 ms
    Memory:908 kb
****************************************************************/