二叉树的 创建

于 2017-02-17 13:23:23 发布
阅读量349 收藏
点赞数
分类专栏： 数据结构 文章标签： 二叉树 递归 结构

指路法定位结点

这里写图片描述

指路法通过根结点与目标结点的相对位置进行定位
指路法可以避开二叉树递归的性质“线性”定位

这里写图片描述

二叉树最重要的操作

定位节点：
这里写图片描述

二叉树结构的代码实现

//二叉树 头文件 BTree.h
#ifndef _BTREE_H_
#define _BTREE_H_

#define BT_LEFT 0
#define BT_RIGHT 1

typedef void BTree;
typedef unsigned long long BTPos;
//该类型定义插入的节点在二叉树中的位置，从数值的最低位（最右侧）开始，1表示右孩子，0表示左孩子 

typedef struct _tag_BTreeNode BTreeNode;
struct _tag_BTreeNode
{
    BTreeNode* left;
    BTreeNode* right;
};

typedef void (BTree_Printf)(BTreeNode*);

BTree* BTree_Create();
void BTree_Destroy(BTree* tree);
void BTree_Clear(BTree* tree);
int BTree_Insert(BTree* tree, BTreeNode* node, BTPos pos, int count, int flag);
BTreeNode* BTree_Delete(BTree* tree, BTPos pos, int count);
BTreeNode* BTree_Get(BTree* tree, BTPos pos, int count);
BTreeNode* BTree_Root(BTree* tree);
int BTree_Height(BTree* tree);
int BTree_Count(BTree* tree);
int BTree_Degree(BTree* tree);
void BTree_Display(BTree* tree, BTree_Printf* pFunc, int gap, char div);

#endif
//二叉树 源文件 BTree.c
#include <stdio.h>
#include <malloc.h>
#include "BTree.h"

typedef struct _tag_BTree TBTree;
struct _tag_BTree
{
    int count;
    BTreeNode* root;
};

static void recursive_display(BTreeNode* node, BTree_Printf* pFunc, int format, int gap, char div) 
// O(n) 采用递归打印节点数据，pFunc打印函数，fomat，gap，div 定义了缩进格式 
{
    int i = 0;

    if( (node != NULL) && (pFunc != NULL) )
    {
        for(i=0; i<format; i++)
        {
            printf("%c", div);
        }

        pFunc(node);

        printf("\n");

        if( (node->left != NULL) || (node->right != NULL) )
        {
            recursive_display(node->left, pFunc, format + gap, gap, div);
            recursive_display(node->right, pFunc, format + gap, gap, div);
        }
    }
    else //如果左孩子节点为NULL，用来区分左右孩子节点 
    {
        for(i=0; i<format; i++)
        {
            printf("%c", div);
        }
        printf("\n");
    }
}

static int recursive_count(BTreeNode* root) // O(n) 递归计算二叉树的节点总数 
{
    int ret = 0;

    if( root != NULL )
    {
        ret = recursive_count(root->left) + 1 + recursive_count(root->right);
    }
    return ret;
}

static int recursive_height(BTreeNode* root) // O(n) 递归计算二叉树的高度 
{
    int ret = 0;

    if( root != NULL )
    {
        int lh = recursive_height(root->left);
        int rh = recursive_height(root->right);

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

static int recursive_degree(BTreeNode* root) // O(n) 递归计算二叉树的度 
{
    int ret = 0;   
    if( root != NULL )
    {
        if( root->left != NULL )
        {
            ret++;
        }      
        if( root->right != NULL )
        {
            ret++;
        }

        if( ret == 1 ) //如果ret=2，则度为2，如果为1，还要看其他的节点 
        {
            int ld = recursive_degree(root->left);
            int rd = recursive_degree(root->right);

            if( ret < ld )
            {
                ret = ld;
            }           
            if( ret < rd )
            {
                ret = rd;
            }
        }
    }   
    return ret;
}

BTree* BTree_Create() // O(1) 创建二叉树 
{
    TBTree* ret = (TBTree*)malloc(sizeof(TBTree));

    if( ret != NULL )
    {
        ret->count = 0;
        ret->root = NULL;
    }  
    return ret;
}

void BTree_Destroy(BTree* tree) // O(1) 销毁二叉树 
{
    free(tree);
}

void BTree_Clear(BTree* tree) // O(1) 清空二叉树 
{
    TBTree* btree = (TBTree*)tree;

    if( btree != NULL )
    {
        btree->count = 0;
        btree->root = NULL;
    }
}

int BTree_Insert(BTree* tree, BTreeNode* node, BTPos pos, int count, int flag) // O(n) 
//向二叉树中插入一个节点，tree为二叉树指针，node为插入节点指针
//pos表明了插入的位置，count是插入函数遍历经过的二叉树的节点数目
//如果插入的位置已有节点，则由flag决定旧的节点是作为新节点的左孩子还是右孩子 
{
    TBTree* btree = (TBTree*)tree;
    int ret = (btree != NULL) && (node != NULL) && ((flag == BT_LEFT) || (flag == BT_RIGHT));
    int bit = 0;

    if( ret )
    {
        BTreeNode* parent = NULL;
        BTreeNode* current = btree->root;

        node->left = NULL;
        node->right = NULL;

        while( (count > 0) && (current != NULL) )
        {
            bit = pos & 1;
            pos = pos >> 1;

            parent = current;

            if( bit == BT_LEFT )
            {
                current = current->left;
            }
            else if( bit == BT_RIGHT )
            {
                current = current->right;
            }           
            count--;
        }

        if( flag == BT_LEFT )
        {
            node->left = current;
        }
        else if( flag == BT_RIGHT )
        {
            node->right = current;
        }

        if( parent != NULL )
        {
            if( bit == BT_LEFT )
            {
                parent->left = node;
            }
            else if( bit == BT_RIGHT )
            {
                parent->right = node;
            }
        }
        else
        {
            btree->root = node;
        }        
        btree->count++;
    }  
    return ret;
}

BTreeNode* BTree_Delete(BTree* tree, BTPos pos, int count) // O(n)
//删除一个二叉树的节点 
{
    TBTree* btree = (TBTree*)tree;
    BTreeNode* ret = NULL; 
    int bit = 0;

    if( btree != NULL )
    {
        BTreeNode* parent = NULL;
        BTreeNode* current = btree->root;

        while( (count > 0) && (current != NULL) )
        {
            bit = pos & 1;
            pos = pos >> 1;

            parent = current;

            if( bit == BT_LEFT )
            {
                current = current->left;
            }
            else if( bit == BT_RIGHT )
            {
                current = current->right;
            }           
            count--;
        }       
        if( parent != NULL ) //把要删除的节点的父节点的相应指针置为NULL 
        {
            if( bit == BT_LEFT )
            {
                parent->left = NULL;
            }
            else if( bit == BT_RIGHT )
            {
                parent->right = NULL;
            }
        }
        else
        {
            btree->root = NULL;
        }

        ret = current;
        //减去删去的的节点数目       
        btree->count = btree->count - recursive_count(ret);
    }  
    return ret;
}

BTreeNode* BTree_Get(BTree* tree, BTPos pos, int count) // O(n)
//获取指定的二叉树的某个节点 
{
    TBTree* btree = (TBTree*)tree;
    BTreeNode* ret = NULL; 
    int bit = 0;

    if( btree != NULL )
    {
        BTreeNode* current = btree->root;

        while( (count > 0) && (current != NULL) )
        {
            bit = pos & 1;
            pos = pos >> 1;

            if( bit == BT_LEFT )
            {
                current = current->left;
            }
            else if( bit == BT_RIGHT )
            {
                current = current->right;
            }

            count--;
        }

        ret = current;
    }
    return ret;
}

BTreeNode* BTree_Root(BTree* tree) // O(1) 获取二叉树的根节点 
{
    TBTree* btree = (TBTree*)tree;
    BTreeNode* ret = NULL;

    if( btree != NULL )
    {
        ret = btree->root;
    }   
    return ret;
}

int BTree_Height(BTree* tree) // O(n) 递归获取二叉树的高度或深度 
{
    TBTree* btree = (TBTree*)tree;
    int ret = 0;

    if( btree != NULL )
    {
        ret = recursive_height(btree->root);
    }   
    return ret;
}

int BTree_Count(BTree* tree) // O(1) 获取二叉树的节点数目 
{
    TBTree* btree = (TBTree*)tree;
    int ret = 0;

    if( btree != NULL )
    {
        ret = btree->count;
    }    
    return ret;
}

int BTree_Degree(BTree* tree) // O(n) 递归获取二叉树的度 
{
    TBTree* btree = (TBTree*)tree;
    int ret = 0;

    if( btree != NULL )
    {
        ret = recursive_degree(btree->root);
    }    
    return ret;
}

void BTree_Display(BTree* tree, BTree_Printf* pFunc, int gap, char div) // O(n)
//打印二叉树节点的数据，采用递归的形式 
{
    TBTree* btree = (TBTree*)tree;

    if( btree != NULL )
    {
        recursive_display(btree->root, pFunc, 0, gap, div);
    }
}
//二叉树 main文件 main.c
#include <stdio.h>
#include <stdlib.h>
#include "BTree.h"

struct Node
{
    BTreeNode header;
    char v;
};

void printf_data(BTreeNode* node)
{
    if( node != NULL )
    {
        printf("%c", ((struct Node*)node)->v);
    }
}

int main(int argc, char *argv[])
{
    BTree* tree = BTree_Create();

    struct Node n1 = {{NULL, NULL}, 'A'};
    struct Node n2 = {{NULL, NULL}, 'B'};
    struct Node n3 = {{NULL, NULL}, 'C'};
    struct Node n4 = {{NULL, NULL}, 'D'};
    struct Node n5 = {{NULL, NULL}, 'E'};
    struct Node n6 = {{NULL, NULL}, 'F'};

    BTree_Insert(tree, (BTreeNode*)&n1, 0, 0, 0);
    BTree_Insert(tree, (BTreeNode*)&n2, 0x00, 1, 0);
    BTree_Insert(tree, (BTreeNode*)&n3, 0x01, 1, 0);
    BTree_Insert(tree, (BTreeNode*)&n4, 0x00, 2, 0);
    BTree_Insert(tree, (BTreeNode*)&n5, 0x02, 2, 0);
    BTree_Insert(tree, (BTreeNode*)&n6, 0x02, 3, 0);

    printf("Height: %d\n", BTree_Height(tree));
    printf("Degree: %d\n", BTree_Degree(tree));
    printf("Count: %d\n", BTree_Count(tree));
    printf("Position At (0x02, 2): %c\n", ((struct Node*)BTree_Get(tree, 0x02, 2))->v);
    printf("Full Tree: \n");
    BTree_Display(tree, printf_data, 4, '_');

    printf("\n");
    BTree_Delete(tree, 0x00, 1);

    printf("After Delete B: \n");
    printf("Height: %d\n", BTree_Height(tree));
    printf("Degree: %d\n", BTree_Degree(tree));
    printf("Count: %d\n", BTree_Count(tree));
    printf("Full Tree: \n");    
    BTree_Display(tree, printf_data, 4, '*');

    printf("\n");    
    BTree_Clear(tree);

    printf("After Clear: \n");
    printf("Height: %d\n", BTree_Height(tree));
    printf("Degree: %d\n", BTree_Degree(tree));
    printf("Count: %d\n", BTree_Count(tree));   
    BTree_Display(tree, printf_data, 4, ' ');

    BTree_Destroy(tree);

    return 0;
}

小结

二叉树在结构上不依赖组织链表。
通过指路法可以方便的定位二叉树中的结点。
基于指路法的二叉树在插入，删除和获取操作的实现细节上与单链表相似。
单链表就是特殊的二叉树，实现上当然相似，只是更简单而已。

二叉树创建
01-15
关于二叉树的一些操作，内容简单易懂，关于二叉树的创建遍历等等问题，适合新手
创建二叉树
weixin_44880330的博客
08-25 104
123
二叉树建立-二叉树建立-二叉树建立-二叉树建立-二叉树建立-二叉树建立
最新发布
09-09
/*********************************************************** ***********************************************************/ void preorder1(bitree *root) { bitree *p,*s[100]; int top=0;...
二叉树创建及其基本操作C++.zip
07-07
本资源包“二叉树创建及其基本操作C++.zip”提供了关于二叉树创建和基本操作的实例，包括节点的增加、删除、查找和修改，以及线索二叉树的概念。下面将详细阐述这些知识点。 二叉树是一种非线性数据结构，每个节点...
数据结构试验3二叉树建立，遍历等
11-11
#### 二叉树创建与遍历 **创建二叉树**：根据给定的先序遍历序列（子树为空时用’#’表示），可以构建出对应的二叉树。例如，输入序列“AB##D##CE##”表示一个包含A、B、C、D、E五个节点的二叉树。 ```cpp void ...
二叉树建立及遍历算法实现
06-03
建立二叉树，实现二叉树的先序、中序、后序的递归遍历算法，输出遍历结果。 实现二叉树的先序、中序、后序和层次遍历的非递归算法，输出遍历结果。
一个生成二叉树的头文件
07-06
一个用于生成二叉树的头文件，里面包含了可在文本文件中显示的代码。
二叉树头文件（包含创建和遍历输出）
11-21
二叉树的创建和遍历输出typedef char datatype; typedef struct node{ datatype data; struct node *lchild,*rchild; }binnode; typedef binnode *bintree; bintree root; void creatbintree(bintree *p) { char ch; if((ch=getchar())==' ') *p=NULL; else { *p=(binnode *)malloc(sizeof(binnode)); (*p)->data=ch; creatbintree(&(*p)->lchild); creatbintree(&(*p)->rchild); } } void preorder(bintree t) { if(t) { printf("%c",t->data); preorder(t->lchild); preorder(t->rchild); } } void postorder(bintree t) { if(t) { postorder(t->lchild); printf("%c",t->data); postorder(t->rchild); } } void inorder(bintree t) { if(t) { printf("%c",t->data); postorder(t->lchild); postorder(t->rchild); } } bintree locate(bintree t,datatype x) { bintree p; if(t==NULL) return NULL; else if(t->data==x)return t; else {p=locate(t->lchild,x); if(p) return p; else return locate(t->rchild,x); } } int numofbintree(bintree t) { if(t==NULL) return 0; else return (numofbintree(t->lchild)+numofbintree(t->rchild)+1); }
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值