Linux学习之路（11）

一兮1211

于 2018-12-18 09:06:00 发布

阅读量87

点赞数

本文链接：https://blog.csdn.net/qq_39584766/article/details/85059503

版权

二叉树：

BTREE.h:

#ifndef _BTREE_H_
#define _BTREE_H_

typedef char BTreeData;

typedef enum {FALSE, TRUE} BOOL;
typedef enum {LEFT, RIGHT} MOUNTWAY;

typedef struct btreeNode                       //二叉树节点结构体
{
   BTreeData data;
   struct btreeNode* lchild;
   struct btreeNode* rchild;
}BTreeNode;

typedef struct btree //二叉树结构体
{
BTreeNode* root;
}BTree;

BTree* BTreeCreate();

typedef void (*PFUNC)(BTreeNode* node, int level);

BOOL BTreeInsert(BTree* btree, BTreeData data, int path, int steps, MOUNTWAY mw);

void BTree_Display(BTree *btree,PFUNC callback);

int BTreeCount(BTree* btree); //节点数

int BTreeHeigth(BTree* btree); //高度

int BTreeDegree(BTree* btree); // 度

#endif //_BTREE_H_

main.c：

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

void myprintf(BTreeNode *node, int level)
{
   int i;
   for(i = 1; i < level; i++)
   {
       printf("----");
   }

   if(node != NULL)
       printf("%c\n", node->data);
   else
       printf("\n");
}

int main1()
{
   BTree* btree = BTreeCreate();
   if (NULL == btree)
       return -1;

   printf("二叉树创建成功\n");

   BTreeInsert(btree, 'A', 0, 0, LEFT);
   BTreeInsert(btree, 'B', 0, 1, LEFT);
   BTreeInsert(btree, 'C', 1, 1, LEFT);
   BTreeInsert(btree, 'D', 0, 2, LEFT);
   BTreeInsert(btree, 'E', 2, 2, LEFT);
   BTreeInsert(btree, 'F', 1, 2, LEFT);
   BTreeInsert(btree, 'G', 3, 2, LEFT);

   BTree_Display(btree, myprintf);
   printf("树的节点数为：%d\n",BTreeCount(btree));
   printf("树的高度为：%d\n",BTreeHeight(btree));
   printf("树的度为：%d\n",BTreeDegree(btree));
   printf("***********************************************\n");


   BTreeDelete(btree, 1, 1);
   BTree_Display(btree, myprintf);

   printf("树的节点数为：%d\n",BTreeCount(btree));
   printf("树的高度为：%d\n",BTreeHeight(btree));
   printf("树的度为：%d\n",BTreeDegree(btree));
   return 0;
}

void pre_order(BTreeNode* node)
{
   if(NULL == node)
       return;
   //根
   printf("%4c", node->data);
   //左
   pre_order(node->lchild);
   //右
   pre_order(node->rchild);
}

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

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

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

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

int main()
{
   BTree* btree = BTreeCreate();
   if (NULL == btree)
       return -1;

   printf("二叉树创建成功\n");

   BTreeInsert(btree, 'A', 0, 0, LEFT);
   BTreeInsert(btree, 'B', 0, 1, LEFT);
   BTreeInsert(btree, 'C', 1, 1, LEFT);
   BTreeInsert(btree, 'D', 0, 2, LEFT);
   BTreeInsert(btree, 'E', 2, 2, LEFT);
   BTreeInsert(btree, 'F', 1, 2, LEFT);
   BTreeInsert(btree, 'G', 3, 2, LEFT);

   BTree_Display(btree, myprintf);
   //前序遍历
   pre_order(btree->root);
   printf("\n");
   //中序遍历
   mid_order(btree->root);
   printf("\n");
   //后序遍历
   last_order(btree->root);
   printf("\n");

return 0;
}

BTree.c：

#include "BTREE.h"
#include <stdlib.h>

BTree* BTreeCreate()
{
   BTree* btree = (BTree*)malloc(sizeof(BTree)/sizeof(char));

   if (NULL == btree)
       return NULL;

   btree->root = NULL;
   return btree;
}

//插入节点
BOOL BTreeInsert(BTree* btree, BTreeData data, int path, int steps, MOUNTWAY mw)
{
   BTreeNode* node = (BTreeNode*)malloc(sizeof(BTreeNode)/sizeof(char));                   //创建节点

   if (NULL == node)   //判断节点是否创建成功
       return FALSE;

   //节点初始化
   node->data = data;
   node->lchild = NULL;
   node->rchild = NULL;

   BTreeNode* parent = NULL; //父节点
   BTreeNode* tmp = btree->root;   //根节点开始

   int way;

   while(steps>0 && tmp != NULL)
   {
       way = path&1;
       path >>= 1;

       parent = tmp;

       if(way == LEFT)
       {
           tmp = tmp->lchild;
       }
       else
       {
           tmp = tmp->rchild;
       }
       steps--;
   }

   if(parent != NULL)
   {
       if(way == LEFT)
       {
           parent->lchild = node;
       }
       else
       {
           parent->rchild = node;
       }
   }
   else
   {
       btree->root = node;
   }
   return TRUE;
}

//打印二叉树
void r_display(BTreeNode* node, PFUNC callback, int level)
{
   callback(node, level); //1、打印自己

   if(NULL == node)
   {
       return;
   }

   if(node->lchild != NULL || node->rchild != NULL)
   {
       r_display(node->lchild, callback, level+1);

       r_display(node->rchild, callback, level+1);
   }
}

void BTree_Display(BTree *btree,PFUNC callback)
{
   if (NULL == btree)
       return;

   r_display(btree->root, callback, 1);
}

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

   r_delete(node->lchild);       //删左子节点
   r_delete(node->rchild);       //删右子节点
   free(node);                   //删自己
}

void BTreeDelete(BTree* btree, int path, int steps)
{
   BTreeNode* parent = NULL; //父节点
   BTreeNode* tmp = btree->root;   //根节点开始

   int way;

   while(steps>0 && tmp != NULL)
   {
       way = path&1;
       path >>= 1;

       parent = tmp;

       if(way == LEFT)
       {
           tmp = tmp->lchild;
       }
       else
       {
           tmp = tmp->rchild;
       }
       steps--;
   }

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

   r_delete(tmp);
}

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

   int lc = r_count(node->lchild);
   int lr = r_count(node->rchild);

   return lc+lr+1;
}

int BTreeCount(BTree* btree) //节点数
{
   if(NULL == btree)
       return 0;

   return r_count(btree->root);
}

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

   int hc = r_heigth(node->lchild);
   int hr = r_heigth(node->rchild);

   return hc>hr?hc+1:hr+1;
}
int BTreeHeight(BTree* btree) //树高度
{
   if(NULL == btree)
       return 0;

   return r_heigth(btree->root);
}

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

   int degree = 0;

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

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

   if(degree == 1)
   {
       if((2 == r_degree(node->lchild)) || (2 == r_degree(node->rchild)))
       degree = 2;
   }
   return degree;
}

int BTreeDegree(BTree* btree)           //树度
{
   if(NULL == btree)
       return 0;

   return r_degree(btree->root);
}