【数据结构】二叉树BinaryTree

最新推荐文章于 2024-05-11 17:00:00 发布
最新推荐文章于 2024-05-11 17:00:00 发布
阅读量1k 收藏 22
点赞数 27
文章标签： 数据结构 算法 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/C0631xjn_/article/details/126928457
版权

目录

1🌲 二叉树的概念及结构

1.1 二叉树的概念

一棵二叉树是结点的一个有限集合，该集合有两种可能：

  1. 为空
  2. 由一个根结点和两棵分别名为左子树和右子树的二叉树组成

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

从上图我们得出结论：

  1. 二叉树中没有度大于2的结点
  2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

⭕对于二叉树层数的描述，一般地，我们定义二叉树的结点在第一层，那么空树的层次就是0，更加符合逻辑。
在这里插入图片描述

1.2 特殊的二叉树

  1. 满二叉树： 一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是 说，如果一个二叉树的层数为K，且结点总数是 ，则它就是满二叉树。
  2. 完全二叉树： 完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K 的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对 应时称之为完全二叉树。 通俗地理解，完全二叉树最后一层的结点必须是从左到右连续的，其他层的结点都是满的。 要注意的是满二叉树是一种特殊的完全二叉树。

⭕满二叉树一定是完全二叉树，二叉树不一定是满二叉树。
在这里插入图片描述

1.3 二叉树的性质

  1. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有 2i-1 个结点
  2. 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是 2h-1 （计算方法：20 +21+22+…+2h-1 = 2h-1）
  3. 对任何一棵二叉树,，如果度为0的叶结点个数为n0，度为2的分支结点个数为n2，则有 n0 = n2 + 1
  4. 完全二叉树中，假设总结点数为n，度为1的结点数为n1，则 当n为偶数时，n1 = 1，n为奇数时，n1 = 0
  5. 若规定根节点的层数为1，具有n个结点的满二叉树的深度， h = log(n+1) （ps：log(n+1)是log以2为底，n+1为对数）

  6. 若一颗二叉树的结点个数为n,则： n = n0+n1+n2，n-1 = 0*n0 + 1*n1 + 2*n2
  7. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对于序号为i的结点有：

若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点
若2i+1<n，左孩子序号：2i+1，2i+1>=n否则无左孩子
若2i+2<n，右孩子序号：2i+2，2i+2>=n否则无右孩子

🔪小试牛刀

1️⃣某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（ ）
A 不存在这样的二叉树
B 200
C 198
D 199
在这里插入图片描述

2️⃣在具有 2n 个结点的完全二叉树中，叶子结点个数为（ ）
A n
B n+1
C n-1
D n/2
在这里插入图片描述

3️⃣一棵完全二叉树的节点数位为531个，那么这棵树的高度为（ ）
A 11
B 10
C 8
D 12
在这里插入图片描述

1.4 二叉树的存储结构

💡 二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构

1. 顺序结构
顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。而现实中使用中只有堆才会使用数组来存储。二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。 在顺序存储中，我们利用二叉树的性质7(点击跳转查看)对所有结点进行编号，如下图。

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

2. 链式结构
二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是
链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所
在的链结点的存储地址 。

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

💬代码

typedef int DataType;

struct BinaryTreeNode
{
	struct BinaryTreeNode* leftChild;//指向当前结点左孩子
	struct BinaryTreeNode* rightChild;//指向当前结点右孩子
	DataType val;//当前结点数据域
};

2🌲 二叉树的顺序结构及实现

2.1 二叉树的顺序结构

普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。

2.2 什么是堆？

堆是一种特殊的二叉树。

  • 堆总是一颗完全二叉树
  • 堆中某个节点的值总是不大于或不小于其父节点的值

将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

⭕如图：

1. 小根堆
在这里插入图片描述
2. 大根堆
在这里插入图片描述

2.3 堆的实现

2.3.1 堆的向下、向上调整算法

1️⃣向下调整算法

💡在确保某个节点的左右子树都是一个堆的情况，我们可以对该节点进行向下调整。使其与它的左右子树合并成为一个新的堆。下面我们给出一个数组，逻辑上看它是一颗完全二叉树。

int a[] = {27,15,19,18,28,34,65,49,25,37};

在这里插入图片描述
不仅是根节点可以进行向下调整，其他任何满足左右子树都是一个堆的节点都可以进行向下调整。

💬代码实现

void Swap(int& a, int& b)
{
	int tmp = a;
	a = b;
	b = tmp;
}

// 向下调整算法
void AdjustDown(HeapDataType* a, int n, int parent)
{
	assert(a);
	int TheChild = parent * 2 + 1;
	//
	while (TheChild < n)//孩子的范围必须在数组下标范围内
	{
		//找到最小(最大)孩子
		if (TheChild + 1 < n && a[TheChild + 1] < a[TheChild])//根据建立大小堆改变符号
		{
			TheChild++;
		}

		//判断：最小(最大)孩子和父亲是否交换
		if (a[TheChild] < a[parent])
		{
			Swap(a[parent], a[TheChild]);
			//移动父亲和孩子的下标
			parent = TheChild;
			TheChild = parent * 2 + 1;
		}
		else//不用交换，则终止调整，跳出循环
		{
			break;
		}
	}
}
1️⃣向上调整算法(堆的插入)

💡堆的向上调整算法主要运用于堆的插入。将一个元素插入一个堆，并且插入后依然还是一个堆，需要用到向上调整算法。向上调整会让插入元素找到自己适当的位置，使得插入后的堆成为一个新的堆。下面我们给出一个数组，逻辑上看它是一颗完全二叉树。

int a[] = { 15,18,19,25,28,34,65,49,27,37 };

⭕插入的步骤图解如下 ：
在这里插入图片描述

📍主要分为两步：

  1. 先将元素插到堆的末尾，既最后一个元素后面
  2. 向上调整，恢复堆结构

第一步很简单，只需将元素插入数组的最后一个位置即可。不过，插入前记得给数组扩容，否则将导致溢出。

⭕ 这里我们主要关注向上调整算法如何实现

💬代码实现

void AdjustUp(int* a, int child)
{
	assert(a);
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] < a[parent])
		{
			Swap(a[child], a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

2.3.2 堆的创建

💭了解了关于堆的两种算法，是时候应该建个堆出来玩玩了！那么，如何创建一个堆呢？我们试着用堆的向下、向上调整算法分别实现。

⭕下面我们给出一个数组，这个数组逻辑上可以看做一颗完全二叉树，但是还不是一个堆，现在我们通过算
法，把它构建成一个堆（下面的建堆均默认为建大根堆）。

int a[] = {1,5,3,8,7,6};

💡根据向下调整的思想我们知道，若一颗完全二叉树的根节点左右都是堆，那么将该根节点向下调整后便能得到一个新的堆。我们可以想象下面这样的一棵树🌴
在这里插入图片描述
或是这样🌴
在这里插入图片描述

这是一颗很简单的树，左右子树都只有一个节点，甚至可以没有节点。那我们可以直接把左右子树都看成是一个堆（只有一个节点，符合堆的性质）。由此，我们只要将该树的根节点进行向下调整，整棵树就会变成一个新的堆了。

就像这样：
在这里插入图片描述
或是这样：
在这里插入图片描述

由特殊到普遍，每一颗二叉树不都是由多颗这样的小树构成的吗？
💡因此，我们不妨大事化小，从最后一个节点的父节点开始，按节点顺序从右到左从下到上依次向下调整。由于最下方的树向下调整一次后就变成堆了，我们再往上操作时，每棵树的根节点的左右子树都是堆，每次向下调整都是一个建堆的过程。最后每个节点都向下调整后，建堆完成。

⭕如图，由于树的最底层没有子树，因此无需调整。我们从最底层的上一层的最右边的节点（也就是最后一个节点的父节点）开始依次进行向下调整，直到整棵树的根节点调整完，堆就建出来了。
在这里插入图片描述

💬代码实现

//a {1,5,3,8,7,6}
void HeapCreat(HeapDataType* a, int n)
{
	assert(a);
	//找到第一个调整的节点
	int aN = ((n - 1) - 1) / 2;

	//第一个调整的节点往前的每个节点都要向下调整
	while (aN >= 0)
	{
		AdjustDown(a, n, aN);
		--aN;
	}
}

⭕通过调试可以看到，a就被建成一个大根堆了。
在这里插入图片描述

2.3.3 堆创建的时间复杂度

💭因为堆是完全二叉树，而满二叉树也是完全二叉树，此处为了简化使用满二叉树来证明(时间复杂度本来看的就是近似值，多几个节点不影响最终结果)：

在这里插入图片描述

💭上面讨论的是用向下调整法建堆。如果用向上调整来建堆呢？我们先讨论向上调整建堆的时间复杂度。和向下调整建堆一样，我们先列出向上调整每一层的节点数和节点需要移动的层数

在这里插入图片描述

🔎可以看到，使用向上调整法建堆，随着节点数的增多，需向上调整的层数也随之增多，那么要是用上面的方法计算时间复杂度，向上调整法建堆的时间复杂度将会非常大。而向下调整建堆恰恰相反，随着节点数的增多，需向下调整的层数随之减少，所以其时间复杂度会相对小。因此，我们不必再讨论向上调整建队，而是选择用向下调整建堆，提高效率。

2.3.4 堆的删除

堆的删除是删除堆顶元素，且删除后堆的结构不能被破坏。这里的逻辑其实很简单，只需要将堆顶元素与堆的最后一个元素交换位置，然后删除最后一个元素，并从根节点开始向下调整即可。

在这里插入图片描述

2.3.5 堆的总体代码实现

下面用C语言实现一下堆，及总结其各种接口
🍖Heap.h

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

typedef int HeapDataType;
typedef struct
{
	HeapDataType* arr;
	int size;
	int capacity;
}HP;

void HeapInit(HP* php);//堆的初始化
void HeapDestroy(HP* php);//堆的销毁
void HeapPrint(HP* php, int n);//打印堆
//
void HeapPush(HP* php, HeapDataType x);//堆的插入
void HeapPop(HP* php);//堆的删除
//
HeapDataType HeapTop(HP* php);//取堆顶的元素
size_t HeapSize(HP* php);//取堆的元素个数
bool HeapIsEmpty(HP* php);//判断堆是否为空
//
void AdjustDown(HeapDataType* arr, int n, int parent);
void AdjustUp(HeapDataType* arr, int child);
void Swap(HeapDataType* p1, HeapDataType* p2);

🍖Heap.c

#include "Heap.h"

void HeapInit(HP* php)//堆的初始化
{
	assert(php);
	php->capacity = php->size = 0;
	php->arr = NULL;
}

void HeapDestroy(HP* php)//堆的销毁
{
	assert(php);
	php->capacity = php->size = 0;
	free(php->arr);
	php->arr = NULL;
}

void HeapPrint(HP* php,int n)//打印堆
{
	assert(php);
	for (int i = 0;i < n;i++)
	{
		printf("%d ", php->arr[i]);
	}
	printf("\n");
}

bool HeapIsEmpty(HP* php)//判断堆是否为空
{
	assert(php);
	return php->size == 0;
}

void Swap(HeapDataType* p1, HeapDataType* p2)//交换数据
{
	HeapDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

void AdjustUp(HeapDataType* arr, int child)//向上调整
{
	assert(arr);
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (arr[parent] > arr[child])//1.
		{
			Swap(&arr[parent], &arr[child]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

void AdjustDown(HeapDataType* arr, int n, int parent)//向下调整
{
	assert(arr);
	int TheChild = parent * 2 + 1;
	while (TheChild < n)
	{
		if (TheChild + 1 < n && arr[TheChild + 1] > arr[TheChild])//根据建大堆还是小堆来确定符号
		{
			TheChild++;
		}
		if (arr[TheChild] > arr[parent])//
		{
			Swap(&arr[TheChild], &arr[parent]);
			parent = TheChild;
			TheChild = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void HeapPush(HP* php, HeapDataType x)//堆的插入
{
	assert(php);
	//在尾部插入数据
	if (php->capacity == php->size)
	{
		int newcapacity = (php->capacity == 0 ? 4 : 2 * php->capacity);
		HeapDataType* tmp = (HeapDataType*)realloc(php->arr, sizeof(HeapDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		//
		php->arr = tmp;
		php->capacity = newcapacity;
	}
	php->arr[php->size] = x;
	php->size++;
	
	//向上调整
	int child = php->size - 1;
	AdjustUp(php->arr, child);
}

void HeapPop(HP* php)//堆的删除
{
	assert(php);
	assert(!HeapIsEmpty(php));
	//交换堆顶和最后一个数据并删除
	Swap(&php->arr[0], &php->arr[php->size - 1]);
	php->size--;
	//向下调整
	AdjustDown(php->arr, php->size, 0);
}

HeapDataType HeapTop(HP* php)//取堆顶的元素
{
	assert(php);
	assert(!HeapIsEmpty(php));
	//
	return php->arr[0];
}

size_t HeapSize(HP* php)//取堆的元素个数
{
	assert(php);
	return php->size;
}

2.4 堆的应用

基于堆的特性，我们可以在不同的地方应用堆这个结构

2.4.1 堆排序

🍦堆排序就是运用堆进行排序，是一种比较高效的算法。实现堆排序分为两个步骤

  1. 建堆（升序建大堆，降序建小堆）
  2. 利用堆删除的思想进行排序

两个步骤都需要用到向下调整算法，因此掌握向下调整对堆排序的实现尤其重要。

⭕实现方法：

给定一个数组，要求将其排为升序：

int a[] = { 17,4,20,3,5,16 };

⭕图示过程如下：
在这里插入图片描述
💬代码实现：

void HeapSort(HeapDataType* a, int n)
{
	// 1.建堆
	HeapCreat(a, n);

	// 2.交换并删除
	int len = n;// len表示可更新的序列长度
	while (len > 1)
	{
		Swap(a[0], a[len - 1]);
		//
		--len;
		//
		AdjustDown(a, len, 0);
	}
}

⭕堆排序的时间复杂度

建堆的时间复杂度是O(N)。交换后重建堆一共需要n-1次循环，每次循环的比较次数为log(i)，则相加为：log2+log3+…+log(n-1)+log(n)≈log(n!)。由数学知识可以证明log(n!)和nlog(n)是同阶函数

因此，堆排序的时间复杂度为O(NlogN)

2.4.2 Top-K问题

TOP-K问题： 即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。
例如：点外卖时搜索附件评分排名前十的饭店、找出游戏中段位排名前五的玩家…这些情况下往往数据量巨大，如果将所有数据排序后再取前K项，效率会非常慢，甚至数据都可能无法一次性全部加载到内存中。

💡然而，利用堆的特性，我们可以高效地解决Top-K问题，基本思路如下：
（假设我们要从N个数据中取出前K个最大元素）

  1. 取数据的前K个元素建一个小堆（求前K大建小堆，求前K小建大堆）
  2. 后(N-K)个数据依次与堆顶元素比较，比堆顶元素大就替换堆顶元素，并向下调整重构堆

💭ps:求前K个最小元素只需第一步改为建一个大堆，第二步比较条件换一下符合即可。

最后，堆中留存的元素就是前K个最大元素

💡该思路的原理是：假设前K个元素就是前K个最大元素，用他们建成一个小堆后，假设堆里的K个元素就是前K个最大元素，堆顶元素就是最小元素。我们再取后(N-K)个元素依次与堆顶元素比较，若是大于堆顶元素（最小元素），说明该堆顶元素并不属于前K个最大元素，则将其替换并向下调整，得到新的堆，新的前K个最大元素。堆顶元素还是最小元素。这样反复地比较、替换、调整，最后便能得到真正的前K个最大元素。

💬代码实现

void PrintTopK(HeapDataType* a, int k, int n)
{
	// 1.建堆

	int* tmp = (int*)malloc(sizeof(HeapDataType) * k);
	if (tmp == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	int i = 0;
	for (i = 0;i < k;i++)
	{
		tmp[i] = a[i];
	}
	HeapCreat(tmp, k);

	// 2.比较、替换、调整
	
	for (i = k;i < n;i++)
	{
		if (a[i] > tmp[0])
		{
			tmp[0] = a[i];
			AdjustDown(tmp, k, 0);
		}
	}

	// 打印
	for (i = 0;i < k;i++)
	{
		printf("%d\n", tmp[i]);
	}
}

void TestTopk()
{
	int n = 10000;
	int* a = (int*)malloc(sizeof(int) * n);
	srand(time(0));
	for (size_t i = 0; i < n; ++i)
	{
		a[i] = rand() % 1000000;
	}
	a[5] = 1000000 + 1;
	a[1231] = 1000000 + 2;
	a[531] = 1000000 + 3;
	a[5121] = 1000000 + 4;
	a[115] = 1000000 + 5;
	a[2335] = 1000000 + 6;
	a[9999] = 1000000 + 7;
	a[76] = 1000000 + 8;
	a[423] = 1000000 + 9;
	a[3144] = 1000000 + 10;
	PrintTopK(a, 10, n);
}

⭕运行结果
在这里插入图片描述

⭕复杂度解析

  • 🏠 空间复杂度：O(K)
  • 🕞 时间复杂度： O( K+(N-K)logK )
    建堆时间复杂度O(N)，后面(N-K)次循环，每次向下调整logK次

3🌲 二叉树的链式结构及实现

二叉树的链式结构在OJ题中十分常见。在对链式二叉树进行各种操作时，最最最核心的思想就是——递归。为了方便我们学习，先手动创建一颗链式二叉树，后续再用递归的方法建立链式二叉树。

typedef int BTDataType;
typedef struct BinaryTreeNode
{
	BTDataType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;
//
BTNode* BuyNode(BTDataType x)
{
	BTNode* tmp = (BTNode*)malloc(sizeof(BTNode));
	if (tmp == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	//
	tmp->data = x;
	tmp->left = tmp->right = NULL;
}
//
BTNode* CreatBinaryTree()
{
	BTNode* node1 = BuyNode(1);
	BTNode* node2 = BuyNode(2);
	BTNode* node3 = BuyNode(3);
	BTNode* node4 = BuyNode(4);
	BTNode* node5 = BuyNode(5);
	BTNode* node6 = BuyNode(6);
	node1->left = node2;
	node1->right = node4;
	node2->left = node3;
	node4->left = node5;
	node4->right = node6;
	return node1;
}

🌲建出来的树如图所示：
在这里插入图片描述

3.1 二叉树的遍历

3.1.1 前序、中序、后序遍历

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

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

实现遍历的核心思想恰恰是递归思想
所谓递归，乃大事化小、小事化了，讲究分而治之的思想。

💬代码实现

//前序遍历
void PreOrder(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}

	printf("%d->", root->data);
	PreOrder(root->left);
	PreOrder(root->right);
}

在这里插入图片描述
📃前序遍历递归展开图
在这里插入图片描述

💨中序遍历和后序遍历的图解与前序遍历思路一致，不再展开。

//中序遍历
void InOrder(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}

	InOrder(root->left);
	printf("%d ", root->data);
	InOrder(root->right);
}

//前序遍历
void PostOrder(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}

	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->data);
}

⭕输出结果
在这里插入图片描述

3.1.2 层序遍历

🏯除了前序、中序、后序遍历外，我们还可以对二叉树进行层序遍历。设二叉树根节点所在层数为第一层，层序遍历就是先从根节点出发，然后从左到又访问第二层（也就是根节点的子节点）的节点，接着再从左到右访问第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。

💡层序遍历需要用到另一个简单的数据结构 —— 队列
总体思路如下：

  1. 根节点入队
  2. 反复访问队头元素，每次访问结束后使其出队，并使他的左右节点依次入队
    ps：队头元素为NULL时直接出队，更新队头元素

⭕过程如图
请添加图片描述
💬代码实现

//typedef BTNode* QueueDataType;
//入队的是指向二叉树节点的指针

void LevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	//
	QueuePush(&q, root);// 1. 根节点入队
	while (!QueueIsEmpty(&q))//队列为空时，停止循环
	{
		// 操作
		QueueDataType head = QueueFront(&q);
		printf("%d ", head->data);
		// 弹出队头
		QueuePop(&q);
		// 压入队头的左右子节点
		if (head->left)
		{
			QueuePush(&q, head->left);
		}
		if (head->right)
		{
			QueuePush(&q, head->right);
		}
	}
	//
	QueueDestroy(&q);
}
超人不会飞）
关注
数据结构——二叉树BinaryTree基本功能大全及代码实现（递归、非递归遍历、深度、结点数）
Jayphone17的博客
10-05 1170
一、需求分析与功能描述 现代社会生活中，计算机扮演着重要角色，而随着计算机运行速度的不断加快，对数据的处理能力也日益增强，因此，程序所涉及的数据很多，如何科学有效的对数据进行操作，使得计算机的时间和空间利用率最高是一个问题。针对这样的问题，我选择了二叉树对数据的各种操作作为我的课程设计主题，希望通过二叉树来提高对数据的处理能力，促进对数据结构课程的理解。 在二叉树的应用中，常常要求在树中查找...
java-二叉树binaryTree
08-05
在这个"java-二叉树binaryTree"主题中，我们将深入探讨二叉树的实现、操作以及相关的算法。 在Java编程语言中，二叉树可以被表示为一个类，这个类通常包含指向左右子节点的引用，以及可能包含的数据。下面是一个...
BinaryTree
03-22
This is a binary tree search implementation.
二叉树
qq_37365741的博客
10-22 611
二叉树： 是n(n>=0)个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树组成。 1）每个结点最多有两颗子树，所以二叉树中不存在度大于2的结点。 2）左子树和右子树是有顺序的，次序不能任意颠倒。 3）即使树中某结点只有一棵子树，也要区分它是左子树还是右子树。 斜树： 所有的结点都只有左子树的二叉树叫左斜树。所有结点都是只有右...
Binary Tree
不可不戒
04-12 605
Description Background  Binary trees are a common data structure in computer science. In this problem we will look at an infinite binary tree where the nodes contain a pair of integers. The tree i
C++数据结构实现之BinaryTree.zip
最新发布
06-04
本篇将重点讨论在C++中实现二叉树（Binary Tree）这一重要数据结构。 二叉树是一种非线性的数据结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。这种结构在很多算法和应用中都有广泛的应用，如搜索、...
exp3-BinaryTree.zip_二叉树的C语言实现_数据结构
09-20
二叉树是一种重要的数据结构，它在计算机科学中有着广泛的应用，例如文件系统、编译器、搜索引擎等。本文将详细介绍如何使用C语言实现二叉树，并深入探讨线索二叉树的概念及其构建方法。 首先，我们需要理解二叉树...
BinaryTree_demo.zip_DEMO_binary tree_二叉树
09-19
二叉树是一种重要的数据结构，它在计算机科学中扮演着至关重要的角色，特别是在算法和数据存储方面。在“BinaryTree_demo.zip”这个压缩包中，包含了一个名为“BinaryTreeDemo.exe”的可执行文件和一个...
BinaryTree.h
05-17
有序二叉树创建 有序二叉树查找 二叉树遍历 有序二叉树删除 类模版实现的有序二叉树
[HDU5573]Binary Tree
dxyinme-Zz
09-03 174
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others) 分数：2500，构造还是比较难的 Problem Description The Old Frog King lives on the root of an infinite tree. According to the law, eac...
二叉树(Binary Tree)
Catherine的笔记
03-26 1744
二叉树(Binary Tree) 1. 二叉树的概念及其特点 二叉树是树形结构的一种重要类型。 二叉树是每个结点最多有两个子树的树结构，通常子树被称作“左子树(left subtree)“和“右子树(right subtree)”。 二叉树的子树有左、右之分，其子树的次序不能颠倒。 注：二叉树是递归定义的，分支数最大不超过2的有根有序树。 2. 二叉树的五种不同形态 空二叉树，一个结点也没有，如图(1)。 只有
二叉树（Binary Tree）
kalvin_y_liu的博客
07-28 1192
二叉树（Binary Tree） 二叉树是一棵特殊的树，其结构简单但很重要。二叉树的特点是每个节点最多有两棵子树，并且有左右之分。 满二叉树 如果一棵二叉树的所有叶子节点都在最后一层，称为满二叉树。满二叉树的结点总数 =2^n-1 （n为层数）。如下图二叉是的层数为3，其结点总数为2^3-1=7 满二叉树 完全二叉树 一棵深度为k的有n个结点的二叉树，对树中的节点按从上至下、从左到右的顺序进行编号，如果
数据结构实验--------二叉树(Binary Tree)
小键233
01-03 2027
使用的教材是电子工业出版社出版的《Data Structures and Algorithm Analysis in C++  》（《数据结构与算法分析（C++）》（第三版）），作者是【美】Clifford A Shaffer，译者是张铭、刘晓丹等。所以，有些代码与书上给出来的几近相同，如有侵权，请联系本人（741239458@qq.com），我会删除文章的。         实验内容：
【数据结构】二叉树 (Binary Tree)
Living_Amethyst的博客
06-27 2270
二叉树快速入门
【数据结构】二叉树(Binary Tree)
炸掉地球的博客
05-11 307
二叉树是一种特殊的树，每个结点最多只能有两个子结点，即二叉树不存在度大于2的结点。 二叉树可以分为三个部分：根、左子树、右子树，每颗子树又可以划分为这三个部分，一直递归到叶子结点，叶子结点是其本身的根结点。 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树。
评论 24
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值