二叉树操作实现-优快云博客

本文介绍了一个二叉树数据结构的实现方法，包括节点初始化、添加节点、遍历等核心功能，并通过具体代码示例展示了如何使用这些功能来构建和操作二叉树。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

btree/btree.c

#include <stdio.h>
#include "btree.h"


static void bnode_init(struct btree_info *info,
        struct bnode_info *bnode)
{
    bnode->parent = NULL;
    bnode->lchild = NULL;
    bnode->rchild = NULL;
}

static void btree_add(struct btree_info *info,
        struct bnode_info *bnode,
        int (*cmp)(struct bnode_info *,
            struct bnode_info *))

{
    bnode_init(info, bnode);

    struct bnode_info *cur = info->root;
    struct bnode_info **pparent = &info->root;

    while (*pparent) {
        if (cmp(bnode, cur) < 0) {
            pparent = &cur->lchild;
        } else {
            pparent = &cur->rchild;
        }
        //??..?版.?ョ.??ur?..?..涓..
        if (*pparent) {
            cur = *pparent;
        }
    }

    *pparent = bnode;
    bnode->parent = cur;
}

//=============preorder=============
static void __btree_preorder(struct btree_info *info,
        struct bnode_info *cur,
        void (*todo)(struct btree_info *,
            struct bnode_info *))
{
    if (cur) {
        todo(info, cur);
        __btree_preorder(info, cur->lchild, todo);
        __btree_preorder(info, cur->rchild, todo);
    }
}

static void btree_preorder(struct btree_info *info,
        void (*todo)(struct btree_info *,
            struct bnode_info *))
{
    __btree_preorder(info, info->root, todo);
}

//=============inorder=============
static void __btree_inorder(struct btree_info *info,
        struct bnode_info *cur,
        void (*todo)(struct btree_info *,
            struct bnode_info *))
{
    if (cur) {
        __btree_inorder(info, cur->lchild, todo);
        todo(info, cur);
        __btree_inorder(info, cur->rchild, todo);
    }
}

static void btree_inorder(struct btree_info *info,
        void (*todo)(struct btree_info *,
            struct bnode_info *))
{
    __btree_inorder(info, info->root, todo);
}

//=============postorder=============
static void __btree_postorder(struct btree_info *info,
        struct bnode_info *cur,
        void (*todo)(struct btree_info *,
            struct bnode_info *))
{
    if (cur) {
        __btree_postorder(info, cur->lchild, todo);
        __btree_postorder(info, cur->rchild, todo);
        todo(info, cur);
    }
}

static void btree_postorder(struct btree_info *info,
        void (*todo)(struct btree_info *,
            struct bnode_info *))
{
    __btree_postorder(info, info->root, todo);
    }

void btree_init(struct btree_info *info)
{
    info->root = NULL;
    info->bnode_init = bnode_init;
    info->add = btree_add;
    info->preorder = btree_preorder;
    info->inorder = btree_inorder;
    info->postorder = btree_postorder;
/*        info->levelorder = btree_levelorder;*/
}

void btree_destroy(struct btree_info *info,
        void (*mfree)(struct btree_info *,
            struct bnode_info *))
{
    if (mfree) {
        btree_postorder(info, mfree);
    } else {
        btree_postorder(info, bnode_init);
    }
}

btree/Makefile

SRCS := btree.c
SUBDIR := 

$(BUILT_IN): $(SRCS:.c=.o) $(SUBDIR)
    $(LD) $(LDFLAGS) -r -o $@ $(SRCS:.c=.o) $(SUBDIR:=/$(BUILT_IN))

$(SUBDIR):
    $(MAKE) -C $@

$(SRCS:.c=.o):
    $(CC) $(CFLAGS) -c $<

$(DEP): $(SRCS)
    $(CC) $(CFLAGS) -MM $(SRCS) >$@
    sed -i "s/: / $@: /g" $@

sinclude $(DEP)

.PHONY: clean $(SUBDIR)

clean:
    for dir in $(SUBDIR); do \
        $(MAKE) -C $$dir clean; \
    done
    $(RM) $(SRCS:.c=.o) $(BUILT_IN) $(DEP)
~

include/btree.h

struct bnode_info {
    struct bnode_info *parent;
    struct bnode_info *lchild;
    struct bnode_info *rchild;
};

struct btree_info {
    struct bnode_info *root;
    void (*bnode_init)(struct btree_info *,
            struct bnode_info *); 
    void (*add)(struct btree_info *,
            struct bnode_info *bnode,
            int (*cmp)(struct bnode_info *,
                struct bnode_info *));
    void (*preorder)(struct btree_info *,
            void (*)(struct btree_info *,
                struct bnode_info *));
    void (*inorder)(struct btree_info *,
            void (*)(struct btree_info *,
                struct bnode_info *));
    void (*postorder)(struct btree_info *,
            void (*)(struct btree_info *,
                struct bnode_info *));
    void (*levelorder)(struct btree_info *,
            void (*)(struct btree_info *,
                struct bnode_info *));
    void (*del)(struct btree_info *,
            struct bnode_info *); 
    struct bnode_info *(*search)(struct btree_info *,
            struct bnode_info *key,
            int (*cmp)(struct bnode_info *,
                struct bnode_info *));
};

include/list.h

struct node_info {
    struct node_info *prev;
    struct node_info *next;
    char priv[];
};

struct list_info {
    struct node_info *head;
    void (*add)(struct list_info *,
            const void *data_entry,
            size_t data_size);
    void (*add_tail)(struct list_info *,
            const void *data_entry,
            size_t data_size);
    void (*del)(struct list_info *,
            struct node_info *,
            size_t data_size);
};

#define list_for_each(cur, head) \
    for (cur = (head)->next; \
        (cur) != (head); \
struct node_info {
    struct node_info *prev;
    struct node_info *next;
    char priv[];
};

struct list_info {
    struct node_info *head;
    void (*add)(struct list_info *,
            const void *data_entry,
            size_t data_size);
    void (*add_tail)(struct list_info *,
            const void *data_entry,
            size_t data_size);
    void (*del)(struct list_info *,
            struct node_info *,
            size_t data_size);
};

#define list_for_each(cur, head) \
    for (cur = (head)->next; \
        (cur) != (head); \
        cur = (cur)->next)

#define list_for_each_safe(cur, tmp, head) \
    for (cur = (head)->next, tmp = (cur)->next; \
        (cur) != (head); \
        cur = tmp, tmp = (tmp)->next)

#define ENTRY(node, type) ((type*)(node->priv))

void list_init(struct list_info*);
void list_destroy(struct list_info*);

cur = (cur)->next)#define list_for_each_safe(cur, tmp, head) \ for (cur = (head)->next, tmp = (cur)->next; \ (cur) != (head); \ cur = tmp, tmp = (tmp)->next)#define ENTRY(node, type) ((type*)(node->priv))void list_init(struct list_info*);void list_destroy(struct list_info*);

include/queue.h

#include "list.h"

struct queue_info {
    struct list_info list;
    void (*push)(struct queue_info *,
            const void *data_entry,
            size_t data_size);
    int (*pop)(struct queue_info *,
            void *data_entry,
            size_t data_size);
    int (*top)(struct queue_info *,
            void *data_entry,
            size_t data_size);
    int (*isempty)(struct queue_info *); 
};

void queue_init(struct queue_info *); 
void queue_destroy(struct queue_info *);

main/test.c

#include <stdio.h>
#include <stdlib.h>
#include "btree.h"

struct node_info {
    ssize_t data;
    struct bnode_info bnode;
};

static int cmp(struct bnode_info *a, struct bnode_info *b)
{
    struct node_info *pa = container_of(a, struct node_info, bnode);
    struct node_info *pb = container_of(b, struct node_info, bnode);

    return pa->data - pb->data;
}

static void print_node(struct btree_info *info,
        struct bnode_info *bnode)
{
    struct node_info *ptr = container_of(bnode, struct node_info, bnode);
    printf("%ld ", ptr->data);
}

static void m_free(struct btree_info *info,
        struct bnode_info *bnode)
{
    info->bnode_init(info, bnode);
    free(container_of(bnode, struct node_info, bnode));
}

int main()
{
    struct btree_info btree;
    btree_init(&btree);

    struct node_info *cur = NULL;

    ssize_t s[] = {10, 15, 2, 6, 7, 3, 8, 5, 2, 0, -2, 6};

    size_t i = 0;
    for (i = 0; i < sizeof(s) / sizeof(ssize_t); ++i) {
        cur = (struct node_info *)malloc(sizeof(struct node_info));
        cur->data = s[i];
        btree.add(&btree, &cur->bnode, cmp);
    }


    printf("preorder\n");
    btree.preorder(&btree, print_node);
    printf("\n");
    printf("inorder\n");
    btree.inorder(&btree, print_node);
    printf("\n");
    printf("postorder\n");
    btree.postorder(&btree, print_node);
    printf("\n");

/*        btree_destroy(&btree, NULL);*/
    btree_destroy(&btree, m_free);

    return 0;
}

main/Makefile

SRCS := test.c
SUBDIR := 

$(BUILT_IN): $(SRCS:.c=.o) $(SUBDIR)
    $(LD) $(LDFLAGS) -r -o $@ $(SRCS:.c=.o) $(SUBDIR:=/$(BUILT_IN))

$(SUBDIR):
    $(MAKE) -C $@

$(SRCS:.c=.o):
    $(CC) $(CFLAGS) -c $<

$(DEP): $(SRCS)
    $(CC) $(CFLAGS) -MM $(SRCS) >$@
    sed -i "s/: / $@: /g" $@

sinclude $(DEP)

.PHONY: clean $(SUBDIR)

clean:
    for dir in $(SUBDIR); do \
        $(MAKE) -C $$dir clean; \
    done
    $(RM) $(SRCS:.c=.o) $(BUILT_IN) $(DEP)

queue/list.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "list.h"


static void __list_add(struct node_info *prev,
        struct node_info *next,
        const void *data_entry,
        size_t data_size)
{
    struct node_info *node = (struct node_info *)malloc(sizeof(struct node_info) + data_size);
    memcpy(node->priv, data_entry, data_size);

    node->prev = prev;
    node->next = next;
    prev->next = node;
    next->prev = node;
}

static void list_add(struct list_info *info,
        const void *data_entry, size_t data_size)
{
    __list_add(info->head, info->head->next,
            data_entry, data_size);
}

static void list_add_tail(struct list_info *info,
        const void *data_entry, size_t data_size)
{
    __list_add(info->head->prev, info->head,
            data_entry, data_size);
}

static void list_del(struct list_info *info,
        struct node_info *node,
        size_t data_size)
{
    node->prev->next = node->next;
    node->next->prev = node->prev;
    node->prev = node;
    node->next = node;

    if (data_size) {
        memset(node->priv, 0, data_size);
    }
    free(node);
}

void list_init(struct list_info *info)
{
    info->head = (struct node_info *)malloc(sizeof(struct node_info));
    info->head->prev = info->head;
    info->head->next = info->head;

    info->add = list_add;
    info->add_tail = list_add_tail;
    info->del = list_del;
}

void list_destroy(struct list_info *info)
{
    struct node_info *cur = info->head->next;

    for (; cur != info->head; cur = info->head->next) {
        list_del(info, cur, 0);
    }

    free(info->head);
}

queue/queue.c

#include <stdio.h>
#include <string.h>
#include "queue.h"


static void queue_push(struct queue_info *info,
        const void *data_entry,
        size_t data_size)
{
    info->list.add_tail(&info->list, data_entry, data_size);
}

static int queue_isempty(struct queue_info *info)
{
    return info->list.head->next == info->list.head;
}

static int queue_top(struct queue_info *info,
        void *data_entry,
        size_t data_size)
{
    if (queue_isempty(info)) {
        return -1; 
    }   

    if (data_entry) {
        memcpy(data_entry, info->list.head->next->priv, data_size);
    }   
    return 0;
}

static int queue_pop(struct queue_info *info,
        void *data_entry,
        size_t data_size)
{
    if (queue_top(info, data_entry, data_size) < 0) {
        return -1; 
    }

    //?..绗.?涓..?..?
    info->list.del(&info->list, info->list.head->next, data_size);
    return 0;
}

void queue_init(struct queue_info *info)
{
    list_init(&info->list);
    info->push = queue_push;
    info->pop = queue_pop;
    info->top = queue_top;
    info->isempty = queue_isempty;
}

void queue_destroy(struct queue_info *info)
{
    list_destroy(&info->list);
}

queue/Makefile

SRCS := list.c queue.c
SUBDIR := 

$(BUILT_IN): $(SRCS:.c=.o) $(SUBDIR)
    $(LD) $(LDFLAGS) -r -o $@ $(SRCS:.c=.o) $(SUBDIR:=/$(BUILT_IN))

$(SUBDIR):
    $(MAKE) -C $@

$(SRCS:.c=.o):
    $(CC) $(CFLAGS) -c $<

$(DEP): $(SRCS)
    $(CC) $(CFLAGS) -MM $(SRCS) >$@
    sed -i "s/: / $@: /g" $@

sinclude $(DEP)

.PHONY: clean $(SUBDIR)

clean:
    for dir in $(SUBDIR); do \
        $(MAKE) -C $$dir clean; \
    done
    $(RM) $(SRCS:.c=.o) $(BUILT_IN) $(DEP)

Makefile

TGT := hello
SUBDIR := \
      btree \
      queue \
      main

export TOPDIR := $(shell pwd)
export CFLAGS := -O2 -I$(TOPDIR)/include
export LDFLAGS :=  

export CROSS_COMPILER_PREFIX :=  
export CC := $(CROSS_COMPILER_PREFIX)gcc
export LD := $(CROSS_COMPILER_PREFIX)ld

export BUILT_IN := built_in.o
export DEP = dep 
export MAKE := make

all: $(TGT)
    ./$^

$(TGT): $(SUBDIR)
    $(CC) $(LDFLAGS) -o $@ $(^:=/$(BUILT_IN))

$(SUBDIR):
    $(MAKE) -C $@

.PHONY: $(SUBDIR) clean all 

clean:
    for dir in $(SUBDIR); do \
        $(MAKE) -C $$dir clean; \
    done
    $(RM) $(TGT)

08btree