數據結構之二叉樹

        既然樹已經熟悉了，那我們就來學習學習二叉樹吧，二叉樹是由n(n>=0)個結點組成的有限集合，該集合或者爲空，或者是由一個根結點加上兩棵分別稱爲左子樹和右子樹的﹑互不相交的二叉樹組成。

        如圖

        

有兩個定義需要大家知道下：

1.滿二叉樹

        如果二叉樹中所有分支結點的度數都爲2，且葉子結點都在同一層次上，則稱這類二叉樹爲滿二叉樹。

2.完全二叉樹

        如果一棵具有n個結點的高度爲k的二叉樹，它的每一個結點都與高度爲k的滿二叉樹中編號爲1-n的結點一一對應，則稱這棵二叉樹爲完全二叉樹。（從上到下從左到右編號）

        完全二叉樹的葉結點僅出現在最下面兩層

        最下層的葉結點一定出現在左邊

        倒數第二層的葉結點一定出現在右邊

        完全二叉樹中度爲1的結點只有左孩子

        同樣結點數的二叉樹，完全二叉樹的高度最小

二叉樹所具有的5個性質需要大家掌握：

 

這裏介紹通用樹的常用操作：

l 創建二叉樹

l 銷燬二叉樹

l 清空二叉樹

l 插入結點到二叉樹中

l 刪除結點

l 獲取某個結點

l 獲取根結點

l 獲取二叉樹的高度

l 獲取二叉樹的總結點數

l 獲取二叉樹的度

l 輸出二叉樹

代碼總分爲三個文件：

BTree.h ： 放置功能函數的聲明，以及樹的聲明，以及樹結點的定義 

BTree.c ： 放置功能函數的定義，以及樹的定義

Main.c   ： 主函數，使用功能函數完成各種需求，一般用作測試

整體結構圖爲：

這裏詳細說下插入結點操作，刪除結點操作和獲取結點操作：

 

插入結點操作：

如圖：

  

刪除結點操作：

如圖：

獲取結點操作：

            獲取結點操作和插入刪除結點操作中的指路法定位結點相同

OK! 上代碼：

BTree.h ： 

#ifndef _BTREE_H_
#define _BTREE_H_

#define BT_LEFT 0
#define BT_RIGHT 1

typedef void BTree;
typedef unsigned long long BTPos;

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;
};

BTree* BTree_Create()
{
    TBTree* ret = (TBTree*)malloc(sizeof(TBTree));

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

    return ret;
}

void BTree_Destroy(BTree* tree)
{
    free(tree);
}

void BTree_Clear(BTree* tree)
{
    TBTree* btree = (TBTree*)tree;

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

int BTree_Insert(BTree* tree, BTreeNode* node, BTPos pos, int count, int flag)
{
    TBTree* btree = (TBTree*)tree;

    int ret = (NULL!=btree) && (NULL!=node) && ((flag == BT_RIGHT) || (flag == BT_LEFT));

    int bit = 0;

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

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

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

            parent = current;

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

            count–;
        }

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

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

        btree->count++;
    }

    return ret;
}

static int recursive_count(BTreeNode* root)
{
    int ret = 0;

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

    return ret;
}

BTreeNode* BTree_Delete(BTree* tree, BTPos pos, int count)
{
    TBTree* btree = (TBTree*)tree;

    BTreeNode* ret = NULL;

    int bit = 0;

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

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

            parent = current;

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

            count–;
        }

        if(NULL != parent)
        {
            if(BT_LEFT == bit)
            {
                parent->left = NULL;
            }
            else if (BT_RIGHT == bit)
            {
                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)
{
    TBTree* btree = (TBTree*)tree;

    BTreeNode* ret = NULL;

    int bit = 0;

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

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

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

            count–;
        }

        ret = current;
    }

    return ret;
}

BTreeNode* BTree_Root(BTree* tree)
{
    TBTree* btree = (TBTree*)tree;

    BTreeNode* ret = NULL;

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

    return ret;
}

static int recursive_height(BTreeNode* root)
{
    int ret = 0;

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

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

    return ret;
}

int BTree_Height(BTree* tree)
{
    TBTree* btree = (TBTree*)tree;

    int ret = -1;

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

    return ret;
}

int BTree_Count(BTree* tree)
{
    TBTree* btree = (TBTree*)tree;

    int ret = -1;

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

    return ret;
}

static int recursive_degree(BTreeNode* root)
{
    int ret = 0;

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

        if(1 == ret)
        {
            int ld = recursive_degree(root->left);
            int rd = recursive_degree(root->right);

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

    return ret;
}

int BTree_Degree(BTree* tree)
{
    TBTree* btree = (TBTree*)tree;

    int ret = -1;

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

    return ret;
}

static void recursive_display(BTreeNode* node, BTree_Printf* pFunc, int format, int gap, char div)
{
    int i = 0;

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

        if((NULL != node->left) || (NULL != node->right))
        {
            recursive_display(node->left, pFunc, format+gap, gap, div);
            recursive_display(node->right, pFunc, format+gap, gap, div);
        }
    }
    else
    {
        for(i=0; i<format; i++)
        {
            printf(”%c”, div);
        }
        printf(”\n”);
    }
}

void BTree_Display(BTree* tree, BTree_Printf* pFunc, int gap, char div)
{
    TBTree* btree = (TBTree*)tree;

    if(NULL != btree)
    {
        recursive_display(btree->root, pFunc, 0, gap, div);
    }
}

 

Main.c  ：

#include <stdio.h>
#include <stdlib.h>
#include “BTree.h”

typedef struct _tag_node
{
    BTreeNode header;
    char v;
}Node;

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

int main(void)
{
    BTree* tree = BTree_Create();

    Node n1 = {{NULL, NULL}, ’A’};
    Node n2 = {{NULL, NULL}, ’B’};
    Node n3 = {{NULL, NULL}, ’C’};
    Node n4 = {{NULL, NULL}, ’D’};
    Node n5 = {{NULL, NULL}, ’E’};
    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”, ((Node*)BTree_Get(tree, 0x02, 2))->v);

    printf(”Full Tree:\n”);
    BTree_Display(tree, printf_data, 4, ’-‘);

    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, ’-‘);

    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));

    printf(”Full Tree:\n”);
    BTree_Display(tree, printf_data, 4, ’-‘);

    BTree_Destroy(tree);

    return 0;
}

        既然樹已經熟悉了，那我們就來學習學習二叉樹吧，二叉樹是由n(n>=0)個結點組成的有限集合，該集合或者爲空，或者是由一個根結點加上兩棵分別稱爲左子樹和右子樹的﹑互不相交的二叉樹組成。

        如圖

        

有兩個定義需要大家知道下：

1.滿二叉樹

        如果二叉樹中所有分支結點的度數都爲2，且葉子結點都在同一層次上，則稱這類二叉樹爲滿二叉樹。

2.完全二叉樹

        如果一棵具有n個結點的高度爲k的二叉樹，它的每一個結點都與高度爲k的滿二叉樹中編號爲1-n的結點一一對應，則稱這棵二叉樹爲完全二叉樹。（從上到下從左到右編號）

        完全二叉樹的葉結點僅出現在最下面兩層

        最下層的葉結點一定出現在左邊

        倒數第二層的葉結點一定出現在右邊

        完全二叉樹中度爲1的結點只有左孩子

        同樣結點數的二叉樹，完全二叉樹的高度最小

二叉樹所具有的5個性質需要大家掌握：

 

這裏介紹通用樹的常用操作：

l 創建二叉樹

l 銷燬二叉樹

l 清空二叉樹

l 插入結點到二叉樹中

l 刪除結點

l 獲取某個結點

l 獲取根結點

l 獲取二叉樹的高度

l 獲取二叉樹的總結點數

l 獲取二叉樹的度

l 輸出二叉樹

代碼總分爲三個文件：

BTree.h ： 放置功能函數的聲明，以及樹的聲明，以及樹結點的定義 

BTree.c ： 放置功能函數的定義，以及樹的定義

Main.c   ： 主函數，使用功能函數完成各種需求，一般用作測試

整體結構圖爲：

這裏詳細說下插入結點操作，刪除結點操作和獲取結點操作：

 

插入結點操作：

如圖：

  

刪除結點操作：

如圖：

獲取結點操作：

            獲取結點操作和插入刪除結點操作中的指路法定位結點相同

OK! 上代碼：

BTree.h ： 

#ifndef _BTREE_H_
#define _BTREE_H_

#define BT_LEFT 0
#define BT_RIGHT 1

typedef void BTree;
typedef unsigned long long BTPos;

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;
};

BTree* BTree_Create()
{
    TBTree* ret = (TBTree*)malloc(sizeof(TBTree));

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

    return ret;
}

void BTree_Destroy(BTree* tree)
{
    free(tree);
}

void BTree_Clear(BTree* tree)
{
    TBTree* btree = (TBTree*)tree;

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

int BTree_Insert(BTree* tree, BTreeNode* node, BTPos pos, int count, int flag)
{
    TBTree* btree = (TBTree*)tree;

    int ret = (NULL!=btree) && (NULL!=node) && ((flag == BT_RIGHT) || (flag == BT_LEFT));

    int bit = 0;

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

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

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

            parent = current;

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

            count–;
        }

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

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

        btree->count++;
    }

    return ret;
}

static int recursive_count(BTreeNode* root)
{
    int ret = 0;

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

    return ret;
}

BTreeNode* BTree_Delete(BTree* tree, BTPos pos, int count)
{
    TBTree* btree = (TBTree*)tree;

    BTreeNode* ret = NULL;

    int bit = 0;

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

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

            parent = current;

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

            count–;
        }

        if(NULL != parent)
        {
            if(BT_LEFT == bit)
            {
                parent->left = NULL;
            }
            else if (BT_RIGHT == bit)
            {
                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)
{
    TBTree* btree = (TBTree*)tree;

    BTreeNode* ret = NULL;

    int bit = 0;

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

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

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

            count–;
        }

        ret = current;
    }

    return ret;
}

BTreeNode* BTree_Root(BTree* tree)
{
    TBTree* btree = (TBTree*)tree;

    BTreeNode* ret = NULL;

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

    return ret;
}

static int recursive_height(BTreeNode* root)
{
    int ret = 0;

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

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

    return ret;
}

int BTree_Height(BTree* tree)
{
    TBTree* btree = (TBTree*)tree;

    int ret = -1;

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

    return ret;
}

int BTree_Count(BTree* tree)
{
    TBTree* btree = (TBTree*)tree;

    int ret = -1;

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

    return ret;
}

static int recursive_degree(BTreeNode* root)
{
    int ret = 0;

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

        if(1 == ret)
        {
            int ld = recursive_degree(root->left);
            int rd = recursive_degree(root->right);

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

    return ret;
}

int BTree_Degree(BTree* tree)
{
    TBTree* btree = (TBTree*)tree;

    int ret = -1;

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

    return ret;
}

static void recursive_display(BTreeNode* node, BTree_Printf* pFunc, int format, int gap, char div)
{
    int i = 0;

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

        if((NULL != node->left) || (NULL != node->right))
        {
            recursive_display(node->left, pFunc, format+gap, gap, div);
            recursive_display(node->right, pFunc, format+gap, gap, div);
        }
    }
    else
    {
        for(i=0; i<format; i++)
        {
            printf(”%c”, div);
        }
        printf(”\n”);
    }
}

void BTree_Display(BTree* tree, BTree_Printf* pFunc, int gap, char div)
{
    TBTree* btree = (TBTree*)tree;

    if(NULL != btree)
    {
        recursive_display(btree->root, pFunc, 0, gap, div);
    }
}

 

Main.c  ：

#include <stdio.h>
#include <stdlib.h>
#include “BTree.h”

typedef struct _tag_node
{
    BTreeNode header;
    char v;
}Node;

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

int main(void)
{
    BTree* tree = BTree_Create();

    Node n1 = {{NULL, NULL}, ’A’};
    Node n2 = {{NULL, NULL}, ’B’};
    Node n3 = {{NULL, NULL}, ’C’};
    Node n4 = {{NULL, NULL}, ’D’};
    Node n5 = {{NULL, NULL}, ’E’};
    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”, ((Node*)BTree_Get(tree, 0x02, 2))->v);

    printf(”Full Tree:\n”);
    BTree_Display(tree, printf_data, 4, ’-‘);

    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, ’-‘);

    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));

    printf(”Full Tree:\n”);
    BTree_Display(tree, printf_data, 4, ’-‘);

    BTree_Destroy(tree);

    return 0;
}