链式二叉树

已于 2023-03-31 15:32:40 修改
阅读量380 收藏 4
点赞数 9
分类专栏： 数据结构 文章标签： 深度优先 算法 数据结构 c语言 广度优先
于 2023-03-31 01:04:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_70056514/article/details/129866322
版权

目录

一、结构体变量的声明

typedef char BTDataType;

typedef struct BinaryTreeNode
{
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
	BTDataType val;

}BTNode;

二、 通过前序遍历的数组构建二叉树

给定你一个通过前序遍历字符数组你将如何把它构建成一颗二叉树呢（字符串中‘#’代表NULL）？

这里最好的方法肯定是递归，因为这个是前序遍历的数组，是典型的DFS(深度优先)，而深度优先最适合的方法就是递归。

BTNode* BinaryTreeCreate(BTDataType* a, int* pi)
{
	assert(a);
	//如果遇到‘#’，那说明遇到NULL了，pi指向的下标需要++
	//跳过这个字符‘#’，然后返回一颗NULL树
	if (a[*pi] == '#')
	{
		(*pi)++;
		return NULL;
	}
	//动态开辟一颗子树
	BTNode* root = (BTNode*)malloc(sizeof(BTNode));
	if (root == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	//给这棵树赋值数组对应的字符
	root->val = a[*pi];
	(*pi)++;

	//再递归构造棵树的左子树和右子树
	root->left = BinaryTreeCreate(a, pi);
	root->right = BinaryTreeCreate(a, pi);

	//最后返回这颗树
	return root;

}

三、二叉树的销毁

void BinaryTreeDestory(BTNode* root)
{
	//如果遇到空树就返回
	if (root == NULL)
	{
		return;
	}

	//递归销毁这棵树的左子树和右子树
	BinaryTreeDestory(root->left);
	BinaryTreeDestory(root->right);

	//最后把这棵树的根销毁
	free(root);
	root = NULL;

}

四、统计二叉树结点的个数

int BinaryTreeSize(BTNode* root)
{
	//如果遇到空树，就返回0
	if (root == NULL)
	{
		return 0;
	}

	//否则就返回左子树的结点数+右子树的结点数+自己本身
	return BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1;

}

五、统计二叉树叶子节点(无左右孩子的节点)的个数

int BinaryTreeLeafSize(BTNode* root)
{
	//如果遇到空树就返回，那证明后面就没有子树了，也就没有叶子节点，返回0
	if (root == NULL)
	{
		return 0;
	}

	//如果这棵树的左子树和右子树都为NULL，那证明这个结点就是叶子节点(根据叶子节点的定义)，返回1
	if (root->left == NULL && root->right == NULL)
	{
		return 1;
	}
	//否则就返回左子树的叶子节点的个数+右子树叶子节点的个数
	else
	{
		return BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);
	}
}

六、求二叉树第K层的节点的个数

这个函数的实现思路是：求一颗二叉树的第K层的节点的个数可以看作是求左右子树的第K-1层的节点的个数。，这也是一种分治的思想，可以用递归来实现。

int BinaryTreeLevelKSize(BTNode* root, int k)
{
	//如果遇到空树，那就证明要么这一层就是所求的第K层的，要么就是
	//还没递归到第K层就出现了空树，无论是哪一种情况都说明这一层和
	//后面都不会有位于第K层的节点了，所以返回0
	//
	if (root == NULL)
	{
		return 0;
	}

	//如果K递减到，说明这一个跟节点就位于第K层，返回1
	if (k == 1)
	{
		return 1;
	}

	//否则就返回左子树的第K-1层的节点+右子树第K-1层的节点树
	return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);
}

七、查找值为x的节点并返回节点的地址

BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	//如果遇到空树就证明这一颗子树找不到x
	if (root == NULL)
	{
		return NULL;
	}

	//如果这棵树的根节点的值就是查找的x，就返回这个根节点
	//返回上一层调用这个函数的栈帧
	if (root->val == x)
	{
		return root;
	}

	//如果根节点不是要找的，就递归到左子树查找x
	BTNode* leftFind = BinaryTreeFind(root->left, x);
	//找到了就返回
	if (leftFind)
	{
		return leftFind;
	}

	//左子树找不到就递归到右子树查找
	BTNode* rightFind = BinaryTreeFind(root->right, x);
	//找到了就返回
	if (rightFind)
	{
		return rightFind;
	}

	//如果根不是，左子树找不到，右子树找不到，那就不可能找到这个值了
	//这里返回NULL是返回到上一层调用这个函数的栈帧中，并不是直接得出
	//结果，等到返回到第一层调用这个函数的栈帧后依然找不到这个值才是
	//真正的在这一整棵树都找不到这个值，建议话递归展开图理解
	return NULL;


	// 不能写成
	// return BinaryTreeFind(root->left, x) || BinaryTreeFind(root->right, x);
	// 因为这里要求的是返回节点的地址，
	//“||”是逻辑运算符，只能得到逻辑结果，即真或者加(0为假，非0为真)
	// 所以这样写的话直接返回的逻辑结果是布尔值，并不符合要求

	//不建议写成
	/*return BinaryTreeFind(root->left, x)
		? BinaryTreeFind(root->left, x)
		: BinaryTreeFind(root->right, x);*/
		//因为如果在左子树找到了这个节点，但是由于没有保存
		//导致返回的时候又要再找一遍，如果这棵树的深度越深，
		//那么再找一遍的话越往下的子树呗反复调用的次数就越多
		//大大降低了效率

}

八、二叉树的遍历

二叉树的前中后序遍历其实都是一样的递归思路的，只不过访问节点的时间不同。三个遍历都是按照一下这张图片这样走的。
在这里插入图片描述

8.1 前序遍历

先访问根节点，再递归访问左子树，最后递归访问右子树。


void BinaryTreePrevOrder(BTNode* root)
{
	//如果遇到空树就打印一个‘#’，再返回，
	// 这样能够更加直观地反映这棵树的真实的形状
	if (root == NULL)
	{
		printf("%c ",'#');
		return;
	}

	//否则先访问它的根节点，再递归访问它的左子树，最后递归访问它的右子树(这里的访问是打印)
	printf("%c ", root->val);
	BinaryTreePrevOrder(root->left);
	BinaryTreePrevOrder(root->right);

}

8.2 中序遍历

和前序遍历是一样的道理，只是访问根节点的时机不同，先递归访问左子树，再访问根节点，最后递归访问右子树。

void BinaryTreeInOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("%c ", '#');
		return;
	}

	BinaryTreeInOrder(root->left);
	printf("%c ", root->val);
	BinaryTreeInOrder(root->right);
}

8.3 后序遍历

先递归访问左子树，再访问右子树，最后递归访问根节点。

void BinaryTreePostOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("%c ", '#');
		return;
	}

	BinaryTreePostOrder(root->left);
	BinaryTreePostOrder(root->right);
	printf("%c ", root->val);
}

8.4 层序遍历

这个层序遍历就是一层一层的往下遍历，直到叶子节点。
这里的层序遍历是典型的BFS(广度优先)。
这里我们需要用到一个队列来协助这里的遍历才能使问题更加简化一些。
思路：首先是根节点先进队列，访问这个根节点，然后根节点出队列，在节点出队列的同时判断这个节点的左孩子节点是否为空，不为空就入队列，为空则不入，再判断右孩子节点是否为空，不为空就入队列，否则不入，循环以上的动作（根节点出队列的同时把左右孩子(不为空)的带进队列）当这个队列为空的时候，就证明这棵树遍历完了。

在这里插入图片描述

void BinaryTreeLevelOrder(BTNode* root)
{
	//如果传过来的是空树，那就直接返回了
	if (root == NULL)
	{
		return;
	}

	//否则创建一个队列
	Queue q;
	//初始化队列
	QueueInit(&q);
	//先把根节点入队列
	QueuePush(&q, root);

	//当队列为空的时候循环就结束了
	while (!QueueEmpty(&q))
	{
		//取队列头的元素
		BTNode* front = QueueFront(&q);
		
		//打印代表访问
		printf("%c ", front->val);
		//如果根节点的左孩子不为空，就把左孩子带进队列
		if (front->left)
		{
			QueuePush(&q, front->left);
		}
		//如果右孩子不为空，就把右孩子带进队列
		if (front->right)
		{
			QueuePush(&q, front->right);
		}

		//队列头的元素出队列
		QueuePop(&q);
	}

	//销毁队列
	QueueDestroy(&q);


}

九、判断一棵树是否是完全二叉树

这里要判断一棵树是否为完全二叉树，首先清楚什么叫完全二叉树，完全二叉树其实是所有的有效节点（不为NULL的节点）都是连续不间断的二叉树就是完全二叉树。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
通过观察以上的几棵树可发现，完全二叉树的所有的有效节点一定是连续的，我们就可以利用这个作为突破点来判断一颗树是否为完全二叉树了。
其实你会发现，这个判断一棵树是否为完全二叉树完全可以沿用二叉树的层序遍历的方法，因为完全二叉树的全部有效节点都是连续的，那么如果我们把二叉树的层序遍历的代码稍微修改一下，就是无论根节点的左子树和右子树是否为空都把它入队列，那么节点出队列的时候一旦遇到了NULL。如果队列中的这个空节点往后的节点中再出现有效节点（即不为NULL的节点），那么这棵树一定不是完全二叉树（由二叉树的性质决定的），如果队列一直出节点，直到队列为空也没有出现有效节点，那么这棵树就一定是完全二叉树。

在这里插入图片描述
在这里插入图片描述

bool BinaryTreeComplete(BTNode* root)
{
	//如果是空树，那么也认为是完全二叉树
	if (root == NULL)
	{
		return true;
	}

	//创建一个队列
	Queue q;
	QueueInit(&q);
	QueuePush(&q, root);
	while (!QueueEmpty(&q))
	{
		//取队列头的元素
		BTNode* front = QueueFront(&q);
		//队头元素出队列
		QueuePop(&q);
		//只要front不是NULL，就进它的左右孩子
		if (front)
		{
			QueuePush(&q, front->left);
			QueuePush(&q, front->right);
		}
		//遇到空就可以跳出循环去判断是否为完全二叉树了
		else
		{
			break;
		}
	}

	//只要队列不为空就一直判断是否存在有效节点
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		//如果遇到不为空的节点，即有效节点，就判定不是完全二叉树
		//返回false
		if (front)
		{
			QueueDestroy(&q);
			return false;
		}
	}

	//来到这里证明队列为空都没找到有效节点，证明该树是完全二叉树
	QueueDestroy(&q);
	return true;


}

十、代码汇总

1、Queue.h

#pragma once

//Queue.h

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

typedef BTNode* QNodeDataType;

typedef struct QueueNode
{
	struct QueueNode* next;
	QNodeDataType data;

}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;

}Queue;

extern void QueueInit(Queue* pq);
extern void QueueDestroy(Queue* pq);
extern void QueuePush(Queue* pq, QNodeDataType x);
extern void QueuePop(Queue* pq);
extern int QueueSize(Queue* pq);
extern bool QueueEmpty(Queue* pq);
extern QNodeDataType QueueFront(Queue* pq);
extern QNodeDataType QueueBack(Queue* pq);

2、Queue.c

#define _CRT_SECURE_NO_WARNINGS 1

//Queue.c

#include "Queue.h"

void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
	
}

void QueueDestroy(Queue* pq)
{
	assert(pq);
	
	//由于每一个结点都是malloc出来的，所以
	//需要遍历逐一释放队列内的结点，防止内存泄露
	QNode* cur = pq->head;
	while (cur)
	{
		//先保存需要释放的结点del，释放后cur迭代地走下去
		//直到cur为空就全部释放完了
		QNode* del = cur;
		cur = cur->next;
		free(del);
		del = NULL;
	}
	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}

void QueuePush(Queue* pq, QNodeDataType x)
{
	assert(pq);

	//申请结点
	QNode* newNode = (QNode*)malloc(sizeof(QNode));
	if (newNode == NULL)
	{
		perror("");
		return;
	}
	newNode->data = x;
	newNode->next = NULL;

	//第一次插入时由于队列为空，所以pq->head和pq->tail
	//都为空，则应该直接赋值结点的结构体给p->head和pq->tail
	//如果直接pq->tail->next = newNode程序会崩的，因为pq->tail为空
	//不能访问
	if (pq->head == NULL)
	{
		pq->head = pq->tail = newNode;
	}
	else
	{
		//插入到尾部
		pq->tail->next = newNode;

		//newNode更新为新的尾结点
		pq->tail = newNode;
	}

	//队列的数据数目+1
	pq->size++;
}

void QueuePop(Queue* pq)
{
	assert(pq);

	//删除的前提是不能队列为空
	assert(!QueueEmpty(pq));

	//如果只有一个结点的话，那删掉这个结点
	//同时把尾指针要置为NULL，不置空的话
	//尾指针就是一个野指针，存在越界访问的风险
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		//先保存下一个结点的地址，再释放当前的结点
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}

	//数目-1
	pq->size--;

}

int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->size == 0;
}

QNodeDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;
}

QNodeDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;

}

3、BinaryTree.h

#pragma once

//BinaryTree.h

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

typedef char BTDataType;

typedef struct BinaryTreeNode
{
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
	BTDataType val;

}BTNode;


// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
extern BTNode* BinaryTreeCreate(BTDataType* a, int* pi);
// 二叉树销毁
extern void BinaryTreeDestory(BTNode* root);
// 二叉树节点个数
extern int BinaryTreeSize(BTNode* root);
// 二叉树叶子节点个数
extern int BinaryTreeLeafSize(BTNode* root);
// 二叉树第k层节点个数
extern int BinaryTreeLevelKSize(BTNode* root, int k);
// 二叉树查找值为x的节点
extern BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
// 二叉树前序遍历 
extern void BinaryTreePrevOrder(BTNode* root);
// 二叉树中序遍历
extern void BinaryTreeInOrder(BTNode* root);
// 二叉树后序遍历
extern void BinaryTreePostOrder(BTNode* root);
// 层序遍历
extern void BinaryTreeLevelOrder(BTNode* root);
// 判断二叉树是否是完全二叉树
extern bool BinaryTreeComplete(BTNode* root);

4、BinaryTree.c

#define _CRT_SECURE_NO_WARNINGS 1

//BinaryTree.c

#include "BinaryTree.h"
#include "Queue.h"

BTNode* BinaryTreeCreate(BTDataType* a, int* pi)
{
	assert(a);
	//如果遇到‘#’，那说明遇到NULL了，pi指向的下标需要++
	//跳过这个字符‘#’，然后返回一颗NULL树
	if (a[*pi] == '#')
	{
		(*pi)++;
		return NULL;
	}
	//动态开辟一颗子树
	BTNode* root = (BTNode*)malloc(sizeof(BTNode));
	if (root == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	//给这棵树赋值数组对应的字符
	root->val = a[*pi];
	(*pi)++;

	//再递归构造棵树的左子树和右子树
	root->left = BinaryTreeCreate(a, pi);
	root->right = BinaryTreeCreate(a, pi);

	//最后返回这颗树
	return root;

}

void BinaryTreeDestory(BTNode* root)
{
	//如果遇到空树就返回
	if (root == NULL)
	{
		return;
	}

	//递归销毁这棵树的左子树和右子树
	BinaryTreeDestory(root->left);
	BinaryTreeDestory(root->right);

	//最后把这棵树的根销毁
	free(root);
	root = NULL;

}

int BinaryTreeSize(BTNode* root)
{
	//如果遇到空树，就返回0
	if (root == NULL)
	{
		return 0;
	}

	//否则就返回左子树的结点数+右子树的结点数+自己本身
	return BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1;

}

int BinaryTreeLeafSize(BTNode* root)
{
	//如果遇到空树就返回，那证明后面就没有子树了，也就没有叶子节点，返回0
	if (root == NULL)
	{
		return 0;
	}

	//如果这棵树的左子树和右子树都为NULL，那证明这个结点就是叶子节点(根据叶子节点的定义)，返回1
	if (root->left == NULL && root->right == NULL)
	{
		return 1;
	}
	//否则就返回左子树的叶子节点的个数+右子树叶子节点的个数
	else
	{
		return BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);
	}
}

int BinaryTreeLevelKSize(BTNode* root, int k)
{
	//如果遇到空树，那就证明要么这一层就是所求的第K层的，要么就是
	//还没递归到第K层就出现了空树，无论是哪一种情况都说明这一层和
	//后面都不会有位于第K层的节点了，所以返回0
	//
	if (root == NULL)
	{
		return 0;
	}

	//如果K递减到，说明这一个跟节点就位于第K层，返回1
	if (k == 1)
	{
		return 1;
	}

	//否则就返回左子树的第K-1层的节点+右子树第K-1层的节点树
	return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);
}

BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	//如果遇到空树就证明这一颗子树找不到x
	if (root == NULL)
	{
		return NULL;
	}

	//如果这棵树的根节点的值就是查找的x，就返回这个根节点
	//返回上一层调用这个函数的栈帧
	if (root->val == x)
	{
		return root;
	}

	//如果根节点不是要找的，就递归到左子树查找x
	BTNode* leftFind = BinaryTreeFind(root->left, x);
	//找到了就返回
	if (leftFind)
	{
		return leftFind;
	}

	//左子树找不到就递归到右子树查找
	BTNode* rightFind = BinaryTreeFind(root->right, x);
	//找到了就返回
	if (rightFind)
	{
		return rightFind;
	}

	//如果根不是，左子树找不到，右子树找不到，那就不可能找到这个值了
	//这里返回NULL是返回到上一层调用这个函数的栈帧中，并不是直接得出
	//结果，等到返回到第一层调用这个函数的栈帧后依然找不到这个值才是
	//真正的在这一整棵树都找不到这个值，建议话递归展开图理解
	return NULL;


	// 不能写成
	// return BinaryTreeFind(root->left, x) || BinaryTreeFind(root->right, x);
	// 因为这里要求的是返回节点的地址，
	//“||”是逻辑运算符，只能得到逻辑结果，即真或者加(0为假，非0为真)
	// 所以这样写的话直接返回的逻辑结果是布尔值，并不符合要求

	//不建议写成
	/*return BinaryTreeFind(root->left, x)
		? BinaryTreeFind(root->left, x)
		: BinaryTreeFind(root->right, x);*/
		//因为如果在左子树找到了这个节点，但是由于没有保存
		//导致返回的时候又要再找一遍，如果这棵树的深度越深，
		//那么再找一遍的话越往下的子树呗反复调用的次数就越多
		//大大降低了效率

}

void BinaryTreePrevOrder(BTNode* root)
{
	//如果遇到空树就打印一个‘#’，再返回，
	// 这样能够更加直观地反映这棵树的真实的形状
	if (root == NULL)
	{
		printf("%c ",'#');
		return;
	}

	//否则先访问它的根节点，再递归访问它的左子树，最后递归访问它的右子树(这里的访问是打印)
	printf("%c ", root->val);
	BinaryTreePrevOrder(root->left);
	BinaryTreePrevOrder(root->right);

}

void BinaryTreeInOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("%c ", '#');
		return;
	}

	BinaryTreeInOrder(root->left);
	printf("%c ", root->val);
	BinaryTreeInOrder(root->right);
}

void BinaryTreePostOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("%c ", '#');
		return;
	}

	BinaryTreePostOrder(root->left);
	BinaryTreePostOrder(root->right);
	printf("%c ", root->val);
}

void BinaryTreeLevelOrder(BTNode* root)
{
	//如果传过来的是空树，那就直接返回了
	if (root == NULL)
	{
		return;
	}

	//否则创建一个队列
	Queue q;
	//初始化队列
	QueueInit(&q);
	//先把根节点入队列
	QueuePush(&q, root);

	//当队列为空的时候循环就结束了
	while (!QueueEmpty(&q))
	{
		//取队列头的元素
		BTNode* front = QueueFront(&q);
		
		//打印代表访问
		printf("%c ", front->val);
		//如果根节点的左孩子不为空，就把左孩子带进队列
		if (front->left)
		{
			QueuePush(&q, front->left);
		}
		//如果右孩子不为空，就把右孩子带进队列
		if (front->right)
		{
			QueuePush(&q, front->right);
		}

		//队列头的元素出队列
		QueuePop(&q);
	}

	//销毁队列
	QueueDestroy(&q);


}


bool BinaryTreeComplete(BTNode* root)
{
	//如果是空树，那么也认为是完全二叉树
	if (root == NULL)
	{
		return true;
	}

	//创建一个队列
	Queue q;
	QueueInit(&q);
	QueuePush(&q, root);
	while (!QueueEmpty(&q))
	{
		//取队列头的元素
		BTNode* front = QueueFront(&q);
		//队头元素出队列
		QueuePop(&q);
		//只要front不是NULL，就进它的左右孩子
		if (front)
		{
			QueuePush(&q, front->left);
			QueuePush(&q, front->right);
		}
		//遇到空就可以跳出循环去判断是否为完全二叉树了
		else
		{
			break;
		}
	}

	//只要队列不为空就一直判断是否存在有效节点
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		//如果遇到不为空的节点，即有效节点，就判定不是完全二叉树
		//返回false
		if (front)
		{
			QueueDestroy(&q);
			return false;
		}
	}

	//来到这里证明队列为空都没找到有效节点，证明该树是完全二叉树
	QueueDestroy(&q);
	return true;


}

5、test.c

#define _CRT_SECURE_NO_WARNINGS 1

//test.c

#include "BinaryTree.h"

int main()
{
	char arr[] = "124##5##3#5##";
	int i = 0;
	BTNode* root = BinaryTreeCreate(arr, &i);
	BinaryTreePrevOrder(root);
	printf("\n");
	BinaryTreeInOrder(root);
	printf("\n");
	BinaryTreePostOrder(root);
	printf("\n");
	BinaryTreeLevelOrder(root);
	printf("\n");

	int ret = BinaryTreeComplete(root);
	if (ret == 1)
	{
		printf("root是完全二叉树\n");
	}
	else
	{
		printf("root不是完全二叉树\n");
	}
	printf("BinaryTreeSize:%d\n", BinaryTreeSize(root));

	printf("BinaryTreeLeafSize:%d\n", BinaryTreeLeafSize(root));

	printf("BinaryTreeLevelKSize:%d\n", BinaryTreeLevelKSize(root, 3));

	BTNode* find = BinaryTreeFind(root, '9');
	if (find)
	{
		printf("%c\n", find->val);
	}
	else
	{
		printf("NULL\n");
	}

	BinaryTreeDestory(root);
	root = NULL;

	return 0;
}

以上就是学习二叉树是需要学习的基本内容，你学会了吗？如果感到有所收获的话点亮一下小心心顺便点点关注呗，后续会持续更新数据结构的相关只是哦，关注博主不迷路，天天学习在进步！！！

Gay~
关注
  • 9
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
链式二叉树模板.cpp
03-29
链式二叉树模板，方便学习C语言数据结构。自行下载，只求积分！
编一个程序，读入用户输入的一串先序遍历字符串，根据此字符串建立一个二叉树（以指针方式存储）。
小雨的博客
01-26 1842
题目 编一个程序，读入用户输入的一串先序遍历字符串，根据此字符串建立一个二叉树（以指针方式存储）。例如如下的先序遍历字符串： ABC##DE#G##F### 其中“#”表示的是空格，空格字符代表空树。 建立起此二叉树以后，再对二叉树进行中序遍历，输出遍历结果。 代码 public static void main(String[] args) { Scanner scanner = new Scanner(System.in); while (scanner.hasNext
【C语言】判断一颗二叉树是否是完全二叉树
wzx0806的博客
08-01 1387
这就是完全二叉树的定义。一颗二叉树，它的每一层的节点都必须是全满的，不能有空。且同时，最后一层的节点也必须从左至右是连续存在的。那么，这颗树就是一颗完全二叉树。（满二叉树是特殊的完全二叉树）
判断一棵树是否为完全二叉树的算法c语言_别再翻了，面试二叉树看这 11 个就够了！||CSDN博客精选...
weixin_39601056的博客
12-03 410
作者：一只不甘平凡的小鹿数据结构与算法：不知道你有没有这种困惑，虽然刷了很多算法题，当去面试的时候，面试官让你手写一个算法，可能你对此算法很熟悉，知道实现思路，但是总是不知道该在什么地方写，而且很多边界条件想不全面，一紧张，代码写的乱七八糟。如果遇到没有做过的算法题，思路也不知道从何寻找。下面来介绍「初学者必会的 30 道数据结构与算法」如果你对数据结构和算法有了一定的了解和认识，那么可以尝试着解...
先序和中序遍历序列确定一颗二叉树（还原二叉树）
不完美的红烧肉的博客
07-12 7146
我用了两种方法解，分别是递归法和堆栈法。递归法是最简单的，学完递归法后，建议一定要学习堆栈法，因为递归程序实际上也是堆栈实现的。 分析： 例： 先序序列 a bcde fghij ; 中序序列 cbed a hgijf 对于根节点a，先序、中序序列可以分别分解为下图两棵树： 对于每个节点的左子树、右子树，按照同样的算法逐步分解，最后可以确认一棵唯一树。 实现递归算法后，虽然简单，而且代码逻辑清晰，
二叉树的基本操作和层序遍历及判断是否为完全二叉树
qq_57283958的博客
11-12 1207
二叉树的基本操作有： 1，前，中，后序遍历 2，求二叉树的节点个数 3，求二叉树叶子节点的个数 4，求二叉树的深度 5，求二叉树第K层节点的个数 6，二叉树的层序遍历 7，判断是否为完全二叉树 8，查找二叉树的节点 我们先构建一颗二叉树代码如下：头文件 banirytree.h #pragma once #include<stdio.h> #include<stdlib.h> #include<stdbool.h> #include<asser
链式二叉树三种遍历
08-08
【先序遍历】：先访问根节点，然后先序遍历左子树，再先序遍历右子树！ 【中序遍历】：中序遍历左子树，然后访问根节点，再中序遍历右子树！ 【后序遍历】：后序遍历左子树，然后后序遍历右子树，再访问根节点！
探讨:C++实现链式二叉树(用非递归方式先序,中序,后序遍历二叉树)
09-05
本篇文章是对用C++实现链式二叉树(用非递归方式先序,中序,后序遍历二叉树)的方法进行了详细的分析介绍，需要的朋友参考下
链式二叉树递归创建及遍历.c
04-01
链式二叉树递归创建及遍历的完整代码
二叉树(线索二叉树、链式二叉树、有序二叉树) 常见操作代码实现
04-08
内容概要：用c代码完成链式二叉树、有序二叉树、线索二叉树的的常见操作。其中包括构建、销毁、前序/后序/中序遍历、高度、密度、添加、删除、查询等操作 适合人群：具备一定编程基础，尤其是c语言基础，并很好地...
链式二叉树 部分参考代码
06-24
内部文件5个 按需求拼接添加即可 二叉树 链接二叉树的相关主要代码
链式二叉树的实现.sln
06-17
本例程详细讲解了链式二叉树的实现方法和实现的函数，对于学习数据结构中的链式二叉树具有很好的学习作用，可以充分理解二叉树的结构和特性
链式二叉树的后序创建、递归后序遍历、非递归堆栈后序遍历、后序销毁
06-13
链式二叉树的后序创建、递归后序遍历、非递归堆栈后序遍历、后序销毁
链式存储二叉树基本操作函数.rar
03-28
采用链式结构存放二叉树，实现二叉树的创建，实现二叉树的遍历（前序，后序，中序层次遍历），分别求二叉树的叶子结点和结点的数目，二叉树的查找，二叉树的深度。 。
二叉树层序遍历及判断完全二叉树
m0_74824254的博客
09-22 283
二叉树层序遍历及判断完全二叉树，图解及思路
判断是否为完全二叉树(两种方法)
热门推荐
yuiop123455的博客
11-07 4万+
完全二叉树也就是没有满的满二叉树，它的节点在每一层一定是连续分布的。如果出现哪一层中两个非空节点间隔一个空节点，那一定不是完全二叉树。如下图所示： 假设这棵完全二叉树有K层，因此我们可以总结一下完全二叉树的规律： 前K-2层：每个节点都有两个孩子，节点饱和 前K-1层：节点肯定是饱和的—>到达了最大值 第K-1层：不一定所有的节点都有孩子节点，如果有孩子节点，至少要是左孩子节点,有可能出现不饱和节点 方法一: 从上面的规律中我们可以知道： 完全二叉树的前k-1层一定是包和节点，第k-1层就可能
判断一个树是完全二叉树
Stillboring的博客
11-12 627
1064 甲级Complete Binary Search Tree(30分) 题目链接：https://pintia.cn/problem-sets/994805342720868352/problems/994805407749357568 A Binary Search Tree (BST) is recursively defined as a binary tree which has the following properties: The left subtree of a node.
判断二叉树是否为完全二叉树
weixin_46838716的博客
05-07 1万+
1）完全二叉树的定义是根据满二叉树来的，希望从左往右编号能跟满二叉树对应上，缺只能缺右边，不能缺左边。 2）判断完全二叉树的2个方法，一个事BFS遍历判断，就2个条件，关键看节点是否双全，第一次遇到不双全，今后都得是叶节点，第二个方法是树形DP，画图看看完全二叉树的几个条件。就明白了，自己要理解透彻。 3）笔试求AC，可以不考虑空间复杂度，但是面试既要考虑时间复杂度最优，也要考虑空间复杂度最优。
dfs链式二叉树查找路径
最新发布
11-11
以下是使用DFS算法在链式二叉树中查找路径的Python代码示例： ```python class TreeNode: def __init__(self, val): self.val = val self.left = None self.right = None def find_path(root, target): if ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值