(eden)对称二叉树

Description:

实在不知道出什么题目了，就还是二叉树吧，你们也别嫌烦。

判断一棵二叉树是否对称。二叉树节点定义如上次的结构相同：

typedef struct node {
    int x;
    struct node* left;
    struct node* right;
} BN;

不用关心输入，二叉树构造和删除过程已经在main函数中实现，需要你们实现函数

int isSymmetric(BN* root)；

来判断一棵二叉树是否对称，对称返回1，非对称返回0.

node结构要按照上面的代码在symmetric.h中进行定义。

注意被测试二叉树不一定是满二叉树。如果树不存在（根节点指针为空）返回0。如果除根节点外没有任何的其他节点返回1。

代码

#include<stdio.h>
#include<stdlib.h>
#define MAXD 50
typedef struct node {
    int x;
    struct node* left;
    struct node* right;
}BN;
void buildTree(BN** root) {
    int temp;
    BN** que[MAXD];
    int head = 0;
    int tail = 1;
    que[0] = root;
    scanf("%d", &temp);
    while (temp != -1) {
        *que[head] = (BN*)malloc(sizeof(struct node));
        (*que[head])->x = temp;
        que[tail] = &((*que[head])->left);
        tail = (tail + 1) % MAXD;
        que[tail] = &((*que[head])->right);
        tail = (tail + 1) % MAXD;
        head = (head + 1) % MAXD;
        scanf("%d", &temp);
    }
    while (head != tail) {
        *que[head] = NULL;
        head = (head + 1) % MAXD;
    }
}
void freeTree(BN* root) {
    if (root != NULL) {
        freeTree(root->left);
        freeTree(root->right);
        free(root);
    }
}
int a[100] = {0}, b[100] = {0};
int atot = 0, btot = 0;
void left(BN* k) {
    if (k -> left != NULL) {
        left(k -> left);
    }
    a[++atot] = k -> x;
    if (k -> right != NULL) {
        left(k -> right);
    }
}
void right(BN* k) {
    if (k -> right != NULL) {
        right(k -> right);
    }
    b[++btot] = k -> x;
    if (k -> left != NULL) {
        right(k -> left);
    }
}
int isSymmetric(BN* k) {
    if (k == NULL) {
        return 0;
    }
    if ((k -> left == NULL)&&(k -> right == NULL)) {
        return 1;
    }
    left(k -> left);
    right(k -> right);
    int i;
    for (i = 1; i <= 50; i++) {
        if (a[i] != b[i]) {
            return 0;
        }
    }
    return 1;
}
int main() {
    BN* root = NULL;
    buildTree(&root);
    printf("%d
", isSymmetric(root));
    freeTree(root);
    return 0;
}

//symmetric.h

typedef struct node {
    int x;
    struct node* left;
    struct node* right;
}BN;
int a[100] = {0}, b[100] = {0};
int atot = 0, btot = 0;
void left(BN* k) {
    if (k -> left != NULL) {
        left(k -> left);
    }
    a[++atot] = k -> x;
    if (k -> right != NULL) {
        left(k -> right);
    }
}
void right(BN* k) {
    if (k -> right != NULL) {
        right(k -> right);
    }
    b[++btot] = k -> x;
    if (k -> left != NULL) {
        right(k -> left);
    }
}
int isSymmetric(BN* k) {
    if (k == NULL) {
        return 0;
    }
    if ((k -> left == NULL)&&(k -> right == NULL)) {
        return 1;
    }
    left(k -> left);
    right(k -> right);
    int i;
    for (i = 1; i <= 50; i++) {
        if (a[i] != b[i]) {
            return 0;
        }
    }
    return 1;
}

标程

1.#include<stdio.h>
2.#include<stdlib.h>
3.#include"symmetric.h"
4.#define MAXD 50
5.void buildTree(BN** root) {
6.    int temp;
7.    BN** que[MAXD];
8.    int head = 0;
9.    int tail = 1;
10.    que[0] = root;
11.    scanf("%d", &temp);
12.    while (temp != -1) {
13.        *que[head] = malloc(sizeof(struct node));
14.        (*que[head])->x = temp;
15.        que[tail] = &((*que[head])->left);
16.        tail = (tail + 1) % MAXD;
17.        que[tail] = &((*que[head])->right);
18.        tail = (tail + 1) % MAXD;
19.        head = (head + 1) % MAXD;
20.        scanf("%d", &temp);
21.    }
22.    while (head != tail) {
23.        *que[head] = NULL;
24.        head = (head + 1) % MAXD;
25.    }
26.}
27.void freeTree(BN* root) {
28.    if (root != NULL) {
29.        freeTree(root->left);
30.        freeTree(root->right);
31.        free(root);
32.    }
33.}
34.int main() {
35.    BN* root = NULL;
36.    buildTree(&root);
37.    printf("%d
", isSymmetric(root));
38.    freeTree(root);
39.    return 0;
40.}

1.#ifndef SYMM
2.#define SYMM
3.#include<stdio.h>
4.#include<string.h>
5.#include<stdlib.h>
6.typedef struct node {
7.    int x;
8.    struct node* left;
9.    struct node* right;
10.} BN;
11.int f = 1;
12.void isSymmetric2(BN* left, BN* right) {
13.    if (f == 1) {
14.        if (left == NULL && right != NULL)
15.            f = 0;
16.        else if (left != NULL && right == NULL)
17.            f = 0;
18.        else if (left != NULL && right != NULL) {
19.            isSymmetric2(left->left, right->right);
20.            isSymmetric2(left->right, right->left);
21.            if (left->x != right->x)
22.                f = 0;
23.        }
24.    }
25.}
26.int isSymmetric(BN* root) {
27.    if (root == NULL) f = 0;
28.    else isSymmetric2(root->left, root->right);
29.    return f;
30.}
31.#endif

解释

标答的更好，因为同时判断了结构上面也是一个对称二叉树，我的有一点投机取巧，就是把根的左节点的左序遍历遍历了一遍，根的右节点的右序遍历遍历了一遍，判断两者相等则是对称，但是这不是充要条件，只是必要条件，侥幸过关==