二叉树

最新推荐文章于 2022-05-01 12:47:37 发布
最新推荐文章于 2022-05-01 12:47:37 发布
阅读量108 收藏
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/meng110389/article/details/109171508
版权

指路法定位结点

指路法通过根结点与目标结点的相对位置进行定位
在C语言中可以利用bit位进行指路

#define BT_LEFT 0
#define BT_RIGHT 1

二叉树存储结构简介

  1. 结点指针域定义
typedef struct _tag_BTreeNode BTreeNode;
struct _tag_BTreeNode
{
	BTreeNode* left;
	BTreeNode* right;
};
  1. 头结点定义
typedef struct _tag_BTree TBTree;
struct _tag_BTree
{
	int count;
	BTreeNode* root;
};
  1. 数据元素定义
struct Node
{
	BTreeNode header;
	char v;
};

代码实现

BTree.h

#pragma once

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

BTree.c

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

typedef struct _tag_BTree TBTree;

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

BTree* BTree_Create() 
{
	TBTree* tree = (TBTree*)malloc(sizeof(TBTree));
	if (tree!=NULL) {
		tree->count = 0;
		tree->root = NULL;
	}
	return tree;
}

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

void BTree_Clear(BTree* tree)
{
	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) 
{
	TBTree* btree = (TBTree*)tree;
	BTreeNode* parent = NULL;
	BTreeNode* current = NULL;
	int bit = 0;
	int ret = (btree!=NULL && node!=NULL);
	ret = ret && (flag == BT_LEFT || flag == BT_RIGHT);

	if (ret) {
		current = btree->root;
		node->left = NULL;
		node->right = NULL;
		while ((count>0) && (current!=NULL)) {
			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 (parent!=NULL) {
			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 (root!=NULL) {
		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;
	BTreeNode* parent = NULL;
	BTreeNode* current = NULL;
	int bit = 0;
	if (btree!=NULL) {

		current = btree->root;
		while ((count>0) && (current!=NULL)) {
			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 (parent!=NULL) {
			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;
	int bit = 0;
	BTreeNode* ret = NULL;
	BTreeNode* current = NULL;
	if (btree!=NULL) {
		current = btree->root;
		while ((count>0) && (current!=NULL)) {
			bit = pos & 1;
			pos = pos >> 1;
			
			if (BT_LEFT == bit)
				current = current->left;
			else if (BT_RIGHT == bit)
				current = current->right;
			count--;
		}
		ret = current;
	}
	return ret;
}

BTreeNode* BTree_Root(BTree* tree) 
{
	TBTree* btree = (TBTree*)tree;
	BTreeNode* ret = NULL;
	
	if (btree!=NULL) {
		ret = btree->root;
	}
	return ret;
}

static int recursive_height(BTreeNode* root) 
{
	int ret = 0;
	int left = 0;
	int right = 0;
	if (root!=NULL) {
		left = recursive_height(root->left);
		right = recursive_height(root->right);

		ret = left > right ? (left + 1) : (right + 1);
	}
	return ret;
}

int BTree_Height(BTree* tree) 
{
	int ret = 0;
	TBTree* btree = (TBTree*)tree;
	if (btree!=NULL) {
		ret = recursive_height(btree->root);
	}
	return ret;
}

int BTree_Count(BTree* tree) 
{
	TBTree* btree = (TBTree*)tree;
	int ret = 0;
	if (btree!=NULL) {
		ret = btree->count;
	}
	return ret;
}

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

	if (root!=NULL) {
		if (root->left!=NULL) {
			ret++;
		}
		if (root->right!=NULL) {
			ret++;
		}
		if (1 == ret) {
			ld = recursive_degree(root->left);
			if (ret<ld) {
				ret = ld;
			}
			rd = recursive_degree(root->right);
			if (ret<rd) {
				ret = rd;
			}
		}
	}
	return ret;
}

int BTree_Degree(BTree* tree) 
{
	TBTree* btree = (TBTree*)tree;
	int ret = 0;
	if (btree!=NULL) {
		ret = recursive_degree(btree);
	}
	return ret;
}

static void recursive_display(BTreeNode* root, BTree_Printf* pFunc, int format, int gap, char div) 
{
	int i = 0;
	if ((root!=NULL) && (pFunc!=NULL)) {
		for (i = 0; i < format;++i) {
			printf("%c", div);
		}
		pFunc(root);
		printf("\n");
		if ((root->left!=NULL) || (root->right!=NULL)) {
			recursive_display(root->left, pFunc, format + gap, gap, div);
			recursive_display(root->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 (btree!=NULL) {
		recursive_display(btree->root, pFunc, 0, gap, div);
	}
}

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

	BTree_Display(tree, printf_data, 4, '-');
	BTree_Destroy(tree);
	return 0;
}

运行结果：

Height:4
Degree:2
Count:6
Position At (0x02,2):E
Full Tree:
A
----B
--------D
--------E
------------F
------------
----C
After Delete B:
Height: 2
Degree: 2
Count: 2
Full Tree:
A
----
----C
After Clear:
Height: 0
Degree: 0
Count: 0
写一行代码
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
正弦定理的博客
12-09 35万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
二叉树详解
weixin_59371851的博客
07-09 5万+
目录前言一、树的概念和结构1、树的概念2、树的表示 3、树在实际中的应用（表示文件系统的目录树结构）二、二叉树概念及结构1.概念 2、特殊的二叉树3、二叉树的性质4、二叉树的存储4.1顺序存储4.2链状存储 三、二叉树的顺序结构和实现1、二叉树的顺序结构2、堆的概念及结构3、堆的实现3.1堆的代码框架3.2堆的插入3.3堆的删除3.4堆的建立 3.5建堆的时间复杂度 4、堆的应用4.1堆排序 4.2TOP-K问题四、二叉树链式结构的实现 1、建二叉树2、二叉树的遍历2.1前序、中序以及后序遍历2.2层序遍历
locate函数测试以及原因分析
欢迎来到我的博客
05-26 283
#include <stdlib.h> #include <stdio.h> #include <unistd.h> static void show_pointer(void *p, char *descr) { // printf("Pointer for %s at %p\n", descr, p); printf("%s\t%p...
在二叉树中找值为x的结点(假设所有结点的值都不一样)
认知 行动 坚持
11-05 1万+
#include #include #define N 7 using namespace std; typedef struct node { struct node *leftChild; struct node *rightChild; int data; }BiTreeNode, *BiTree; // 生成一个结点 BiTreeNode *create
数据结构：树、二叉树
yin的博客
09-09 359
一：树的定义： 树（tree）是n个节点的有限集；n = 0;称为空树； 在任意非空树中： 1、有且仅有一个特定的根节点； 2、当n&gt;1时其余结点可分为m(m&gt;0)个互不相交的有限集，其中每个集合本身又是一棵树，并且称为根的子树。     树的定义强调两点： 1、n&gt;0时，根节点唯一 2、m&gt;0时，子树的个数没有限制，但他们一定互不相交 下图就不符合...
python二叉树
惊鸿的博客
03-12 5634
二叉树特征定义 特征 树是一种 非线性的数据结构，，直观的看，他是数据元素（在树中称为结点）按分支关系组织起来的结构，很像自然界中的树那样，树结构在客观世界中广泛存在，如人类社会的族谱和各种社会组织机构都可以用树形象来表示。还有比如在编译程序的时候，它可以用来表示源程序的语法结构，又或者在数据库中，树型结构也是信息的重要组织形式之一。 总之：一切具有层次关系的问题都可以用树来描述。 定义 树（Tree）是n（≥0）个节点的有限集。在任意一棵树中： 1、有且仅有一个称为根（Root）的结点 2、当n&g
【数据结构】——二叉树详解
atwdy的博客
07-28 5万+
二叉树(Binary Tree)是由n个结点构成的有限集(n≥0)，n=0时为空树，n>0时为非空树。对于非空树TTT有且仅有一个根结点；除根结点外的其余结点又可分为两个不相交的子集TLT_LTL​和TRT_RTR​，分别称为TTT的左子树和右子树，且TLT_LTL​和TRT_RTR​本身又都是二叉树。很明显该定义属于递归定义，所以有关二叉树的操作使用递归往往更容易理解和实现。从定义也可以看出二叉树与一般树的区别主要是两点，一是每个结点的度最多为2；
二叉树的基本操作
热门推荐
Daioo 随笔
04-21 12万+
一、实验目的 1、掌握二叉树的定义； 2、掌握二叉树的基本操作，如二叉树的建立、遍历、结点个数统计、树的深度计算等。 二、实验内容 （一）用递归的方法实现以下算法： 1、以二叉链表表示二叉树，建立一棵二叉树（算法5.3）； 2、输出二叉树的中序遍历结果（算法5.1）； 3、输出二叉树的前序遍历结果（见讲稿）； 4、输出二叉树的后序遍历结果（见讲稿）； 5、计算二叉树的深度（算法5.
平衡二叉树
清风
05-01 4万+
1.定义 平衡二叉树，又称AVL树，用于解决二叉排序树高度不确定的情况，如果二叉排序树的子树间的高度相差太大，就会让二叉排序树操作的时间复杂度升级为O(n)，为了避免这一情况，为最坏的情况做准备，就出现了平衡二叉树，使树的高度尽可能的小，其本质还是一棵二叉搜索树。 平衡二叉树的性质： 左子树和右子树的高度之差的绝对值小于等于1 左子树和右子树也是平衡二叉树 为了方便起见，给树上的每个结点附加一个数字，给出该结点左子树与右子树的高度差，这个数字称为结点的平衡因子（BF） 平衡因子=结点左子树的高度-
二叉树_二叉树遍历_
10-04
1.二叉树的基本操作实现【问题描述】建立一棵二叉树，用递归方法实现二叉树的如下基本操作：（1）按先序序列构造一棵二叉链表表示的二叉树T；（2）对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出...
二叉树 基础
03-08
在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 二叉树的每个结点至多只有二棵子树...
将满二叉树转化为求和二叉树_二叉树_
09-30
在IT领域，特别是数据结构和算法的学习中，二叉树是一种重要的抽象数据类型。满二叉树是一种特殊的二叉树，其中每一层都是完全填充的，除了可能的最后一层，且最后一层的所有节点都尽可能地向左靠拢。而将满二叉树...
线索二叉树
04-10
通过前序序列创建线索二叉树 1:中序遍历 2:查找节点前驱后继 3:插入节点 4:删除节点 0:退出
Uniapp软件库全新带勋章功能/包含前后端源码
08-14
Uniapp软件库全新带勋章功能，搭建好后台 在前端找到 util 这个文件 把两个js文件上面的填上自己的域名，电脑需要下载：HBuilderX 登录账号 没有账号就注册账号，然后上传文件，打包选择 “发行” 可以打包app h5等等。 后端安装： 1、下载源码到服务器目录 2、设置运行目录为 public 3、配置伪静态 4、修改数据库账号密码config/database.php点击导入， 5、访问域名即可
【独家首发】基于矮猫鼬优化算法DMOA-GMDH的锂电池寿命SOC估计算法研究Matlab实现.rar
最新发布
08-14
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手
基于Android五子棋设计与实现.docx
08-14
基于Android五子棋设计与实现.docx
MultiVideoDemo.rar
08-14
MultiVideoDemo.rar 博客地址：https://lw112190.blog.csdn.net/article/details/141200926
二叉树操作算法详解
"二叉树相关的C语言实现代码，包括初始化、创建、遍历等基本操作" 二叉树是一种在计算机科学中广泛使用的数据结构，它由节点（或称为结点）组成，每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值