今天来看大家介绍树，树是一种非线性的数据结构，树是由n个结点组成的有限集合，如果n=0,称为空树；如果n>0，则：有一个特定的称之为根的结点，它只有直接后继，但没有直接前驱；除根以外的其他结点划分为m个互不相交的有限集合，每个集合又是一棵树，并且称之为根的子树。

 

      如图

              一步一步学数据结构之1--n（通用树）_#include

 

      树的一些基本概念

 

l 树的结点包含一个数据以及若干指向子树的分支

l 结点拥有的子树数称为结点的度

u 度为0的结点称为叶结点

u 度不为0的结点称为分支结点

l 树的度定义为所有结点中的度的最大值

l 结点的直接后继称为该结点的孩子

u 相应的，该结点称为孩子的双亲

l 结点的孩子的孩子的.....称为该结点的子孙

u 相应的，该结点称为子孙的祖先

l 同一个双亲的孩子之间互称兄弟

l 树中结点的最大层次称为树的深度或高度

l 森林是由n（n>=0）棵互不相交的树组成的集合

 

在这里，我们用通用树结构来给大家介绍树的一些基本操作和操作实现。通用树的存储结构为：

   一步一步学数据结构之1--n（通用树）_结点_02

 

 

 

这里介绍通用树的常用操作：

 

l 创建树

l 销毁树

l 清空树

l 插入结点到树中

l 删除结点

l 获取某个结点

l 获取根结点

l 获取树的高度

l 获取总结点数

l 获取树的度

l 输出树

 

 

代码总分为三个文件：

GTree.h ： 放置功能函数的声明，以及树的声明，以及数据的声明 

GTree.c ： 放置功能函数的定义，以及树结点和组织链表结点的定义

Main.c   ： 主函数，使用功能函数完成各种需求，一般用作测试

 

整体结构图为：

 一步一步学数据结构之1--n（通用树）_子树_03

 

 

这里详细说下插入结点操作，删除结点操作：

 

插入结点操作：

一步一步学数据结构之1--n（通用树）_删除结点_04

 

如图：

 

  一步一步学数据结构之1--n（通用树）_#include_05

删除结点操作：

一步一步学数据结构之1--n（通用树）_#include_06

 

如图：

 

一步一步学数据结构之1--n（通用树）_#include_07

 

 

OK! 上代码：

 

GTree.h ： 

#ifndef _GTREE_H_
#define _GTREE_H_

typedef void GTree;
typedef void GTreeData;
typedef void (GTree_Printf)(GTreeData*);

GTree* GTree_Create();

void GTree_Destroy(GTree* tree);

void GTree_Clear(GTree* tree);

int GTree_Insert(GTree* tree, GTreeData* data, int pPos);

GTreeData* GTree_Delete(GTree* tree, int pos);

GTreeData* GTree_Get(GTree* tree, int pos);

GTreeData* GTree_Root(GTree* tree);

int GTree_Height(GTree* tree);

int GTree_Count(GTree* tree);

int GTree_Degree(GTree* tree);

void GTree_Display(GTree* tree, GTree_Printf* pFunc, int gap, char div);

#endif

 

GTree.c ： 

#include <stdio.h>
#include <malloc.h>
#include "GTree.h"
#include "LinkList.h"

typedef struct _tag_GTreeNode GTreeNode;
struct _tag_GTreeNode
{
  GTreeData* data;
  GTreeNode* parent;
  LinkList* child;
};

typedef struct _tag_TLNode TLNode;
struct _tag_TLNode
{
  LinkListNode header;
  GTreeNode* node;
};

GTree* GTree_Create()
{
  return LinkList_Create();
}

void GTree_Destroy(GTree* tree)
{
  GTree_Clear(tree);

  LinkList_Destroy(tree);
}

void GTree_Clear(GTree* tree)
{
  GTree_Delete(tree, 0);
}

int GTree_Insert(GTree* tree, GTreeData* data, int pPos)
{
  LinkList* list = (LinkList*)tree;

  int ret = (NULL!=list) && (NULL!=data) && (pPos<LinkList_Length(list));

  if(ret)
  {
    TLNode* trNode = (TLNode*)malloc(sizeof(TLNode));
    TLNode* cldNode = (TLNode*)malloc(sizeof(TLNode));
    TLNode* pNode = (TLNode*)LinkList_Get(list, pPos);

    GTreeNode* cNode = (GTreeNode*)malloc(sizeof(GTreeNode));

    ret = (NULL!=trNode) && (NULL!=cldNode) && (NULL!=cNode);

    if(ret)
    {
      cNode->data = data;
      cNode->parent = NULL;
      cNode->child = LinkList_Create();

      trNode->node = cNode;
      cldNode->node = cNode;

      LinkList_Insert(list, (LinkListNode*)trNode, LinkList_Length(list));

      if(NULL != pNode)
      {
        cNode->parent = pNode->node;

        LinkList_Insert(pNode->node->child, (LinkListNode*)cldNode, LinkList_Length(pNode->node->child));
      }
      else
      {
        free(cldNode);
      }
    }
    else
    {
      free(trNode);
      free(cldNode);
      free(cNode);
    }
  }

  return ret;
}

static int recursive_height(GTreeNode* node)
{
  int ret = 0;

  if(NULL != node)
  {
    int subHeight = 0;
    int i = 0;

    for(i=0; i<LinkList_Length(node->child); i++)
    {
      TLNode* trNode = (TLNode*)LinkList_Get(node->child, i);

      subHeight = recursive_height(trNode->node);

      if(ret < subHeight)
      {
        ret = subHeight;
      }
    }

    ret = ret+1;
  }

  return ret;
}


int GTree_Height(GTree* tree)
{
  TLNode* trNode = (TLNode*)LinkList_Get(tree, 0);

  int ret = 0;

  if(NULL != trNode)
  {
    ret = recursive_height(trNode->node);
  }

  return ret;
}

static void recursive_delete(LinkList* list, GTreeNode* node)
{
  if((NULL != list) && (NULL != node))
  {
    GTreeNode* parent = node->parent;

    int index = -1;
    int i = 0;

    for(i=0; i<LinkList_Length(list); i++)
    {
      TLNode* trNode = (TLNode*)LinkList_Get(list, i);

      if(node == trNode->node)
      {
        LinkList_Delete(list, i);
        free(trNode);
        index = i;

        break;
      }
    }

    if(0 <= index)
    {
      if(NULL != parent)
      {
        for(i=0; i<LinkList_Length(parent->child); i++)
        {
          TLNode* trNode = (TLNode*)LinkList_Get(parent->child, i);

          if(node == trNode->node)
          {
            LinkList_Delete(parent->child, i);
            free(trNode);

            break;  
          }
        }
      }

      while(0 < LinkList_Length(node->child))
      {
        TLNode* trNode = (TLNode*)LinkList_Get(node->child, 0);

        recursive_delete(list, trNode->node);
      }

      LinkList_Destroy(node->child);
      free(node);
    }
  }
}

GTreeData* GTree_Delete(GTree* tree, int pos)
{
  TLNode* trNode = (TLNode*)LinkList_Get(tree, pos);

  GTreeData* ret = NULL;

  if(NULL != trNode)
  {
    ret = trNode->node->data;

    recursive_delete(tree, trNode->node);
  }

  return ret;
}

GTreeData* GTree_Get(GTree* tree, int pos)
{
  TLNode* trNode = (TLNode*)LinkList_Get(tree, pos);

  GTreeData* ret = NULL;

  if(NULL != trNode)
  {
    ret = trNode->node->data;
  }

  return ret;
}

GTreeData* GTree_Root(GTree* tree)
{
  return GTree_Delete(tree, 0);
}

int GTree_Count(GTree* tree)
{
  return LinkList_Length(tree);
}

static int recursive_degree(GTreeNode* node)
{
  int ret = -1;

  if(NULL != node)
  {
    int subDegree = 0;
    int i = 0;

    ret = LinkList_Length(node->child);

    for(i=0; i<LinkList_Length(node->child); i++)
    {
      TLNode* trNode = (TLNode*)LinkList_Get(node->child, i);

      subDegree = recursive_degree(trNode->node);

      if(ret < subDegree)
      {
        ret = subDegree;
      }
    }
  }

  return ret;
}

int GTree_Degree(GTree* tree)
{
  TLNode* trNode = (TLNode*)LinkList_Get(tree, 0);

  int ret = -1;

  if(NULL != trNode)
  {
    ret = recursive_degree(trNode->node);
  }

  return ret;
}

static void recursive_display(GTreeNode* node, GTree_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->data);
    printf("\n");

    for(i=0; i<LinkList_Length(node->child); i++)
    {
      TLNode* trNode = (TLNode*)LinkList_Get(node->child, i);

      recursive_display(trNode->node, pFunc, format+gap, gap, div);
    }
  }
}

void GTree_Display(GTree* tree, GTree_Printf* pFunc, int gap, char div)
{
  TLNode* trNode = (TLNode*)LinkList_Get(tree, 0);

  if((NULL != trNode) && (NULL != pFunc))
  {
    recursive_display(trNode->node, pFunc, 0, gap, div);
  }
}

 

Main.c  ：

              

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

void printf_data(GTreeData* data)
{
  printf("%c", (int)data);
}

int main(void)
{
  GTree* tree = GTree_Create();

  int i = 0;

  GTree_Insert(tree, (GTreeData*)'A', -1);
  GTree_Insert(tree, (GTreeData*)'B', 0);
  GTree_Insert(tree, (GTreeData*)'C', 0);
  GTree_Insert(tree, (GTreeData*)'D', 0);
  GTree_Insert(tree, (GTreeData*)'E', 1);
  GTree_Insert(tree, (GTreeData*)'F', 1);
  GTree_Insert(tree, (GTreeData*)'H', 3);
  GTree_Insert(tree, (GTreeData*)'I', 3);
  GTree_Insert(tree, (GTreeData*)'J', 3);

  printf("Tree Height: %d\n", GTree_Height(tree));
  printf("Tree Degree: %d\n", GTree_Degree(tree));
  printf("Full Tree:\n");

  GTree_Display(tree, printf_data, 2, '-');

  printf("Get Tree Data: \n");

  for(i=0; i<GTree_Count(tree); i++)
  {
    printf_data(GTree_Get(tree, i));
    printf("\n");
  }

  printf("Get Root Data: \n");

  printf_data(GTree_Root(tree));
  printf("\n");

  GTree_Delete(tree, 3);
  printf("After Deleting D: \n");
  GTree_Display(tree, printf_data, 2, '-');

  GTree_Clear(tree);

  printf("After Clearing Tree:\n");

  GTree_Display(tree, printf_data, 2, '.');

  GTree_Destroy(tree);

  return 0;
}