数据结构——二叉树的基本操作及进阶操作

原创 已于 2024-10-21 23:14:51 修改
· 1.5k 阅读 · 14 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构

于 2024-10-21 23:05:42 首次发布

前言

介绍

 🍃数据结构专区：数据结构

参考

该部分知识参考于《数据结构（C语言版 第2版）》116 ~ 122页 及 《数据结构教程》201 ~ 213页

重点

树的基本实现并不难，重点在于对递归的理解才是树这部分知识带来的最大收获，因为树的逻辑结构就保证了使用递归思路来解决是最优的算法

由于树的基础知识太多，这里只进行简单解释，本篇主要是对基本操作代码的解释，后序的文章会跟进树的相关知识和性质的

🌈每一个清晨，都是世界对你说的最温柔的早安：ૢ(≧▽≦)و✨

目录

前言

1、二叉树的基础知识

1.1、定义与特点

1.2、基本形态与类型

1.3、性质与存储

1.4、遍历方法

2、链表树的操作

2.1 宏定义及结构体定义

2.2 前中后序遍历法

2.3 初始化树

2.4 创建新节点

2.5 创建树

2.6 销毁树

2.7 判空

2.8 求树的深度

2.9 根据值查找节点

2.10 求树根

2.11 求结点总数

2.12 输出叶子节点

2.13 计算值为x的节点所在的层数

2.14 计算第k层的节点数

2.15 复制二叉树

2.16 判断两棵树是否相似

2.17 查找某节点的双亲节点

2.18 其他一些不重要函数

2.19 整体代码（含测试代码）

结语

1、二叉树的基础知识

1.1、定义与特点

  • 定义：二叉树（Binary Tree）是树形结构的一个重要类型，是一种每个节点最多有两个子树（左子树和右子树）的有序树。

  • 特点：

    • 每个节点最多只能有两棵子树，且有左右之分，次序不能颠倒。
    • 二叉树可以是空树，或者由根节点和左、右子树组成，其中左子树和右子树也同样是二叉树。

1.2、基本形态与类型

  • 基本形态：

    • 空二叉树：没有任何节点的二叉树。
    • 只有一个根节点的二叉树。
    • 只有左子树或只有右子树的二叉树。
    • 完全二叉树：深度为k，有n个节点的二叉树，当且仅当其每一个节点都与深度为k的满二叉树中编号从1到n的节点一一对应时，称为完全二叉树。
    • 满二叉树：如果一棵二叉树只有度为0的节点和度为2的节点，并且度为0的节点在同一层上，则这棵二叉树为满二叉树。

  • 特殊类型：

    • 二叉查找树（Binary Search Tree）：左子树上的所有节点值均小于根节点值，右子树上的所有节点值均大于根节点值。
    • 平衡二叉树（如AVL树）：左右子树都是平衡二叉树，且所有节点左、右子树深度之差的绝对值不大于1。
    • 红黑树：除了具备二叉查找树的特性外，还有额外的特性以保持树的自平衡。
    • 哈夫曼树（Huffman Tree）：带权路径长度最短的树，常用于通信中的压缩编码。

1.3、性质与存储

  • 性质：

    • 二叉树的第i层上至多有2^(i-1)个节点。
    • 深度为h的二叉树中至多含有2^h-1个节点。
    • 在任意一棵二叉树中，若叶子节点数为n0，度为2的节点数为n2，则必有n0=n2+1。

  • 存储方式：

    • 顺序存储：使用数组来存储二叉树的节点，通常适用于完全二叉树。
    • 链式存储：使用链表来存储二叉树的节点，每个节点包含数据域和指向左、右子节点的指针。

1.4、遍历方法

  • 遍历：是对树的一种最基本的运算，指按一定的规则和顺序走遍二叉树的所有节点，使每一个节点都被访问一次，而且只被访问一次。

  • 遍历方法：

    • 先序遍历（Preorder Traversal）：访问根节点，然后遍历左子树，最后遍历右子树。
    • 中序遍历（Inorder Traversal）：遍历左子树，访问根节点，然后遍历右子树。中序遍历二叉排序树可得到一个关键字的有序序列。
    • 后序遍历（Postorder Traversal）：遍历左子树，遍历右子树，最后访问根节点。

2、链表树的操作

一、由于二叉树的顺序存储结构具有顺序存储结构的固有缺陷，使得二叉树的插入、删除等运算十分麻烦，所以对于一般二叉树通常采用链式存储方式

二、这里我采用左右孩子的存储方法

三、下面我会先把各函数代码进行简单介绍并粘贴出来，若有不懂的可以向下翻找会有函数的详细介绍

2.1 宏定义及结构体定义

#include<stdio.h>
#include<iostream>
using namespace std;

typedef char TElemType;
typedef struct BiTNode {
	TElemType data;
	struct BiTNode* lchild, * rchild;
}BiTNode, * BiTree;

2.2 前中后序遍历法

//前序递归遍历法
void PreOrder(BiTree T)
{
	if (T != NULL)
	{
		cout << T->data << " ";
		PreOrder(T->lchild);
		PreOrder(T->rchild);
	}
}

//中序递归遍历法
void InOrder(BiTree T)
{
	if (T != NULL)
	{
		InOrder(T->lchild);
		cout << T->data << " ";
		InOrder(T->rchild);
	}
}

//后序递归遍历法
void PostOrder(BiTree T)
{
	if (T != NULL)
	{
		PostOrder(T->lchild);
		PostOrder(T->rchild);
		cout << T->data << " ";
	}
}

2.3 初始化树

//初始化树
void InitTree(BiTree& T)
{
	T = NULL;
}

2.4 创建新节点

//创建新节点
BiTNode* CreatNewNode(TElemType value)
{
	BiTNode* node = new BiTNode;
	//等价于
	//BiTNode* node = (BiTNode*)malloc(sizeof(BiTNode));
	node->data = value;
	node->lchild = NULL;
	node->rchild = NULL;
	return node;
}

2.5 创建树

//创建树
void CreateTree(BiTree& T, char* definition)
{
	static int i = 0;  //静态变量，每次递归进入过程中都会i++
	char ch = definition[i++];
	if (ch == '#')
	{
		T = NULL;
	}
	else
	{
		T = CreatNewNode(ch);
		CreateTree(T->lchild, definition);
		CreateTree(T->rchild, definition);
	}
}

2.6 销毁树

//销毁树
void DestroyTree(BiTree& T)
{
	if (T != NULL)
	{
		DestroyTree(T->lchild);
		DestroyTree(T->rchild);
		free(T);
		T = NULL;
	}
}

2.7 判空

//判空
int TreeEmpty(BiTree T)
{
	if (T == NULL)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

2.8 求树的深度

//求树的深度
int TreeDepth(BiTree T)
{
	//定义左右子树的高度，作为最后返回时的比较值
	int lchildh = 0, rchildh = 0;
	if (T == NULL)
	{
		return 0;
	}
	else
	{
		lchildh = TreeDepth(T->lchild);
		rchildh = TreeDepth(T->rchild);
		return lchildh > rchildh ? lchildh + 1 : rchildh + 1;
	}
}

2.9 根据值查找节点

//查找某个节点
BiTNode* FindNode(BiTree T, TElemType x)
{
	BiTNode* p;//作为遍历
	if (T == NULL)
	{
		return NULL;
	}
	if (T->data == x)
	{
		return T;
	}
	
	//左递归查找
	p = FindNode(T->lchild, x);
	if (p != NULL)
	{
		return p;
	}
	else
	{
		//否则进行右递归查找
		return FindNode(T->rchild, x);
	}
}

2.10 求树根

//求树根
BiTNode* Root(BiTree T)
{
	if (T == NULL)
	{
		printf("ERROR:Tree is NULL!");
	}
	return T;
}

2.11 求结点总数

//求结点总数
int Nodes(BiTree T)
{
	if (T == NULL)
	{
		return 0;
	}
	return Nodes(T->lchild) + Nodes(T->rchild) + 1;
}

2.12 输出叶子节点

//输出叶子结点
void DispLeaf(BiTree T)
{
	if (T != NULL)
	{
		if (T->lchild == NULL && T->rchild == NULL)
		{
			cout << T->data << "  ";   //访问叶子节点
		}
		DispLeaf(T->lchild);  //输出左子树中的叶子节点
		DispLeaf(T->rchild);  //输出右子树中的叶子节点
	}
}

2.13 计算值为x的节点所在的层数

//计算某个节点值为x的层次（若在根结点 h = 1，树为空h = 0）
int Level(BiTree T, TElemType x, int h)
{
	int l;
	if (T == NULL)
	{
		return(0);
	}
	if (T->data == x)
	{
		return(h);
	}
	l = Level(T->lchild, x, h + 1);
	if (l != 0)
	{
		return(l);
	}
	else
	{
		return(Level(T->rchild, x, h + 1));
	}
}

2.14 计算第k层的节点数

//计算第k层的结点数
void LnodeNum(BiTree T, int h, int k, int& n)
{
	if (T == NULL)
	{
		return;//空树直接返回
	}
	//处理非空树
	if (h == k)
		n++;  //当前访问的结点在第k层时，n++
	else if (h < k) //若当前节点层次小于k,递归处理左右子树
	{
		LnodeNum(T->lchild, h + 1, k, n);
		LnodeNum(T->rchild, h + 1, k, n);
	}
}

2.15 复制二叉树

//复制二叉树
void Copy(BiTree T, BiTree& NewT)
{
	//复制一棵和T完全相同的二叉树
	if (T == NULL)
	{
		NewT = NULL;
		return;
	}
	else
	{
		NewT = new BiTNode;
		NewT->data = T->data;
		Copy(T->lchild, NewT->lchild);
		Copy(T->rchild, NewT->rchild);
	}
}

2.16 判断两棵树是否相似

//判断两棵树是否相似
bool Like(BiTree T1, BiTree T2)
{
	bool like1, like2;
	if (T1 == NULL && T2 == NULL)
	{
		return true;
	}
	else if (T1 == NULL || T2 == NULL)
	{
		return false;
	}
	else
	{
		like1 = Like(T1->lchild, T2->lchild);
		like2 = Like(T1->rchild, T2->rchild);
		return(like1 && like2);
	}
}

2.17 查找某节点的双亲节点

//查找某节点的双亲节点
//这里需要用到两个函数来完成
//1.辅助函数
BiTNode* ParentHelper(BiTNode* root, BiTNode* cur_e)
{
	if (root == NULL || cur_e == NULL)
	{
		return NULL;
	}
	//如果root节点的左右节点中某一个是目标节点
	if (root->lchild == cur_e || root->rchild == cur_e)
	{
		return root;
	}
	//进行左递归查找
	BiTNode* leftResult = ParentHelper(root->lchild, cur_e);
	if (leftResult != NULL)
	{
		return leftResult;
	}
	//否则递归查找右子树
	return ParentHelper(root->rchild, cur_e);
}
//2.查询函数
BiTNode* Parent(BiTree& T, BiTNode* cur_e)
{
	if (T == NULL || cur_e == NULL)
	{
		return NULL;
	}

	//调用辅助函数查找双亲节点
	return ParentHelper(T, cur_e);
}

2.18 其他一些不重要函数

//不重要函数
//求某个节点的值
TElemType Value(BiTree& T, BiTNode* cur_e)
{
	if (T == NULL || cur_e == NULL)
	{
		printf("ERROR:Tree or Node is NULL!");
		exit(1);
	}
	return cur_e->data;
}

//给某个节点赋值
void Assign(BiTree& T, BiTNode* cur_e, TElemType value)
{
	if (T == NULL || cur_e == NULL)
	{
		printf("ERROR:Tree or Node is NULL!");
		exit(1);
	}
	cur_e->data = value;
}

//求某节点的左孩子结点
BiTNode* LeftChild(BiTree T, BiTNode* cur_e)
{
	if (T == NULL || cur_e == NULL)
	{
		printf("ERROR: Tree or cur_e is NULL!");
		exit(1);
	}
	return cur_e->lchild;
}

//求某节点的右孩子结点
BiTNode* RightChild(BiTree T, BiTNode* cur_e)
{
	if (T == NULL || cur_e == NULL)
	{
		printf("ERROR: Tree or cur_e if NULL!");
		exit(1);
	}
	return cur_e->rchild;
}

2.19 整体代码（含测试代码）

#include<stdio.h>
#include<iostream>
using namespace std;

typedef char TElemType;
typedef struct BiTNode {
	TElemType data;
	struct BiTNode* lchild, * rchild;
}BiTNode, * BiTree;

//前序递归遍历法
void PreOrder(BiTree T)
{
	if (T != NULL)
	{
		cout << T->data << " ";
		PreOrder(T->lchild);
		PreOrder(T->rchild);
	}
}

//中序递归遍历法
void InOrder(BiTree T)
{
	if (T != NULL)
	{
		InOrder(T->lchild);
		cout << T->data << " ";
		InOrder(T->rchild);
	}
}

//后序递归遍历法
void PostOrder(BiTree T)
{
	if (T != NULL)
	{
		PostOrder(T->lchild);
		PostOrder(T->rchild);
		cout << T->data << " ";
	}
}

//初始化树
void InitTree(BiTree& T)
{
	T = NULL;
}

//创建新节点
BiTNode* CreatNewNode(TElemType value)
{
	BiTNode* node = new BiTNode;
	//等价于
	//BiTNode* node = (BiTNode*)malloc(sizeof(BiTNode));
	node->data = value;
	node->lchild = NULL;
	node->rchild = NULL;
	return node;
}

//创建树
void CreateTree(BiTree& T, char* definition)
{
	static int i = 0;  //静态变量，每次递归进入过程中都会i++
	char ch = definition[i++];
	if (ch == '#')
	{
		T = NULL;
	}
	else
	{
		T = CreatNewNode(ch);
		CreateTree(T->lchild, definition);
		CreateTree(T->rchild, definition);
	}
}

//销毁树
void DestroyTree(BiTree& T)
{
	if (T != NULL)
	{
		DestroyTree(T->lchild);
		DestroyTree(T->rchild);
		free(T);
		T = NULL;
	}
}

//清空树
//在C代码作为主要函数的代码下，清空树和销毁树是几乎一样的操作
//唯一差别在于，销毁树是树根也销毁，清空树保存其树根
//如果是C++代码下
//BinaryTree类中添加了一个析构函数（~BinaryTree()），它会在对象被删除时自动调用DestroyTree。
//这确保了即使用户忘记显式调用DestroyTree，内存也会被正确释放


//判空
int TreeEmpty(BiTree T)
{
	if (T == NULL)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

//求树的深度
int TreeDepth(BiTree T)
{
	//定义左右子树的高度，作为最后返回时的比较值
	int lchildh = 0, rchildh = 0;
	if (T == NULL)
	{
		return 0;
	}
	else
	{
		lchildh = TreeDepth(T->lchild);
		rchildh = TreeDepth(T->rchild);
		return lchildh > rchildh ? lchildh + 1 : rchildh + 1;
	}
}

//查找某个节点
BiTNode* FindNode(BiTree T, TElemType x)
{
	BiTNode* p;//作为遍历
	if (T == NULL)
	{
		return NULL;
	}
	if (T->data == x)
	{
		return T;
	}
	
	//左递归查找
	p = FindNode(T->lchild, x);
	if (p != NULL)
	{
		return p;
	}
	else
	{
		//否则进行右递归查找
		return FindNode(T->rchild, x);
	}
}

//求树根
BiTNode* Root(BiTree T)
{
	if (T == NULL)
	{
		printf("ERROR:Tree is NULL!");
	}
	return T;
}

//求结点总数
int Nodes(BiTree T)
{
	if (T == NULL)
	{
		return 0;
	}
	return Nodes(T->lchild) + Nodes(T->rchild) + 1;
}

//输出叶子结点
void DispLeaf(BiTree T)
{
	if (T != NULL)
	{
		if (T->lchild == NULL && T->rchild == NULL)
		{
			cout << T->data << "  ";   //访问叶子节点
		}
		DispLeaf(T->lchild);  //输出左子树中的叶子节点
		DispLeaf(T->rchild);  //输出右子树中的叶子节点
	}
}

//计算某个节点值为x的层次（若在根结点 h = 1，树为空h = 0）
int Level(BiTree T, TElemType x, int h)
{
	int l;
	if (T == NULL)
	{
		return(0);
	}
	if (T->data == x)
	{
		return(h);
	}
	l = Level(T->lchild, x, h + 1);
	if (l != 0)
	{
		return(l);
	}
	else
	{
		return(Level(T->rchild, x, h + 1));
	}
}

//计算第k层的结点数
void LnodeNum(BiTree T, int h, int k, int& n)
{
	if (T == NULL)
	{
		return;//空树直接返回
	}
	//处理非空树
	if (h == k)
		n++;  //当前访问的结点在第k层时，n++
	else if (h < k) //若当前节点层次小于k,递归处理左右子树
	{
		LnodeNum(T->lchild, h + 1, k, n);
		LnodeNum(T->rchild, h + 1, k, n);
	}
}

//复制二叉树
void Copy(BiTree T, BiTree& NewT)
{
	//复制一棵和T完全相同的二叉树
	if (T == NULL)
	{
		NewT = NULL;
		return;
	}
	else
	{
		NewT = new BiTNode;
		NewT->data = T->data;
		Copy(T->lchild, NewT->lchild);
		Copy(T->rchild, NewT->rchild);
	}
}

//判断两棵树是否相似
bool Like(BiTree T1, BiTree T2)
{
	bool like1, like2;
	if (T1 == NULL && T2 == NULL)
	{
		return true;
	}
	else if (T1 == NULL || T2 == NULL)
	{
		return false;
	}
	else
	{
		like1 = Like(T1->lchild, T2->lchild);
		like2 = Like(T1->rchild, T2->rchild);
		return(like1 && like2);
	}
}

//查找某节点的双亲节点
//这里需要用到两个函数来完成
//1.辅助函数
BiTNode* ParentHelper(BiTNode* root, BiTNode* cur_e)
{
	if (root == NULL || cur_e == NULL)
	{
		return NULL;
	}
	//如果root节点的左右节点中某一个是目标节点
	if (root->lchild == cur_e || root->rchild == cur_e)
	{
		return root;
	}
	//进行左递归查找
	BiTNode* leftResult = ParentHelper(root->lchild, cur_e);
	if (leftResult != NULL)
	{
		return leftResult;
	}
	//否则递归查找右子树
	return ParentHelper(root->rchild, cur_e);
}
//2.查询函数
BiTNode* Parent(BiTree& T, BiTNode* cur_e)
{
	if (T == NULL || cur_e == NULL)
	{
		return NULL;
	}

	//调用辅助函数查找双亲节点
	return ParentHelper(T, cur_e);
}


//不重要函数
//求某个节点的值
TElemType Value(BiTree& T, BiTNode* cur_e)
{
	if (T == NULL || cur_e == NULL)
	{
		printf("ERROR:Tree or Node is NULL!");
		exit(1);
	}
	return cur_e->data;
}

//给某个节点赋值
void Assign(BiTree& T, BiTNode* cur_e, TElemType value)
{
	if (T == NULL || cur_e == NULL)
	{
		printf("ERROR:Tree or Node is NULL!");
		exit(1);
	}
	cur_e->data = value;
}

//求某节点的左孩子结点
BiTNode* LeftChild(BiTree T, BiTNode* cur_e)
{
	if (T == NULL || cur_e == NULL)
	{
		printf("ERROR: Tree or cur_e is NULL!");
		exit(1);
	}
	return cur_e->lchild;
}

//求某节点的右孩子结点
BiTNode* RightChild(BiTree T, BiTNode* cur_e)
{
	if (T == NULL || cur_e == NULL)
	{
		printf("ERROR: Tree or cur_e if NULL!");
		exit(1);
	}
	return cur_e->rchild;
}


int main() {
	BiTree T, NewT;
	char definition[] = "ABD##E##CF##G#H##";

	// 测试初始化和创建树
	InitTree(T);
	CreateTree(T, definition);

	cout << "初始化树和创建树的测试:" << endl;

	// 测试遍历
	cout << "\n前序遍历: ";
	PreOrder(T);
	cout << "\n中序遍历: ";
	InOrder(T);
	cout << "\n后序遍历: ";
	PostOrder(T);

	// 测试TreeEmpty和TreeDepth
	cout << "\n\n树是否为空？ " << (TreeEmpty(T) ? "Yes" : "No");
	cout << "\n树深: " << TreeDepth(T);

	// 测试FindNode
	TElemType searchValue = 'D';
	BiTNode* foundNode = FindNode(T, searchValue);
	cout << "\n\n查找节点 '" << searchValue << "': "
		<< (foundNode ? "Found" : "Not found");

	// 测试Root
	BiTNode* root = Root(T);
	cout << "\n树根: " << (root ? root->data : ' ');

	// 测试Nodes和DispLeaf
	cout << "\n所有节点数: " << Nodes(T);
	cout << "\n叶子结点: ";
	DispLeaf(T);

	// 测试Level
	cout << "\n\n'E'所在的层数: " << Level(T, 'E', 1);

	// 测试LnodeNum
	int nodeCount = 0;
	LnodeNum(T, 1, 3, nodeCount);
	cout << "\n第3层的结点数: " << nodeCount;

	// 测试Copy
	Copy(T, NewT);
	cout << "\n\n复制一棵树，并进行中序遍历: ";
	InOrder(NewT);

	// 测试Like
	cout << "\n上面复制的树和原树是否相似? " << (Like(T, NewT) ? "Yes" : "No");

	// 测试Parent
	BiTNode* nodeE = FindNode(T, 'E');
	BiTNode* parentOfE = Parent(T, nodeE);
	cout << "\n\n'E'的双亲节点: " << (parentOfE ? parentOfE->data : ' ');

	// 清理内存
	DestroyTree(T);
	DestroyTree(NewT);

	cout << "\n\nAll tests completed." << endl;

	return 0;
}

结语

数据结构树这里的相关操作和知识点非常多，并且一环套一环，这里需要大家拥有较多的耐心来一步步走下去，相信一定会更好的！

实践 - 二叉树的基本操作
Junds0的博客
09-25 176
任务描述本关任务：编写程序，访问二叉树的先序末点和后序首点。相关知识为了完成本关任务，你需要掌握：理解二叉树的先序遍历和后序遍历的特点。typedef struct node /*二叉树结构定义*/char data;/*按前序遍历顺序建立一棵二叉树,通过引用类型返回树根地址 *//* t为指向树根结点的指针,返回先序遍历的最后一个结点地址,如果树为空，返回NULL*//* t为指向树根结点的指针,返回后序遍历的第一个结点地址，如果树为空，返回NULL*/
二叉树基本操作
m0_53223094的博客
11-21 1359
二叉树的一些基本操作
二叉树的基本操作-数据结构C++
hilws760的博客
09-18 398
③调用非递归中序遍历算法对建立好的二叉链表树进行遍历。要求显示遍历后的结点序列。非递归中序遍历算法需要用栈操作的函数。④调用层次遍历算法对建立好的二叉链表树进行遍历。要求显示遍历后的结点序列。层次遍历算法需要用队列操作的函数。②分别调用先序、中序和后序遍历递归算法对建立好的二叉链表树进行遍历。要求分别显示遍历后的结点序列。①从键盘输入结点编号及对应的结点值，可以分别以0和$作为结束标志。③实现二叉树的非递归的中序遍历算法。②二叉树的先、中、后序遍历。
二叉树的基本操作
最新发布
2502_90265864的博客
04-22 740
大家好！今天我们将一起探索中的重要成员——。二叉树是计算机科学中最基础也最强大的数据结构之一，广泛应用于等领域。理解二叉树不仅能帮助我们解决许多，更能培养，这对程序员来说至关重要。在本篇博客中，我将通过简洁的代码示例，带你实现二叉树的各种基本操作。我们会从最基础的结构定义开始，逐步实现等操作，最后完成。特别地，我会重点讲解其中的，因为理解递归是掌握二叉树操作的关键。无论你是数据结构初学者，还是想巩固二叉树知识的开发者，这篇文章都能为你提供清晰的指导和实用的代码示例。让我们开始这段探索二叉树世界的旅程吧。
【数据结构】二叉树的基本操作
qq_34168477的博客
10-06 1595
这样是为了保证左右子树都访问过了以后在访问根节点：当我们访问过左子树以后，弹出根节点，然后需要判断右子树是否访问过或者右子树是否为空，如果是的话就访问根节点，否则就将右子树的根节点压入栈中，然后再访问右子树的根节点的左子树，直到右子树为空或者右子树被访问过，就返回去访问根节点弹栈。该结构采用的是二叉树的左右链表示，即一个结构体中有三部分，一部分是二叉树节点本事的数据，其他两部分是指向二叉树下一个节点的指针，一个指向左子树，一个指向右子树。二叉树的存储方式哦同样有两种，一种是顺序存储，一种是链式存储。
数据结构——二叉树的层次遍历进阶
qq_50675813的博客
11-26 423
之前的一个博客 数据结构——二叉树的层次遍历看完这个，可以简单实现下面的问题 问题： 1.计算二叉树的最大宽度(二叉树的最大宽度是指二叉树所有层中结点个数的最大值。 2.用按层次顺序遍历二叉树的方法,统计树中具有度为1的结点数目。 解决问题的思路： int BiTree_height1(BiTree T)函数用于计算出树的高度（深度）； void levelOrder( BiTree T)；创建了一个记录每层树的宽度数组width[totalLevel] void printNodeAtLevel(BiT
数据结构——二叉树进阶
New_learner55的博客
12-28 444
在我看来，在数据结构中，存在三个最经典的树型结构，他们分别是二叉排序树（BST），二叉平衡树（AVL） 和 红黑树（BRT）。 二叉排序树又叫做二叉搜索树，它可以是一棵空树，也可以是具有三个性质的一棵二叉树。 性质一：若它的左子树不为空，则左子树上的所有结点的值均小于它的根结点的值 性质二： 若它的右子树不为空，则右子树上的所有结点的值均大于它的根结点的值 性质三： 左右子树也是二叉排序树。 构造二叉搜索树的目的是提高查找和插入删除关键字的速度。因为二叉排序树是一个排序好的有序数据集，查找的速度肯定是快于无
C++学习_进阶——（三）二叉树进阶
graceyun的博客
07-18 525
目录1 二叉搜索树1.1 二叉搜索树概念1.2 二叉搜索树操作1.3 二叉搜索树的实现1.4 二叉搜索树的应用 1 二叉搜索树 1.1 二叉搜索树概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 int a [] = {5,3,4,1,7,8,2,6,0,9}; 1.2 二叉搜索树操作 二叉搜索树的查找 二叉搜
算法和数据结构——左程云.zip
06-17
《算法和数据结构——左程云》是一份深入探讨计算机科学核心领域的资源包，由知名专家左程云编著。这份资料集主要聚焦于算法与数据结构的学习，这对于任何计算机科学专业的学生或软件开发者来说都是必不可少的基础...
非线性数据结构与算法-二叉树和图的应用探索-可实现的-有问题请联系博主，博主会第一时间回复！！！
12-06
内容概要：本文详细介绍了两个重要的非线性数据结构——二叉树和图的应用实例。对于二叉树，首先证明了完全二叉树和满二叉树的重要性质，随后探讨了使用二叉树表示算术表达式的可行性，最后通过具体的例子演示了如何...
二叉树的基本操作（共21个）
热门推荐
CXR_XC的博客
11-04 1万+
简单介绍二叉树，并给出二叉树的21种基本操作
二叉树的构建
li123128的博客
11-10 3553
二叉树是一种非常重要的数据结构。本文总结了二叉树的常见操作：二叉树的构建，查找，删除，二叉树的遍历(包括前序遍历、中序遍历、后序遍历、层次遍历)，二叉搜索树的构造等。
Symmetric Tree
aysd68784的博客
08-04 126
问题：判断二叉树是否为镜像二叉树分析：递归判断，根节点单独判断，然后递归左结点和右结点，之后每次一起递归左结点的左结点和右结点的右结点比较，左结点的右结点和右结点的左结点比较 /** * Definition for binary tree * struct TreeNode { * int val; * TreeNode *left; * ...
二叉树基本操作（一）
lxt-st
08-20 550
目录 一、二叉树的概念 二、二叉树的分类 满二叉树 && 完全二叉树 三、二叉树的基本操作 1、二叉树的创建 2、二叉树的销毁 3、求二叉树的高度 4、求二叉树叶子结点的个数 5、求二叉树结点的个数 6、求二叉树第 K 层结点的个数 7、判断一个节点是否在一棵二叉树中 注：完整代码请至 Github 查看：https://github.com/...
二叉树基础操作
weixin_63178060的博客
10-15 1312
层序遍历相对于前三种遍历，需要用队列进行辅助操作，具体操作：定义一个队列，首先将二叉树的第一个结点入队，while循环判断该队列是否为空，不为空的话，则先进行出队，然后判断该树的左又子树是否为空，不为空则入队。在销毁时，不能先销毁根结点，因为其左子树和右子树是通过根结点访问的，如果根结点先被销毁，则其左子树和右子树在后序程序中无法被访问，会出现错误。满二叉树：一个二叉树，如果其每一层的结点都达到最大值，即结点个数为2^k-1，k为二叉树层数，则该树为满二叉树。（n0为度为0的结点，n2为度为2的结点）
二叉树的使用方法
qq_30534935的博客
02-11 1398
转载： http://blog.jobbole.com/108184/ https://blog.youkuaiyun.com/zhanggonglalala/article/details/79738213 https://blog.youkuaiyun.com/heyanxi0101/article/details/79593542 一、概述 平衡树：所有结点左右子树深度差≤1 排序树：所有结点“左小右大 字典树：由...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值