【数据结构】链式二叉树

二叉树头文件

//@　author　成鹏致远
//@　net http://infodown.tap.cn
//@　qq 552158509
//@ blog　lcw.cnblogs.com

#ifndef __BINTREE_H
#define __BINTREE_H

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>


typedef char datatype_tree;

typedef struct tree
{
    datatype_tree data_t;
    struct tree *lchild,*rchild;
}bin_tree,*bin_ptree;

extern void bintree_create(bin_ptree *ptree);//create a binary tree
extern void pre_order(bin_ptree ptree);//iterate voer a binary tree,begin with root
extern void in_order(bin_ptree ptree);//iterate over a binary tree,begin with left child
extern void post_order(bin_ptree proot);//iterate over a binary tree,begin with right child
extern void level_order(bin_ptree proot);
extern void travel(char *str, void(*pfun)(bin_ptree),bin_ptree proot);

#endif

 链表头文件

//@　author　成鹏致远
//@　net http://infodown.tap.cn
//@　qq 552158509
//@ blog　lcw.cnblogs.com

#ifndef __LINKQUEUE_H
#define __LINKQUEUE_H

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include "bin_tree.h"
typedef bin_ptree datatype;//存储二叉树指针

typedef struct node
{
    datatype data;
    struct node *next;
}link_node,*link_pnode;

typedef struct queue
{
    link_pnode front,rear;
}link_queue,*link_pqueue;


extern void linkqueue_init(link_pqueue *pqueue);//初始化链表队列
extern bool is_empty(link_pqueue pqueue);
extern bool in_linkqueue(link_pqueue pqueue, datatype data);//链表队列入队
extern bool out_linkqueue(link_pqueue pqueue, datatype *result);//链表队列出队
//extern void linkqueue_show(link_pqueue pqueue);//显示链表队列

#endif

二叉树文件 

//@　author　成鹏致远
//@　net http://infodown.tap.cn
//@　qq 552158509
//@ blog　lcw.cnblogs.com

#include "bin_tree.h"
#include "linkqueue.h"

void bintree_create(bin_ptree *proot)//create a binary tree
{
    datatype_tree ch;

    scanf("%c",&ch);
    if('#' != ch)//create
    {
        *proot = (bin_ptree)malloc(sizeof(bin_tree));
        if(NULL == *proot)
        {
            perror("malloc");
            exit(1);
        }
        (*proot)->data_t = ch;
        bintree_create(&(*proot)->lchild);
        bintree_create(&(*proot)->rchild);
    }
    else
        *proot = NULL;
}

void pre_order(bin_ptree proot)//iterate over a binary tree,begin with root
{
    if(NULL != proot)
    {
        printf("%c",proot->data_t);
        pre_order(proot->lchild);
        pre_order(proot->rchild);
    }
}

void in_order(bin_ptree proot)//iterate over a binary tree,begin with left child
{
    if(NULL != proot)
    {
        in_order(proot->lchild);
        printf("%c",proot->data_t);
        in_order(proot->rchild);
    }

}

void post_order(bin_ptree proot)//iterate over a binary tree,begin with right child
{
    if(NULL != proot)
    {
        post_order(proot->lchild);
        post_order(proot->rchild);
        printf("%c",proot->data_t);
    }

}


void level_order(bin_ptree proot)//按层遍历
{
    //需要借助队列
    link_pqueue pqueue;

    linkqueue_init(&pqueue);//初始化队列

    //1.proot != NULL,打印proot->data_t,proot == NULL,出队,队列空结束
    //2.proot->lchild != NULL,则入队
    //3.proot->rchild != NULL,则入队
    //4.队列不为空,出队,回到1,为空结束

    while(NULL != proot)//proot不为空,则一值循环
    {
        printf("%c",proot->data_t);

        if(NULL != proot->lchild)
            in_linkqueue(pqueue,proot->lchild);
        if(NULL != proot->rchild)
            in_linkqueue(pqueue,proot->rchild);
        if(is_empty(pqueue))//队列为空则结束
            break;
        else//不为空则出队
            out_linkqueue(pqueue,&proot);
    }
}

void travel(char *str, void(*pfun)(bin_ptree),bin_ptree proot)//将proot传给pfun函数处理
{
    printf("%s	",str);
    pfun(proot);//将proot传给pfun函数处理
    printf("
");
}

链表文件 

//@　author　成鹏致远
//@　net http://infodown.tap.cn
//@　qq 552158509
//@ blog　lcw.cnblogs.com

//输入数字入栈
//输入字符出栈

#include "linkqueue.h"

void linkqueue_init(link_pqueue *pqueue)//初始化链表队列
{
    link_pnode pnode;

    *pqueue = (link_pqueue)malloc(sizeof(link_queue));//分配链表
    if(NULL == *pqueue)
    {
        perror("malloc");
        exit(1);
    }

    pnode = (link_pnode)malloc(sizeof(link_node));//分配节点
    if(NULL == pnode)
    {
        perror("malloc");
        exit(1);
    }

    pnode->next = NULL;//初始化pnode
    //初始化pqueue
    (*pqueue)->front = pnode;
    (*pqueue)->rear = pnode;
}

bool is_empty(link_pqueue pqueue)
{
    if(pqueue->front == pqueue->rear)
        return true;
    else
        return false;
}

bool in_linkqueue(link_pqueue pqueue, datatype data)//链表队列入队
{
    link_pnode new;
    new = (link_pnode)malloc(sizeof(link_node));//分配结点
    if(NULL == new)
        return false;
    else
    {
        new->data = data;

        //将new结点插入到队列的末尾
        new->next = pqueue->rear->next;//将尾结点的next赋值给new->next
        pqueue->rear->next = new;//尾结点指向new,即new成为新的尾结点
        pqueue->rear = new;//尾结点指向new

        return true;
    }
}

bool out_linkqueue(link_pqueue pqueue, datatype *result)//链表队列出队
{
    link_pnode pnode;//临时指针,指向要出队的结点

    if(is_empty(pqueue))
        return false;
    else
    {
        pnode = pqueue->front;//头结点,将出队
        pqueue->front = pnode->next;//头指针后移
        //注意头指针指向的是头结点,第一个结点是pqueue->front,即出队结点
        *result = pqueue->front->data;
        free(pnode);//释放结点空间

        return true;
    }
}

#if 0    //链表中用不到

void linkqueue_show(link_pqueue pqueue)//显示链表队列
{
    link_pnode pnode;//负责遍历过程中的节点移动

    pnode = pqueue->front->next;//指向第一个结点
    while(NULL != pnode)
    {
        printf("%d	",pnode->data);
        pnode = pnode->next;
    }
    printf("
");
}
#endif

 主文件

//@　author　成鹏致远
//@　net http://infodown.tap.cn
//@　qq 552158509
//@ blog　lcw.cnblogs.com

#include "bin_tree.h"

int main()
{
    bin_ptree proot = NULL;

    printf("Pls input data to create a binary tree 
such as ABC##DE#G##F###
");
    bintree_create(&proot);//create binary tree

    travel("Pre_order:",pre_order,proot);
    travel("in_order:",in_order,proot);
    travel("Post_order:",post_order,proot);
    travel("level_order:",level_order,proot);
#if 0    
    pre_order(proot);//iterate,begin with root
    printf("
");

    in_order(proot);//iterate,begin with left child
    printf("
");

    post_order(proot);//iterate,begin with right child
    printf("
");

    level_order(proot);
    printf("
");
#endif
    return 0;
}

Makefile文件

binary_tree:main.c bin_tree.c linkqueue.c
        gcc -o $@ $^
clean:
        $(RM) binary_tree .*.sw?