（eden）排序二叉树VS二叉树链表

排序二叉树

Description:

题目大意：请完成下面四个函数的定义（在tree.h文件中），使整个程序能够利用排序二叉树的结构对输入的数（不会出现相同的数），进行排序输出。节点的结构体在下面已给出，这个二叉树的特征是，左子数的值肯定比父节点小，右子树的值肯定比父节点的大。要求大家按照这个结构特征去构建二叉树，最后中序遍历输出就是我们要求的升序输出。

树的节点结构体为：

typedef struct Node {

         struct Node *left;

         struct Node *right;

         int value;

} Node;

中序遍历这个二叉树，按照升序输出，每个数之间有一个空格，最后一个数后也有一个空格。

void traverse_tree_inorder(Node *p);

回收建立二叉树时开辟的内存空间，提示类似后序遍历。

void recycle_nodes(Node *p);

将一个值为value的数插入到这个树中，但是要注意，需要插到那个地方，按照排序二叉树的要求来。

void insert_node(Node *p, int value);

初始化根节点的值。

Node* init_root(int value);

输入示例：

5

23 3 53 333 2

输出示例：

2 3 23 53 333  （最后一个数后有空格）

前置知识要求：数据结构二叉树，二叉树的中序遍历和后序遍历，递归函数设计，指针的使用，结构体。

知识介绍：

先序遍历：对一棵二叉树的前序遍历，先访问根结点，再访问左子树，然后访问右子树。

void preorder(Treenode *p) {

if (p!=NULL){

visit(p);

preorder(p->left);

preorder(p->right);

}

}

中序遍历：对一棵二叉树的中序遍历，先访问左子树，再访问根结点，然后访问右子树。

void inorder(Treenode *p) {

if (p!=NULL){

inorder(p->left);

visit(p);

inorder(p->right);

}

}

后序遍历：对一棵二叉树的后序遍历，先访问左子树，再访问右子树，然后访问根结点。

void postorder(Treenode *p) {

if (p!=NULL){

postorder(p->left);

postorder(p->right);

visit(p);

}

}

Hint:

Hint is not available for this exercise.

 

代码

#include<stdio.h>
#include<stdlib.h>
#define MAXI 50
typedef struct Node {

         struct Node *left;

         struct Node *right;

         int value;

} Node;

void traverse_tree_inorder(Node *p) {
    if (p -> left != NULL) {
        traverse_tree_inorder(p -> left);
    }
    printf("%d ", p -> value);
    if (p -> right != NULL) {
        traverse_tree_inorder(p -> right);
    }
}
void recycle_nodes(Node *p) {
    Node* que[50];
    que[0] = p;
    int head = 0;
    int tail = 1;
    while (head != tail) {
        if (que[head]->left != NULL) {
            que[tail] = que[head]->left;
            tail = (tail + 1) % MAXI;
        }
        if (que[head]->right != NULL) {
            que[tail] = que[head]->right;
            tail = (tail + 1) % MAXI;
        }
        free(que[head]);
        head = (head + 1) % MAXI;
    }
}
void insert_node(Node *p, int value) {
    Node* q;
    int t = 0;
    while (p != NULL) {
        q = p;
        if (value <= (p -> value)) {
            p = p -> left;
            t = 1;
        } else {
            p = p -> right;
            t = 2;
        }
    }
    p = (Node*)malloc(sizeof(Node));//in the eden,there should be 隐形类型转换
    p -> value = value;
    p -> left = NULL;
    p -> right = NULL;
    if (t == 1) {
        q -> left = p;
    } else {
        q -> right = p;
    }
}
Node* init_root(int value) {
    Node* p = (Node*)malloc(sizeof(Node));//in the eden,(Node*)is not needed
    p -> value = value;
    p -> left = NULL;
    p -> right = NULL;
    return p;
}
int main() {
    int node_num, i = 0, temp;
    Node *root = NULL;
    scanf("%d", &node_num);
    while (i < node_num) {
        scanf("%d", &temp);
        if (i == 0) root = init_root(temp);
        else insert_node(root, temp);
        i++;
    }
    traverse_tree_inorder(root);
    printf("
");
    recycle_nodes(root);
    return 0;
}

二叉树链表

Description:

使用链表实现二叉树的构造并完成中序遍历。

首先在头文件中定义结点结构体如下：

typedef struct node {

int x;

struct node* left;

struct node* right;

} BN;

其次要实现两个函数，函数buildTree通过读入一串整数以层次优先从左到右的方式构建一个二叉树，函数outputTree输出此树的中序遍历。两个函数的原型如下：

void buildTree(BN** rootptr);

void outputTree(BN* root);

输入：N个正整数，1<=N<=30，以空格间隔，以-1结束。注意-1不包含在此树的结构中，只是作为输入结束的符号。

输出：一行按照中序遍历排列的正整数，以空格间隔，最后一个输出的元素后仍然有空格，且没有换行

注意：main函数已经给出，并且在其中给出了树的根节点的指针以及整棵树free的过程，buildTree函数内所有的结点应以malloc形式生成，如果一个结点没有左儿子或者右儿子，则相应的指针应该等于NULL。

Sample:

input:

1 2 3 4 5 6 7 8 9 -1

output：

8 4 9 2 5 1 6 3 7 

Hint:

如果以层次优先从左向右构建二叉树的过程感觉有难度，可以参考main函数中释放所有结点空间的做法。思想就是使用一个“队列”数据结构存储要处理的指针。

关于前序中序后序遍历的知识请自行查找书本及网上相应内容进行学习。

代码

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define MAXI 50
typedef struct node {
    int x;
    struct node* left;
    struct node* right;
}BN;
void outputTree(BN* root);
void buildTree(BN** rootptr) {
    int num, tot = 1, head = 1;
    BN* a[50];
    scanf("%d", &num);
    BN* p = (BN*)malloc(sizeof(BN));
    *rootptr = p;
    (*rootptr) -> x = num;
    a[1] = *rootptr;
    a[1] -> left = NULL;
    a[1] -> right = NULL;
    while (num != -1) {
        scanf("%d", &num);
        if (num != -1) {
            tot++;
            BN* left = (BN*)malloc(sizeof(BN));
            left -> x = num;
            left -> left = NULL;
            left -> right = NULL;
            a[tot] = left;
            a[head] -> left = left;
            scanf("%d", &num);
        }
        if (num != -1) {
            tot++;
            BN* right = (BN*)malloc(sizeof(BN));
            right -> x = num;
            right -> right = NULL;
            right -> left = NULL;
            a[tot] = right;
            a[head] -> right = right; 
        }
        head++;
    }
}
void outputTree(BN* root) {
    if (root -> left != NULL) {
        outputTree(root -> left);
    }
    printf("%d ", root -> x);
    if (root -> right != NULL) {
        outputTree(root -> right);
    }
}
int main() {
    BN* root;
    BN* que[MAXI];    /*used for free*/
    int head = 0;   /*head of que*/
    int tail = 1;   /*tail of que*/
    buildTree(&root);
    outputTree(root);
    /*the free procedure*/
    que[0] = root;
    while (head != tail) {
        if (que[head]->left != NULL) {
            que[tail] = que[head]->left;
            tail = (tail + 1) % MAXI;
        }
        if (que[head]->right != NULL) {
            que[tail] = que[head]->right;
            tail = (tail + 1) % MAXI;
        }
        free(que[head]);
        head = (head + 1) % MAXI;
    }
    return 0;
}