数据结构——二叉树

最新推荐文章于 2024-06-26 20:53:01 发布

clusterally

最新推荐文章于 2024-06-26 20:53:01 发布

阅读量171

点赞数

分类专栏：数据结构文章标签：数据结构二叉树

本文链接：https://blog.csdn.net/clusterally/article/details/76685139

版权

数据结构专栏收录该内容

8 篇文章 0 订阅

订阅专栏

头文件：

#ifndef __BTREE_H__
#define __BTREE_H__

#define BLEFT  0    // 表示插入二叉树的左边
#define BRIGHT 1    // 表示插入二叉树的右边

#define TRUE   1
#define FALSE  0

typedef char BTreeData;
// 二叉树的结点
typedef struct _btreeNode
{
    BTreeData data;
    struct _btreeNode *lchild;   // 指向左孩子结点的指针
    struct _btreeNode *rchild;   // 指向右孩子结点的指针
}BTreeNode;

// 二叉树
typedef struct _btree
{
    BTreeNode *root;     // 指向二叉树的根节点
    int  count;          // 记录二叉树结点的个数
}BTree;


typedef void (*Print_BTree)(BTreeNode*);

// 创建一棵二叉树
BTree *Create_BTree();

// pos 走的路径 值类似 110（左右右）  011 （右右左）
// count  代表走的步数
// flag   代表被替换的结点应该插入在新节点的位置，如果是BLEFT 表示插在左边，BRIGHT表示插在右边
int Btree_Insert(BTree *tree, BTreeData data, int pos, int count, int flag);

void Display (BTree* tree, Print_BTree pfunc);

int Delete (BTree *tree, int pos, int count);

int BTree_Height (BTree *);

int BTree_Degree (BTree *);

int BTree_Clear (BTree *);

int BTree_Destroy (BTree **);

// 前序遍历
void pre_order (BTreeNode *node);

void mid_order (BTreeNode *node);

void last_order (BTreeNode *node);



#endif // __BTREE_H__

功能函数：

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

BTree *Create_BTree()
{
    BTree *btree = (BTree*)malloc(sizeof(BTree)/sizeof(char));
    if (btree == NULL)
        return NULL;

    btree->count = 0;
    btree->root  = NULL;


    return btree;
}


int Btree_Insert(BTree *tree, BTreeData data, int pos, int count, int flag)
{
    if (tree == NULL || (flag != BLEFT && flag != BRIGHT))
        return FALSE;

    BTreeNode *node = (BTreeNode*)malloc(sizeof(BTreeNode)/sizeof(char));
    if (node == NULL)
        return FALSE;

    node->data = data;
    node->lchild = NULL;
    node->rchild = NULL;


    // 找插入的位置
    BTreeNode *parent = NULL;
    BTreeNode *current = tree->root; // current 一开始指向根节点，根节点的父节点是空
    int way;   // 保存当前走的位置
    while (count > 0 && current != NULL)
    {
        way = pos & 1;    // 取出当前走的方向
        pos = pos >> 1;   // 移去走过的路线

        // 因为当前位置就是走完以后的位置的父节点
        parent = current;

        if (way == BLEFT)   // 往左走
            current = current->lchild;
        else
            current = current->rchild;

        count--;
    }

    // 把被替换掉的结点插入到新节点下面
    if (flag == BLEFT)
        node->lchild = current;
    else
        node->rchild = current;

    // 把新节点插入到二叉树中,way保存了应该插入在父节点的左边还是右边
    if (parent != NULL)
    {
        if (way == BLEFT)
            parent->lchild = node;
        else
            parent->rchild = node;
    }
    else
    {
        tree->root = node;  // 替换根节点
    }


    tree->count ++;

    return TRUE;
}

void r_display(BTreeNode* node, Print_BTree pfunc,int gap)
{
    int i;
    if (node == NULL)
    {
        for (i = 0; i < gap; i++)
        {
            printf ("-");
        }
        printf ("\n");
        return;
    }

    for (i = 0; i < gap; i++)
    {
        printf ("-");
    }

    // 打印结点
    // printf ("%c\n", node->data);
    pfunc (node);

    if (node->lchild != NULL || node->rchild != NULL)
    {
        // 打印左孩子
        r_display (node->lchild, pfunc, gap+4);

        // 打印右孩子
        r_display (node->rchild, pfunc, gap+4);
    }
}

void Display (BTree* tree, Print_BTree pfunc)
{
    if (tree == NULL)
        return;

    r_display(tree->root, pfunc, 0);
}

void r_delete (BTree *tree, BTreeNode* node)
{
    if (node == NULL || tree == NULL)
        return ;

    // 先删除左孩子
    r_delete (tree, node->lchild);

    // 删除右孩子
    r_delete (tree, node->rchild);

    free (node);

    tree->count --;
}

int Delete (BTree *tree, int pos, int count)
{
    if (tree == NULL)
        return FALSE;

    // 找结点
    BTreeNode* parent  = NULL;
    BTreeNode* current = tree->root;
    int way;
    while (count > 0 && current != NULL)
    {
        way = pos & 1;
        pos = pos >> 1;

        parent = current;

        if (way == BLEFT)
            current = current->lchild;
        else
            current = current->rchild;

        count --;
    }

    if (parent != NULL)
    {
        if (way == BLEFT)
            parent->lchild = NULL;
        else
            parent->rchild = NULL;
    }
    else
    {
        tree->root = NULL;
    }

    // 释放结点
    r_delete (tree, current);

    return TRUE;
}

int r_height (BTreeNode *node)
{
    if (node == NULL)
        return 0;

    int lh = r_height (node->lchild);
    int rh = r_height (node->rchild);

    return (lh > rh ? lh+1 : rh+1);
}

int BTree_Height (BTree *tree)
{
    if (tree == NULL)
        return FALSE;

    int ret = r_height(tree->root);

    return ret;
}

int r_degree (BTreeNode * node)
{
    if (node == NULL)
        return 0;

    int degree = 0;
    if (node->lchild != NULL)
        degree++;
    if (node->rchild != NULL)
        degree++;

    if (degree == 1)
    {
        int ld = r_degree (node->lchild);
        if (ld == 2)
            return 2;

        int rd = r_degree (node->rchild);
        if (rd == 2)
            return 2;
    }

    return degree;
}

int BTree_Degree (BTree *tree)
{
    if (tree == NULL)
        return FALSE;

    int ret = r_degree(tree->root);

    return ret;
}

int BTree_Clear (BTree *tree)
{
    if (tree == NULL)
        return FALSE;

    Delete (tree, 0, 0);  // 删除根节点

    tree->root = NULL;

    return TRUE;
}

int BTree_Destroy (BTree **tree)
{
    if (tree == NULL)
        return FALSE;

    BTree_Clear(*tree);

    free (*tree);
    *tree = NULL;
    return TRUE;
}


void pre_order (BTreeNode *node)
{
    if (node == NULL)
        return;

    printf ("%4c", node->data);
    pre_order (node->lchild);
    pre_order (node->rchild);
}

void mid_order (BTreeNode *node)
{
    if (node == NULL)
        return;

    mid_order (node->lchild);
    printf ("%4c", node->data);
    mid_order (node->rchild);
}


void last_order (BTreeNode *node)
{
    if (node == NULL)
        return;

    last_order (node->lchild);  
    last_order (node->rchild);
    printf ("%4c", node->data);
}

main函数：

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

void printA(BTreeNode *node)
{
    printf ("%c\n", node->data);
}


int main()
{
    BTree *btree = Create_BTree();
    if (btree == NULL)
    {
        printf ("创建失败\n");
    }
    else
    {
        printf ("创建成功\n");
    }


    Btree_Insert(btree, 'A', 0, 0, 0);
    Btree_Insert(btree, 'B', 0, 1, 0);
    Btree_Insert(btree, 'C', 1, 1, 0);
    Btree_Insert(btree, 'D', 0, 2, 0);
    Btree_Insert(btree, 'E', 2, 2, 0);
    Btree_Insert(btree, 'F', 0, 3, 0);
    Btree_Insert(btree, 'G', 4, 3, 0);
    Btree_Insert(btree, 'H', 3, 2, 0);

    Display(btree, printA);

    printf ("前序遍历：\n");
    pre_order (btree->root);

    printf ("\n");

    printf ("中序遍历：\n");
    mid_order (btree->root);

    printf ("\n");
    printf ("后序遍历：\n");
    last_order (btree->root);
    printf ("\n");

#if 0
    Delete(btree, 0, 1);
    printf ("删除后--------------\n");
    Display(btree, printA);

    printf ("高度： %d\n", BTree_Height(btree));

    printf ("度 ： %d\n", BTree_Degree(btree));

    printf ("清空后--------------\n");
    BTree_Clear(btree);

    Display(btree, printA);

    BTree_Destroy(&btree);
    //btree = NULL;
#endif  
    return 0;
}