二叉树的实现

头文件

//
//  tree.h
//  tree
//
//  Created by bikang on 16/9/26.
//  Copyright (c) 2016年 bikang. All rights reserved.
//

#ifndef __tree__tree__
#define __tree__tree__
#include <stdlib.h>
//#include <stdio.h>

typedef struct BitTreeNode_{
    void *data;
    struct BitTreeNode_ *left;
    struct BitTreeNode_ *right;
}BitTreeNode;

typedef struct BitTree_{
    int size;
    int (*compare)(const void *k1,const void *k2);
    void (*destroy)(void *data);
    BitTreeNode *root;
}BitTree;

void bitree_init(BitTree *tree,void (*destroy)(void *data));
void bitree_destroy(BitTree *tree);
//左边插入数据
int bitree_ins_left(BitTree *tree,BitTreeNode *node,const void*data);
//右边插入数据
int bitree_ins_right(BitTree *tree,BitTreeNode *node,const void*data);
//删除左树
void bitree_rm_left(BitTree *tree,BitTreeNode *node);
//删除右树
void bitree_rm_right(BitTree *tree,BitTreeNode *node);
//树合并,以data为root节点
int bitree_merge(BitTree *merge,BitTree *left,BitTree *right,const void *data);

#define bitree_size(tree) ((tree)->size)
#define bitree_root(tree) ((tree)->root)
#define bitree_is_eob(node) ((node) == NULL)

#define bitree_is_leaf(node) ((node)->left == NULL && (node)->right == NULL)
#define bitree_is_eob(node) ((node)->data)
#define bitree_left(node) ((node)->left)
#define bitree_right(node) ((node)->right)

#endif /* defined(__tree__tree__) */

实现

//
//  tree.c
//  tree
//
//  Created by bikang on 16/9/26.
//  Copyright (c) 2016年 bikang. All rights reserved.
//

#include "tree.h"
#include <stdlib.h>
#include <string.h>

void bitree_init(BitTree *tree,void (*destroy)(void *data)){
    tree->size = 0;
    tree->destroy = destroy;
    tree->root = NULL;
    return;
}
void bitree_destroy(BitTree *tree){
    bitree_rm_left(tree, NULL);
    memset(tree, 0, sizeof(BitTree));
    return;
}
//在node的左边插入数据,确定在什么地方插入数据
int bitree_ins_left(BitTree *tree,BitTreeNode *node,const void*data){
    BitTreeNode *new_node,**position;
    if(node == NULL){
        if(bitree_size(tree) > 0) return -1;
        position = &(tree->root);
    }else{
        if(bitree_left(node) != NULL) return -1;
        position = &node->left;
    }

    if((new_node = (BitTreeNode *)malloc(sizeof(BitTreeNode))) == NULL)return -1;
    new_node->data = (void*)data;
    new_node->left = NULL;
    new_node->right = NULL;
    *position = new_node;
    tree->size++;
    return 0;
}
int bitree_ins_right(BitTree *tree,BitTreeNode *node,const void*data){
    BitTreeNode *new_node,**position;
    if(node == NULL){
        if(bitree_size(tree) > 0) return -1;
        position = &(tree->root);
    }else{
        if(bitree_right(node) != NULL) return -1;
        position = &node->right;
    }

    if((new_node = (BitTreeNode *)malloc(sizeof(BitTreeNode))) == NULL)return -1;
    new_node->data = (void*)data;
    new_node->left = NULL;
    new_node->right = NULL;
    *position = new_node;
    tree->size++;
    return 0;
}
//删除元素node的左边的树，如果node为空，删除整个树
void bitree_rm_left(BitTree *tree,BitTreeNode *node){
    BitTreeNode **position;
    if(bitree_size(tree) == 0) return;

    if(node == NULL){
        position = &tree->root;
    }else{
        position = &node->left;
    }
    if(*position != NULL){
        bitree_rm_left(tree,*position);
        bitree_rm_right(tree,*position);
        if(tree->destroy != NULL){
            tree->destroy((*position)->data);
        }
        free(*position);
        *position = NULL;
        tree->size--;
    }
    return;
}
void bitree_rm_right(BitTree *tree,BitTreeNode *node){
    BitTreeNode **position;
    if(bitree_size(tree) == 0) return;

    if(node == NULL){
        position = &tree->root;
    }else{
        position = &node->right;
    }
    if(*position != NULL){
        bitree_rm_left(tree,*position);
        bitree_rm_right(tree,*position);
        if(tree->destroy != NULL){
            tree->destroy((*position)->data);
        }
        free(*position);
        *position = NULL;
        tree->size--;
    }
    return;
}
//树的合并
int bitree_merge(BitTree *merge,BitTree *left,BitTree *right,const void *data){
    bitree_init(merge,left->destroy);
    if(bitree_ins_left(merge, NULL, data) != 0){
        bitree_destroy(merge);
        return -1;
    }
    bitree_root(merge)->left = bitree_root(left);
    bitree_root(merge)->right = bitree_root(right);
    merge->size = left->size+ right->size;

    //合并后禁止通过其他方式访问
    left->root = NULL;
    left->size = 0;
    right->root = NULL;
    right->size = 0;

    return 0;
}

测试代码

//
//  main.c
//  tree
//
//  Created by bikang on 16/9/26.
//  Copyright (c) 2016年 bikang. All rights reserved.
//
#include <stdlib.h>
#include <stdio.h>
#include "tree.h"

void ttree();

int main(int argc, const char * argv[]) {
    printf("test tree:\n");
    ttree();
    return 0;
}
void ttree(){
    BitTree *tree = (BitTree*)malloc(sizeof(BitTree));
    bitree_init(tree, NULL);

    //插入
    int i1 = 1;int *pi1 = &i1;
    int i2 = 2;int *pi2 = &i2;
    int i3 = 3;int *pi3 = &i3;
    int i4 = 4;int *pi4 = &i4;
    int i5 = 5;int *pi5 = &i5;
    bitree_ins_left(tree, NULL, pi1);
    bitree_ins_left(tree, bitree_root(tree), pi2);
    bitree_ins_right(tree,bitree_root(tree), pi3);
    bitree_ins_left(tree, bitree_root(tree)->left, pi4);
    bitree_ins_right(tree, bitree_root(tree)->right, pi5);
    printf("t1->size=%d\n",bitree_size(tree));
    //删除
    bitree_rm_left(tree,bitree_root(tree)->left);
    bitree_rm_right(tree,bitree_root(tree)->right);
    printf("t1->size=%d\n",bitree_size(tree));

    //合并
    BitTree *tree2 = (BitTree*)malloc(sizeof(BitTree));
    bitree_init(tree2, NULL);
    int i7 = 1;int *pi7 = &i7;
    int i8 = 2;int *pi8 = &i8;
    bitree_ins_left(tree2, NULL, pi7);

    BitTree *merge = (BitTree*)malloc(sizeof(BitTree));
    bitree_merge(merge, tree, tree2, pi8);
    printf("t1->size=%d\n",bitree_size(merge));

    bitree_destroy(merge);
    //摧毁
    //bitree_destroy(tree);

}