二叉树和二叉树排序

很长时间没有看过数据结构了，二叉树都淡忘了，赶紧复习一下。

二叉树是每个结点最多有两个子树的树结构。下面就定义一下如下：

struct tree
{
    int data;
    struct tree *child_l;
    struct tree *child_r;
};

关于二叉树，有多种遍历方式，前序，中序和后序，前中后代表了根节点的顺序，就是先根，中根，后根。

遍历分为递归遍历和非递归遍历。

递归遍历的代码非常简单。一下就是以前序为例子，进行前序遍历：

void read_tree(struct tree *t) {
    printf("%d\n",t->data);
    if (t->child_l != NULL)
        read_tree(t->child_l);
    if (t->child_r != NULL)
        read_tree(t->child_r);
}

非递归需要借助栈的数据结构，那么首先建立一个栈：

struct stack {
    struct tree* stack_value[10];
    int top;
};

并且初始化一个栈：

#define NOMAL_COUNT 1

struct stack* init_stack() {
    struct stack *s = (struct stack *) calloc(NOMAL_COUNT, sizeof(struct stack));
    s->top = -1;
    return s;
}

然后是入栈和出栈：

void stack_push(struct stack *s, struct tree *t) {
    s->top++;
    s->stack_value[s->top] = t;
}

struct tree* stack_pop(struct stack *s) {
    struct tree *t = s->stack_value[s->top];
    s->top--;
    return t;
}

接下来就是非递归遍历，非递归就是根完了一直向左，左边完全完了再访问右边：

void read_tree2(struct tree *t) {
    struct tree * temp = t;
    struct stack *s = init_stack();
    
    while (temp != NULL || s->top != -1) {
        while (temp != NULL) {
            printf("%d\n", temp->data);
            stack_push(s, temp);
            temp = temp->child_l;
        }
        if (s->top != -1) {
            temp = stack_pop(s); 
            temp = temp->child_r;
        }
    }
}

初始化一下这个树：

struct tree *t = (struct tree *) calloc(NOMAL_COUNT, sizeof(struct tree));
struct tree *temp;
t->data = 1;
t->child_l = (struct tree *) calloc(NOMAL_COUNT, sizeof(struct tree));
temp = t->child_l;
temp->data = 2;
temp->child_l = (struct tree *) calloc(NOMAL_COUNT, sizeof(struct tree));
temp->child_l->data = 4;
temp->child_r = (struct tree *) calloc(NOMAL_COUNT, sizeof(struct tree));
temp->child_r->data = 5;
t->child_r = (struct tree *) calloc(NOMAL_COUNT, sizeof(struct tree));
t->child_r->data = 3;

然后开始遍历就好啦，得到：1，2，4，5，3.

接下来是二叉树排序：

可以将小的放在左孩子上，大的放在右孩子上：

void add_tree(struct tree *t, int number) {
    if (t->data > number) {
        if (t->child_l != NULL) {
            add_tree(t->child_l, number);
        } else {
            t->child_l = (struct tree *) calloc(NOMAL_COUNT, sizeof(struct tree));
            t->child_l->data = number;
        }
    } else {
        if (t->child_r != NULL) {
            add_tree(t->child_r, number);
        } else {
            t->child_r = (struct tree *) calloc(NOMAL_COUNT, sizeof(struct tree));
            t->child_r->data = number;
        }
    }
}

然后就可以中序遍历二叉树，输出排序结果了：

// 中序遍历二叉树
void read_tree(struct tree *t) {
    if (t->child_l != NULL)
        read_tree(t->child_l);
    printf("%d\n",t->data);
    if (t->child_r != NULL)
        read_tree(t->child_r);
}

我们来测试一下：

int main(int argc, char const *argv[])
{
    int numbers[] = {8, 7, 1, 4, 3, 5, 9, 19, 13, 11, 15, 20, 16, 2, 6};
    struct tree *t = (struct tree *) calloc(NOMAL_COUNT, sizeof(struct tree));
    t->data = numbers[0];
    for (int i = 1; i < 15; i++) {
        add_tree(t, numbers[i]);
    }
    read_tree(t);
    return 0;
}

输出结果：

1
2
3
4
5
6
7
8
9
11
13
15
16
19
20