【数据结构】链式二叉树【递归】

已于 2022-11-07 21:21:15 修改
阅读量623 收藏 1
点赞数 4
文章标签： 数据结构 c语言
于 2022-08-27 16:54:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kdjjdjdjjejje128/article/details/126527752
版权

我们前面已经了解了树和堆的性质原理，今天就来学习一下链式二叉树，也就是递归

文章目录

前言

下面是我们前面讲的树、二叉树和堆的一些性质：

树的性质与堆

堆的应用

其次，我们在下面实现二叉树要使用到队列的代码

队列

普通二插树的实现

1、构建一个二叉树

方法1

我们在拿到一组数据的时候，这组数据在逻辑结构上面并不是一个二叉树，这里为了方便直接手动构建一个二叉树

通过前序遍历的数组"123#7###45##6##"构建二叉树

BTNode* BinaryTreeCreate1()
{
	BTNode* n1 = (BTNode*)malloc(sizeof(BTNode));
	assert(n1);//为了方便直接断言n1，后面同理
	BTNode* n2 = (BTNode*)malloc(sizeof(BTNode));
	assert(n2);
	BTNode* n3 = (BTNode*)malloc(sizeof(BTNode));
	assert(n3);
	BTNode* n4 = (BTNode*)malloc(sizeof(BTNode));
	assert(n4);
	BTNode* n5 = (BTNode*)malloc(sizeof(BTNode));
	assert(n5);
	BTNode* n6 = (BTNode*)malloc(sizeof(BTNode));
	assert(n6);
	BTNode* n7 = (BTNode*)malloc(sizeof(BTNode));
	assert(n7);

	n1->data = 1;
	n2->data = 2;
	n3->data = 3;
	n4->data = 4;
	n5->data = 5;
	n6->data = 6;
	n7->data = 7;

	n1->left = n2;
	n1->right = n4;
	n2->left = n3;
	n2->right = NULL;
	n3->left = NULL;
	n3->right = n7;
	n4->left = n5;
	n4->right = n6;
	n5->left = NULL;
	n5->right = NULL;
	n6->left = NULL;
	n6->right = NULL;
	n7->left = NULL;
	n7->right = NULL;

	return n1;
}

在这里插入图片描述
这样就构成了一个简单的二叉树

接下来换一种方法进行构建二叉树

方法2

通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树

//通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate2(char* a, int* pi)//这里的*pi是下标，如果不使用下标在特殊情况下*pi下标对应的值会被后面的值给覆盖了
{
	if (a[*pi] == '#')//如果数组里面的元素是#，那么下标*pi就加加，到下一位
	{
		(*pi)++;
		return NULL;
	}
	BTNode* root = (BTNode*)malloc(sizeof(BTNode));//动态开辟root
	if (root == NULL)
	{
		perror("malloc fail\n");
		exit(-1);
	}
	root->data = a[(*pi)++];//二叉树的节点值就等于数组a里面的元素
	root->left = BinaryTreeCreate2(a, pi);//左子树递归
	root->right = BinaryTreeCreate2(a, pi);//右子树递归
	return root;//返回root就是返回我们构建出来的二叉树的起始地址
}

char a[18] = "ABD##E#H##CF##G##";
int pi = 0;
//BTNode* root = BinaryTreeCreate2(a, &pi);
root = BinaryTreeCreate2(a, &pi);
BinaryTreePrevOrder(root);//要用%c遍历

2、遍历操作

普通二叉树不像特殊二叉树和堆那样，它的函数接口并不是增删查改，因为普通二叉树进行增删查改没有意义
普通二叉树最常见的操作就是前序遍历、中序遍历、后序遍历和层序遍历
我们先来看看前面的三种遍历：

学习二叉树结构，最简单的方式就是遍历。所谓二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉
树中的节点进行相应的操作，并且每个节点只操作一次。访问结点所做的操作依赖于具体的应用问题。 遍历
是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。

在这里插入图片描述
按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历：

1 . 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
2. 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
3. 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。

由于被访问的结点必是某子树的根，所以N(Node）、 L(Left subtree）和R(Right subtree）又可解释为
根、根的左子树和根的右子树。 NLR、 LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。

也就是说三种遍历的操作顺序为：

前序遍历：根——左子树——右子树
中序遍历：左子树——根——右子树
后序遍历：左子树——右子树——根

这里我们来看看前序遍历，中序遍历和后序遍历也会融会贯通的
前序遍历递归图解：
在这里插入图片描述

在这里插入图片描述

接下来看看前、中、后序遍历的代码：

// 二叉树前序遍历 
void BinaryTreePrevOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	printf("%d ", root->data);
	BinaryTreePrevOrder(root->left);
	BinaryTreePrevOrder(root->right);
}

// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	BinaryTreeInOrder(root->left);
	printf("%d ", root->data);
	BinaryTreeInOrder(root->right);
}

// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	BinaryTreePostOrder(root->left);
	BinaryTreePostOrder(root->right);
	printf("%d ", root->data);
}

这里我们通过递归展开图来分析：
在这里插入图片描述
上面就是前序遍历的递归展开图，中序遍历和后序遍历与上面差不多，大家可以自己动手画一画

接下来我们看看层序遍历，这里就要用到一个队列来完成了。因为用队列会比较简单
主要逻辑就是：上一层节点出的时候带入下一层节点
在这里插入图片描述
这里就是QueueNode里面包含了一个BTNode*
在这里插入图片描述

代码如下：

// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)
{
	Queue p;
	QueueInit(&p);
	if (root)//如果树的节点不为空，就先把树的节点入进去
		QueuePush(&p, root);
	while (!QueueEmpty(&p))//如果队列不为空
	{
		BTNode* front = QueueFront(&p);//出队头数据
		QueuePop(&p);
		printf("%d ", front->data);//打印
		if (front->left)//上一层节点出的时候，带下一层左节点
			QueuePush(&p, front->left);
		if (front->right)//上一层节点出的时候，带下一层右节点
			QueuePush(&p, front->right);
	}
	printf("\n");
	QueueDestroy(&p);
}

3、二叉树的销毁

这个挺简单的，也是左右递归下去然后free掉root

// 二叉树销毁
void BinaryTreeDestory(BTNode* root)
{
	if (root == NULL)
		return;
	BinaryTreeDestory(root->left);
	BinaryTreeDestory(root->right);
	free(root);
}

4、节点个数

// 二叉树节点个数
int BinaryTreeSize(BTNode* root)
{
	return root == NULL ? 0 : BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1;
	//如果root不等于NULL,那么就返回左子树节点与右子树节点加上1的和，就是整个二叉树节点个数
}

在这里插入图片描述

注意：

这里如果使用一个计数器的话有许多弊端的。如果使用局部变量计数器那么就不会返回，因为局部变量计数器出作用域就销毁了，外面接收返回值就相当于越界访问了；如果加static变为静态变量也有问题，局部的静态变量只有在第一次调用的时候会初始化，static修饰的变量是保存在静态区的，这个变量在函数销毁之后并不会销毁，那么如果多次求二叉树节点个数结果会不断累加

同一棵树调用两次求节点个数：

可以看到结果是累加的，所以使用static修饰的静态变量也有问题

如果使用全局变量计数的话，在每次统计个数的时候记得把全局变量初始化为0，不然结果也是累加的

5、叶节点的个数

// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root)
{
	if (root == NULL)
		return 0;
	if (root->left == NULL && root->right == NULL)//如果节点的左子树和右子树都为空，那么该节点就是叶子节点，返回1
		return 1;
	return BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);//左子树的叶子节点加上右子树的叶子节点
}

6、树高

//二叉树高度/层次
int BinaryTreeHeight(BTNode* root)//这里的函数是有返回值的，所以左右子树递归结果要用一个int变量进行统计
{
	if (root == NULL)
		return 0;
	int leftheight = BinaryTreeHeight(root->left);//如果这里没有leftheight和下面的rightheight就接收不到左右子树的返回结果
	int rightheight = BinaryTreeHeight(root->right);
	return leftheight > rightheight ? leftheight + 1 : rightheight + 1;
	//因为是求树高，所以左右子树高度高的那一个加上根就是整个树的高度
}

7、第k层的节点个数

// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
	assert(k > 0);
	if (root == NULL)
		return 0;
	if (k == 1)//如果k等于1，就直接返回1，因为左右子树递归到第k层的时候有且仅有一个节点
		return 1;
	return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);
	//左右递归，k依次减一，表示每次递归一层
}

8、查找x节点

// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, NDataType x)//与上面一样，函数有返回值的
{
	if (root == NULL)
		return NULL;
	if (root->data == x)//如果data等于x，直接返回root当前的地址
		return root;
	BTNode* left = BinaryTreeFind(root->left, x);//这里和下面都需要一个BTNode指针类型来接收左右子树递归返回的地址
	//if(left)
	   //return left;
	BTNode* right = BinaryTreeFind(root->right, x);
	//if(right)
		 //return right;
	//return NULL;
	return left == NULL ? right : left;
	//这里是一个小妙招，如果left等于NULL,就返回right地址；即便是right是NULL,返回right也没错，因为left是NULL
}

9、判断二叉树是否是完全二叉树

思路：

使用层序遍历方法，上一层节点出的时候带下一层节点，当出的节点为NULL时，后面数据必须都为NULL,否则就是错的

在这里插入图片描述

// 判断二叉树是否是完全二叉树
// 判断二叉树是否是完全二叉树（使用层序遍历方法）
int BinaryTreeComplete(BTNode* root)
{//与上面一样，上一层节点出的时候带下一层节点，当出的节点为NULL时，后面数据必须都为NULL,否则就是错的
	Queue p;
	QueueInit(&p);
	if (root)//如果树的节点不为空，就先把树的节点入进去
		QueuePush(&p, root);
	while (!QueueEmpty(&p))
	{
		BTNode* front = QueueFront(&p);
		QueuePop(&p);
		if (front == NULL)//当出到NULL的时候就跳出
			break;
		QueuePush(&p, front->left);
		QueuePush(&p, front->right);
	}
	while (!QueueEmpty(&p))//到这里如果后面全是NULL，那么是完全二叉树
	{
		BTNode* front = QueueFront(&p);
		QueuePop(&p);
		if (front != NULL)
		{
			QueueDestroy(&p);//记得销毁
			return false;//如果后面有一个数据不是NULL,那么就不是完全二叉树
		}
	}
	QueueDestroy(&p);
	return true;
}

前全部代码

这里代码大部分都有注释，应该比较容易理解

Queue.h

#pragma once

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef int NDataType;
typedef struct BinaryTreeNode
{
	NDataType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;//这里要把二叉树结构体定义放到这里，因为Queue.c也引用了Queue.h头文件，如果不放到这里，Queue.c无法使用下面的DataType

typedef BTNode* DataType;//这里不再是int重命名了，而是BTNode*类型重命名

//QueueNode*里面包含了一个BTNode*
typedef struct QueueNode//单链表的形式
{
	DataType data;//数值
	struct QueueNode* next;//指向下一个节点的指针
}QN;//重命名为QN

typedef struct Queue//定义一个结构体用来存放两个结构体指针
//这样修改外面指针（也就是改变head和tail指向节点）的时候，不用传二级指针和接收改变指针的返回值
{
	QN* head;//指向队列的对头
	QN* tail;//指向队列的对尾
	int size;//记录队列数据个数，用一个计数器可以提高计算效率
}Queue;

void QueueInit(Queue* ps);//初始化
void QueueDestroy(Queue* ps);//释放空间
bool QueueEmpty(Queue* ps);//判断队列是否为空
void QueuePush(Queue* ps,DataType x);//入队列
void QueuePop(Queue* ps);//出队列
DataType QueueFront(Queue* ps);//队头数据
DataType QueueBack(Queue* ps);//队尾数据
int QueueSize(Queue* ps);//队列剩余数据个数

Queue.c

#define _CRT_SECURE_NO_WARNINGS
#include"Queue.h"
void QueueInit(Queue* ps)//初始化
{
	assert(ps);
	ps->head = ps->tail = NULL;//两个指针都指向空
	ps->size = 0;//此时队列没有数据
}
void QueueDestroy(Queue* ps)//释放空间
{
	assert(ps);
	QN* cur = ps->head;//cur等于头指针，ps是结构体指针，结构体指针指向头指针
	while (cur)//如果头指针不为空，就进入循环释放空间
	{
		QN* del = cur;//保留头指针的节点
		cur = cur->next;//头指针向后移动
		free(del);//释放头指针移动前的节点
	}
	ps->head = ps->tail = NULL;//释放完之后，头尾指针指向NULL
	ps->size = 0;//数据个数清0
}
void QueuePush(Queue* ps, DataType x)//入队列
{
	assert(ps);
	QN* newnode = (QN*)malloc(sizeof(QN));//扩容一个新的节点出来
	if (newnode == NULL)
	{
		perror("malloc fail\n");
		exit(-1);
	}
	else
	{
		newnode->data = x;//对新节点就行初始化操作
		newnode->next = NULL;//这里将新节点的next置空，不用考虑插入节点后的next指向了
	}
	if (ps->tail == NULL)//第一次入队列数据head和tail都是指向NULL的，直接让head和tail都指向第一个新节点
	{
		ps->head = ps->tail = newnode;
	}
	else
	{
		ps->tail->next = newnode;//将扩容节点插在tail后面
		ps->tail = newnode;//让tail指向到插入的节点处
	}
	++ps->size;//插入size就加1，记录此时队列节点的个数
}
void QueuePop(Queue* ps)//出队列（队列出数据就相当于单链表的头删）
{
	assert(ps);
	assert(!QueueEmpty(ps));//如果队列没有节点了，断言生效
	if(ps->head->next==NULL)//如果队列只剩下一个节点了，直接释放该节点，然后将头尾指针置空
	{
		free(ps->head);
		ps->head = ps->tail = NULL;
	}
	else
	{
		QN* cur = ps->head;//保存当前头节点
		ps->head = ps->head->next;//让头指针指向下一个节点
		free(cur);//释放之前的头节点
		cur = NULL;
	}
	--ps->size;//出一个数据size就减1
}
bool QueueEmpty(Queue* ps)//判断队列是否为空
{
	assert(ps);
	return ps->head == NULL && ps->tail == NULL;//头尾指针都指向NULL，队列才为空
}
DataType QueueFront(Queue* ps)//队头数据
{
	assert(ps);
	assert(!QueueEmpty(ps));
	return ps->head->data;
}
DataType QueueBack(Queue* ps)//队尾数据
{
	assert(ps);
	assert(!QueueEmpty(ps));
	return ps->tail->data;
}
int QueueSize(Queue* ps)//队列剩余数据个数
{
	assert(ps);
	return ps->size;
	/*QN* cur = ps->head;//不使用size的方法，遍历队列，如果偶尔查看数据个数还好，经常使用效率太慢了
	int capacity = 0;
	while (cur)
	{
		++capacity;
		cur = cur->next;
	}
	return capacity;*/
}

Test.c

#define _CRT_SECURE_NO_WARNINGS
#include"Queue.h"

// 通过前序遍历的数组"123#7###45##6##"构建二叉树
BTNode* BinaryTreeCreate1()
{
	BTNode* n1 = (BTNode*)malloc(sizeof(BTNode));
	assert(n1);
	BTNode* n2 = (BTNode*)malloc(sizeof(BTNode));
	assert(n2);
	BTNode* n3 = (BTNode*)malloc(sizeof(BTNode));
	assert(n3);
	BTNode* n4 = (BTNode*)malloc(sizeof(BTNode));
	assert(n4);
	BTNode* n5 = (BTNode*)malloc(sizeof(BTNode));
	assert(n5);
	BTNode* n6 = (BTNode*)malloc(sizeof(BTNode));
	assert(n6);
	BTNode* n7 = (BTNode*)malloc(sizeof(BTNode));
	assert(n7);

	n1->data = 1;
	n2->data = 2;
	n3->data = 3;
	n4->data = 4;
	n5->data = 5;
	n6->data = 6;
	n7->data = 7;

	n1->left = n2;
	n1->right = n4;
	n2->left = n3;
	n2->right = NULL;
	n3->left = NULL;
	n3->right = n7;
	n4->left = n5;
	n4->right = n6;
	n5->left = NULL;
	n5->right = NULL;
	n6->left = NULL;
	n6->right = NULL;
	n7->left = NULL;
	n7->right = NULL;

	return n1;
}

//通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate2(char* a, int* pi)//这里的*pi是下标，如果不使用下标在特殊情况下*pi下标对应的值会被后面的值给覆盖了
{
	if (a[*pi] == '#')//如果数组里面的元素是#，那么下标*pi就加加，到下一位
	{
		(*pi)++;
		return NULL;
	}
	BTNode* root = (BTNode*)malloc(sizeof(BTNode));//动态开辟root
	if (root == NULL)
	{
		perror("malloc fail\n");
		exit(-1);
	}
	root->data = a[(*pi)++];//二叉树的节点值就等于数组a里面的元素
	root->left = BinaryTreeCreate2(a, pi);//左子树递归
	root->right = BinaryTreeCreate2(a, pi);//右子树递归
	return root;//返回root就是返回我们构建出来的二叉树的起始地址
}

// 二叉树销毁
void BinaryTreeDestory(BTNode* root)
{
	if (root == NULL)
		return;
	BinaryTreeDestory(root->left);
	BinaryTreeDestory(root->right);
	free(root);
}

// 二叉树节点个数
int BinaryTreeSize(BTNode* root)
{
	return root == NULL ? 0 : BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1;
	//如果root不等于NULL,那么就返回左子树节点与右子树节点加上1的和，就是整个二叉树节点个数
}

// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root)
{
	if (root == NULL)
		return 0;
	if (root->left == NULL && root->right == NULL)//如果节点的左子树和右子树都为空，那么该节点就是叶子节点，返回1
		return 1;
	return BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);//左子树的叶子节点加上右子树的叶子节点
}

//二叉树高度/层次
int BinaryTreeHeight(BTNode* root)//这里的函数是有返回值的，所以左右子树递归结果要用一个int变量进行统计
{
	if (root == NULL)
		return 0;
	int leftheight = BinaryTreeHeight(root->left);//如果这里没有leftheight和下面的rightheight就接收不到左右子树的返回结果
	int rightheight = BinaryTreeHeight(root->right);
	return leftheight > rightheight ? leftheight + 1 : rightheight + 1;
	//因为是求树高，所以左右子树高度高的那一个加上根就是整个树的高度
}

// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
	assert(k > 0);
	if (root == NULL)
		return 0;
	if (k == 1)//如果k等于1，就直接返回1，因为左右子树递归到第k层的时候有且仅有一个节点
		return 1;
	//转换为求子树的k-1层
	return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);
	//左右递归，k依次减一，表示每次递归一层
}

// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, NDataType x)//与上面一样，函数有返回值的
{
	if (root == NULL)
		return NULL;
	if (root->data == x)//如果data等于x，直接返回root当前的地址
		return root;
	BTNode* left = BinaryTreeFind(root->left, x);//这里和下面都需要一个BTNode指针类型来接收左右子树递归返回的地址
	//if(left)//如果left不等于NULL,就返回left
	   //return left;
	BTNode* right = BinaryTreeFind(root->right, x);
	//if(right)//如果right不等于NULL,就返回right
		 //return right;
	//return NULL;//如果left和right都等于NULL,就返回NULL
	return left == NULL ? right : left;
	//这里是一个小妙招，如果left等于NULL,就返回right地址；即便是right是NULL,返回right也没错，因为left是NULL
}

// 二叉树前序遍历 
void BinaryTreePrevOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	printf("%d ", root->data);
	BinaryTreePrevOrder(root->left);
	BinaryTreePrevOrder(root->right);
}

// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	BinaryTreeInOrder(root->left);
	printf("%d ", root->data);
	BinaryTreeInOrder(root->right);
}

// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	BinaryTreePostOrder(root->left);
	BinaryTreePostOrder(root->right);
	printf("%d ", root->data);
}

// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)//使用队列最合适
{
	Queue p;
	QueueInit(&p);
	if (root)//如果树的节点不为空，就先把树的节点入进去
		QueuePush(&p, root);
	while (!QueueEmpty(&p))//如果队列不为空
	{
		BTNode* front = QueueFront(&p);//出队头数据
		QueuePop(&p);
		printf("%d ", front->data);//打印
		if (front->left)//上一层节点出的时候，带下一层左节点
			QueuePush(&p, front->left);
		if (front->right)//上一层节点出的时候，带下一层右节点
			QueuePush(&p, front->right);
	}
	printf("\n");
	QueueDestroy(&p);
}

// 判断二叉树是否是完全二叉树（使用层序遍历方法）
int BinaryTreeComplete(BTNode* root)
{//与上面一样，上一层节点出的时候带下一层节点，当出的节点为NULL时，后面数据必须都为NULL,否则就是错的
	Queue p;
	QueueInit(&p);
	if (root)//如果树的节点不为空，就先把树的节点入进去
		QueuePush(&p, root);
	while (!QueueEmpty(&p))
	{
		BTNode* front = QueueFront(&p);
		QueuePop(&p);
		if (front == NULL)//当出到NULL的时候就跳出
			break;
		QueuePush(&p, front->left);
		QueuePush(&p, front->right);
	}
	while (!QueueEmpty(&p))//到这里如果后面全是NULL，那么是完全二叉树
	{
		BTNode* front = QueueFront(&p);
		QueuePop(&p);
		if (front != NULL)
		{
			QueueDestroy(&p);//记得销毁
			return false;//如果后面有一个数据不是NULL,那么就不是完全二叉树
		}
	}
	QueueDestroy(&p);
	return true;
}


int main()
{
	BTNode* root = BinaryTreeCreate1();
	BinaryTreePrevOrder(root);//前序遍历
	printf("\n");
	BinaryTreeInOrder(root);//中序遍历
	printf("\n");
	BinaryTreePostOrder(root);//后序遍历
	printf("\n");

	printf("二叉树结点个数:%d\n", BinaryTreeSize(root));
	printf("二叉树叶子结点个数:%d\n", BinaryTreeLeafSize(root));
	printf("二叉树的高度:%d\n", BinaryTreeHeight(root));

	printf("节点%d的地址为:%p\n", 5, BinaryTreeFind(root, 5));
	BinaryTreeFind(root, 5)->data *= 10;//修改
	BinaryTreePrevOrder(root);//前序遍历
	printf("\n");

	//char a[18] = "ABD##E#H##CF##G##";
	//int pi = 0;
	BTNode* root = BinaryTreeCreate2(a, &pi);
	//root = BinaryTreeCreate2(a, &pi);
	//BinaryTreePrevOrder(root);//要用%c遍历

	BinaryTreeLevelOrder(root);//层序遍历

	printf("该二叉树是不是完全二叉树:%d\n", BinaryTreeComplete(root));//0表示不是完全二叉树，1表示是完全二叉树
	BinaryTreeDestory(root);//二叉树的销毁
	//BinaryTreeDestory(&root);
	root = NULL;
	return 0;
}

总结

到目前为止，我们有关二叉树的知识基础的全部讲完了！剩下二插树的知识等到c++内容再讲解更简单一些。下一期就进入我们初阶数据结构的最后一个大纲了——排序，大家一起加油！

ks不知火
关注
  • 4
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
链式二叉树递归创建及遍历.c
04-01
链式二叉树递归创建及遍历的完整代码
链式存储二叉树
chang二牛的专栏
01-16 777
1 创建二叉树 节点 public class TreeNode { //节点的权 int value; TreeNode leftNode; TreeNode rightNode; public TreeNode(int value){ this.value = value; } public TreeNode get...
链式二叉树-递归操作
专注于全栈开发领域
08-16 408
对于二叉树通常约定以前序遍历方式输入，若输入不正确是不会有什么显示的，这点要注意 假设二叉树为                   1          2               4              3                5  扩展后的二叉树                   1          2                  4  
【数据结构】链式二叉树（超详细）
最新发布
qq_74897518的博客
05-27 1055
链式二叉树
2.6-17假设二叉树采用二叉链存储结构存放，结点值为 int 类型，设计一个递归算法求 二叉树 bt 中所有结点值大于等于 k 的结点个数
qq_43192537的博客
10-09 8970
假设二叉树采用二叉链存储结构存放，结点值为 int 类型，设计一个递归算法求二叉树 bt 中所有结点值大于等于 k 的结点个数 #include "Btree.cpp" #include <bits/stdc++.h> int Nodenum(BTNode *bt,int k ) { if(bt == NULL) return 0; int lnum = Nodenum(bt...
数据结构：二叉树（链式结构的实现）
weixin_57663528的博客
12-06 699
二叉树递归遍历原来是这样子！！！
2.6-16假设二叉树采用二叉链存储结构存放，结点值为 int 类型，设计一个递归算法求二叉树 bt 中所有叶子结点值之和
热门推荐
qq_43192537的博客
10-09 1万+
假设二叉树采用二叉链存储结构存放，结点值为 int 类型，设计一个递归算法求二叉树 bt 中所有叶子结点值之和 //假设二叉树采用二叉链存储结构存放，结点值为 int 类型，设计一个递归算法求 //二叉树 bt 中所有叶子结点值之和 #include "Btree.cpp" #include <bits/stdc++.h> int LeafSum(BTNode *bt){ if(...
二叉树链式结构在递归形式下各个接口写法c语言实现
qq_39527730的博客
10-19 147
二叉树是数据结构里最重要的一大块内容，而用递归形式 下写出的二叉树代码整洁简短，是非递归形式不能比的。当然二叉树的非递归形式也是在递归思想的指导下写出的。递归形式最大的缺点就是不容易理解。需要静静的思考！ 那么我们首先定义一下二叉树的结构体定义出树上的节点 typedef char DataType； typedef struct Btree{ DataType _data; struc...
数据结构：二叉树（链式存储）
12-07
以上就是关于“数据结构：二叉树（链式存储）”的主要内容，包括了二叉树的链式存储结构，递归创建二叉树的方法，以及三种遍历策略的实现。这些知识对于理解和操作二叉树至关重要，也是数据结构和算法学习中的基础...
数据结构-二叉树的创建与遍历（链式存储结构）
11-13
二叉树作为数据结构中的重要概念，是用于表示有限数据集的一种方式，特别是链式存储结构。在这个主题中，我们将深入探讨如何创建二叉树以及如何遍历它们。 首先，我们来理解二叉树的基本概念。二叉树是由节点构成的...
数据结构 二叉树 链式
06-01
二叉树是数据结构中的一种重要类型，它具有特殊的结构，每个节点最多有两个子节点，通常分为左子节点和右子节点。在这个资源中，我们专注于二叉树的链式表示以及其遍历方法，这些都是理解和实现二叉树算法的关键。 ...
数据结构学习--二叉树及其应用
06-25
二叉树是数据结构中的重要概念，它是一种特殊的树形数据结构，每个节点最多只有两个子...通过这个程序，我们可以深入理解二叉树的链式存储结构和遍历算法，这对于后续学习其他复杂的数据结构和算法有着重要的基础作用。
C/C++数据结构（九） —— 链式二叉树
Edison's 小宇宙
11-05 2242
二叉树的顺序存储结构就是用一维数组存储二叉树中的结点，并且结点的存储位置，也就是数组的下标要能体现结点之间的逻辑关系，比如双亲与孩子的关系，左右兄弟的关系等。
链式二叉树的基本操作(C语言实现)
Brant_zero的博客
07-05 1472
本篇博客学习的是最普通的链式二叉树，这个结构在实际应用的中的作用并不是很大，但是我们仍要学习这个结构。学习这个结构的目的是为了以后我们研究更复杂的树型结构打下基础。废话不多说，直接开始。...
c语言实现二叉树(链式结构)
dong132697的博客
08-30 1365
当我们使用顺序结构实现了二叉树的存储后，接下来就是使用链式结构来实现二叉树的存储。
【数据结构】二叉树 —— 遍历二叉树 + 递归的分治（链式存储）
上上谦. 的博客
04-22 2571
文章目录前言：1. 二叉树的四种遍历结构：1.1 二叉树结构划分：1.2 二叉树的遍历结构：2.递归的分治思想3. 链式二叉树的创建：（BinaryTree）1.1 具体函数实现：1.2 创建二叉树1.2 前序遍历1.3 中序 / 后序遍历1.4 树中结点个的数分治思想测试函数 前言： 学习二叉树结构，最简单的方式就是遍历。所谓二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉树中的节点进行相应的操作，并且每个节点只操作一次。 访问结点所做的操作依赖于具体的应用问题。 遍历是二叉树上最重要的运
二叉树的学习
m0_63783532的博客
11-11 1382
2.n = n1 + 2n2 + 1（树的结点数 = 总度数 + 1，其中度为0的结点数有n0个，度数和为0×n0；1.n = n0 + n1 + n2（树的结点数 = 度为0的结点数 + 度为1的结点数 + 度为2的结点数）分析：第一层有1个结点；总共有1+2+2^2......+2^(h-1)=(1-2^h)/(1-2)=2^h-1。又推出若完全二叉树有2k个（偶数）个结点，则必有n1=1，n0=k，n2=k-1。若完全二叉树有2k-1个（奇数）个结点，则必有n1=0，n0=k，n2=k-1。
【数据结构】链式二叉树
weixin_74078718的博客
01-03 579
。
图解剖析，递归思想，使用二叉链建立一个二叉树并实现相关操作（数据结构）
qwerlw的博客
03-20 2669
在建立一个简单的二叉树之前，我们需要了解二叉树的特点与性质。 二叉树的特点： 1.二叉树不存在度大于2的结点。 2.二叉树是有序树，二叉树的子树有左右之分，次序不能颠倒。 3.空树也是二叉树，二叉树由一个根节点和两颗分别叫做左子树和右子树的二叉树构成。 对于任意二叉树，都是由以上几种情况复合而成。 二叉树的储存结构： 1.顺序结构，一般比较适合完全二叉树。 2.链式结构，用一个链表来表示一颗二叉树，用链来表...
二叉树的建立及其基本操作.doc
06-28
二叉树是一种常见的数据结构，它由节点组成，每个节点最多有两个子节点。在二叉树中，我们将根节点定义为第一个节点，并且从根节点开始，分别称为左子树和右子树。 在本实验中，我们首先介绍了两种二叉树的建立方法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值