数据结构C语言——简单二叉树的实现

4 树

深度：层数。

度：子树的数量。

叶子：没有子节点的节点。

4.1 二叉树

定义：每个节点至多有两个子节点，且需要区分左孩子和右孩子。

满二叉树：深度为 $k$ 节点数量为 $2^k-1$ 的二叉树。

完全二叉树：只有最后两层的节点可以不满，且只有一个子节点的节点，其子节点必为左孩子的二叉树。

4.1.1 二叉树的顺序存储

/*	
 *	二叉树 如下
 *								A
 *						B				C
 *					D		E		F		G
 *				H	……	……	……		……	……	……
 *  我们假设A的编号为1，B的编号为2，…………。则我们可以总结出来节点编号为n的节点，
 *其左子树的编号为2n，右子树的编号为2n+1.通过这种方式，我们能够通过顺序结构存储
 *二叉树。
 *
 *优点：同顺序表。
 *缺点：空间利用率低，容易产生大量空闲空间；不能适用其他类型的树。
 *
 */

4.1.2 二叉树的链式存储

/*
 *  构造节点结构体
 *
 * struct _node_st{
 *     datatype data;
 *     struct _node_st *leftChild;
 *     struct _node_st *rightChild;
 * }
 *
 *  使用这种节点构造二叉树，如果没有子节点，就将对应的指针指空。
 *
 *
 *
 */

4.2 遍历

/*	
 *	二叉树 如下
 *								A
 *						B					  C
 *					 		D			E			F
 *						G			H		I	
 *  
 *
 */

• 按行遍历

ABCDEFGHI

• 先序遍历

遍历顺序：根节点–>左子树–>右子树

A BDG CEHI F

• 中序遍历

遍历顺序：左子树–>根节点–>右子树

B DG A HEI C F

• 后序遍历

左子树–>右子树–>根节点

GD B HIE F C A

4.3 程序实现

• 简单二叉树的实现

main.c

#include 
#include 

#define NAMESIZE    32

typedef struct score_st SCORE;

struct score_st{
      
    int id;
    char name[NAMESIZE];
    int math;
    int chinese;
           
};


struct node_st{
    SCORE data;
    struct node_st *l, *r; 
};



void print_s(const void *record){
    const SCORE *r = record;
    printf("%d %s %d %d\n", r->id, r->name, r->math, r->chinese);
}


int insert(struct node_st **root, SCORE *data){

    struct node_st *node;


    if((*root) == NULL){
        node = malloc(sizeof(*node));
        if(node == NULL){
            return -1;
        }
        node->data = *data;
        node->l = NULL;
        node->r = NULL;

        *root = node;
        return 0;
    }

    if(data->id <= (*root)->data.id){
        return insert(&(*root)->l, data);
    }
    else{
        return insert(&(*root)->r, data);
    }

}


SCORE *find(struct node_st *root, int id){
    
    if(root == NULL){
        return NULL;
    }

    if(id == root->data.id){
        return &root->data;
    }

    if(id <= root->data.id){
        return find(root->l, id);
    }
    else{
        return find(root->r, id);
    }

}

void draw_(struct node_st *root, int level){
    if(root == NULL){
        return ;
    }

    draw_(root->r, level+1);

    for(int i = 0; i < level; i++){
        printf("    ");
    }
    print_s(&root->data);

    draw_(root->l, level+1);
}


void draw(struct node_st *root){//向左倒
    draw_(root , 0);
}

int main(){

    int arr[] = {1, 2, 3, 7, 6, 5, 9, 8, 4};
    int i;
    struct node_st *tree = NULL;
    SCORE tmp;

    for(i = 0; i < sizeof(arr)/sizeof(*arr); i++ ){
        tmp.id = arr[i];
        snprintf(tmp.name, NAMESIZE, "stu%d", arr[i]);
        tmp.math = rand() % 100;
        tmp.chinese = rand() % 100;

        insert(&tree, &tmp);                
    }
#if 0 //find
    int tmpid = 2;
    SCORE *datap;
    datap = find(tree, tmpid);
    if(datap == NULL){
        printf("Can not find id %d!\n" ,tmpid);
    }
    else{
        print_s(datap);
    }
#endif

    draw(tree);

    return 0;
}