数据结构学习笔记（二叉树）总结与整理

最新推荐文章于 2023-05-18 16:20:15 发布
最新推荐文章于 2023-05-18 16:20:15 发布
阅读量440 收藏 2
点赞数 1
分类专栏： 数据结构与算法 C语言 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44814867/article/details/119926012
版权

数据结构学习笔记（二叉树）总结与整理

二叉树定义

概念：一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。
二叉树的特点：

  1. 每个结点最多有两棵子树，即二叉树不存在度大于2的结点。
  2. 二叉树的子树有左右之分，其子树的次序不能颠倒。
    二叉树的存储结构
    二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构
    二叉树的性质
  3. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有2^(i-1) 个结点.
  4. 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是2^h- 1.
  5. 对任何一棵二叉树, 如果度为0其叶结点个数为 n0, 度为2的分支结点个数为 n2,则有n0＝n2＋1
  6. 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h=Log2(n+1). (ps：Log2(n+1)是log以2为底，n+1为对数)
  7. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对于序号为i的结点有：
  8. 若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点
  9. 若2i+1<n，左孩子序号：2i+1，2i+1>=n否则无左孩子
  10. 若2i+2<n，右孩子序号：2i+2，2i+2>=n否则无右孩子

二叉树结构

数据结构中的二叉树：
在这里插入图片描述
结构定义：
在这里插入图片描述
代码表示：

二叉树结构体定义：

// An highlighted block
//结点结构
typedef struct BinTreeNode
{
	ElemType data;
	struct BinTreeNode *leftChild;
	struct BinTreeNode *rightChild;
}BinTreeNode;
//根节点管理
typedef  BinTreeNode* BinTree;
void BinTreeInit(BinTree *t);

二叉树常用操作

**初始化**

// An highlighted block
void BinTreeInit(BinTree *t)
{
	*t = NULL;
}

二叉树的创建

二叉树创建——**使用指针引用方式**

// An highlighted block
void BinTreeCreate_1(BinTree *t)
{
	ElemType item;//接收数据
	scanf("%c", &item);
	if(item == '#')//判断输入是否为一个结束标记
		*t = NULL;//是 说明这棵二叉树是空树
	else
	{
		*t = (BinTreeNode*)malloc(sizeof(BinTreeNode));//创建树（子树）根结点
		assert(*t != NULL);
		(*t)->data = item;//为结点赋值
		BinTreeCreate_1(&(*t)->leftChild);//创建左子树
		BinTreeCreate_1(&(*t)->rightChild);//创建右子树
	}
}

二叉树创建——**通过返回值返回二叉树**

// An highlighted block
BinTree BinTreeCreate_2()
{
	BinTreeNode *t;
	ElemType item;//接收数据
	scanf("%c", &item);
	if(item == '#')//判断输入是否为一个结束标记
		return NULL;//返回空
	//创建树（子树）根结点
	t = (BinTreeNode*)malloc(sizeof(BinTreeNode));
	assert(t != NULL);
	t->data = item;//为结点赋值
	t->leftChild = BinTreeCreate_2();//创建左子树
	t->rightChild = BinTreeCreate_2();//创建右子树
	return t;//返回所创建的树
}

二叉树创建——**使用二级指针**

// An highlighted block
void _BinTreeCreate(BinTreeNode **t)
{
	ElemType item;//接收数据
	scanf("%c", &item);
	if(item == '#')//判断输入是否为一个结束标记
		*t = NULL;//是 说明这棵二叉树是空树
	else
	{
	    //创建树（子树）根结点
		*t = (BinTreeNode*)malloc(sizeof(BinTreeNode));
		assert(*t != NULL);
		(*t)->data = item;//为结点赋值
		_BinTreeCreate(&(*t)->leftChild);//创建左子树
		_BinTreeCreate(&(*t)->rightChild);//创建右子树
	}
}

**二叉树创建——**传入要创建的二叉树的串进行创建

// An highlighted block
BinTree BinTreeCreate_3(char *str)
{
	BinTreeNode *t;
	if(*str=='#' || *str=='\0')//判断输入是否为一个结束标记
		return NULL;//是 说明这棵二叉树是空树
	//创建树（子树）根结点
	t = (BinTreeNode*)malloc(sizeof(BinTreeNode));
	assert(t != NULL);
	t->data = *str;//为结点赋值
	t->leftChild = BinTreeCreate_3(++str);//创建左子树
	t->rightChild = BinTreeCreate_3(++str);//创建右子树
	return t;
}

**根据前序遍历和中序遍历来创建二叉树**

// An highlighted block
BinTree BinTreeCreate_VLR_LVR(char *VLR, char *LVR, int n)
{
	if(n == 0)
		return NULL;
	int k = 0;
	//利用先序序列，查找根在中序序列的位置
	while(VLR[0] != LVR[k])
		k++;
    //创建根
	BinTreeNode *t = (BinTreeNode*)malloc(sizeof(BinTreeNode));
	assert(t != NULL);
	t->data = LVR[k];

	t->leftChild = BinTreeCreate_VLR_LVR(VLR+1, LVR, k);//创建t的左子树
	t->rightChild = BinTreeCreate_VLR_LVR(VLR+k+1, LVR+k+1, n-k-1);//创建右子树
	return t;
}

**根据中序和后序序列创建二叉树**

// An highlighted block
BinTree BinTreeCreate_LVR_LRV(char *LVR, char *LRV, int n)
{
    if(n == 0)
		t = NULL;
	else
	{
        //利用后序序列，查找根在中序序列的位置
		int k = 0;
		while(LRV[n-1] != LVR[k]) //后序需要从后往前找根
		   k++;
	    //创建根节点
        t = (BinTreeNode*)malloc(sizeof(BinTreeNode));
		assert(t != NULL);
		t->data = LVR[k];
	    //递归创建右树
         BinTreeCreate_LVR_LRV(t->rightChild,LVR+k+1,LRV+k,n-k-1);
  	    //递归创建左树
         BinTreeCreate_LVR_LRV(t->leftChild,LVR,LRV,k);
	    //返回树
	    return t;
}

递归方式二叉树的遍历

**前序遍历**

// An highlighted block
void BinTreePreOrder(BinTree t)
{
	if(t != NULL)//树不为空
	{
		printf("%c ", t->data); //访问（子树）根结点
		BinTreePreOrder(t->leftChild);//访问左子树
		BinTreePreOrder(t->rightChild);//访问右子树
	}
}

**中序遍历**

// An highlighted block
void BinTreeInOrder(BinTree t)
{
	if(t != NULL)//树不为空
	{
		BinTreeInOrder(t->leftChild);//访问左子树
		printf("%c ", t->data); //访问（子树）根结点
		BinTreeInOrder(t->rightChild);//访问右子树
	}
}

**后序遍历**

// An highlighted block
void BinTreePostOrder(BinTree t)
{
	if(t != NULL)
	{
		BinTreePostOrder(t->leftChild);
		BinTreePostOrder(t->rightChild);
		printf("%c ", t->data); 
	}
}

**层次遍历**（需要用到队列结构）

// An highlighted block
void BinTreeLevelOrder(BinTree t)
{
	if(t != NULL)
	{
		LinkQueue Q;//创建队列
		LinkQueueInit(&Q);//对队列初始化
		LinkQueuePush(&Q, t);//将二叉树根结点（地址）入队
		while(!LinkQueueEmpty(&Q))//判断队列是否为空
		{
			BinTreeNode *node = LinkQueueFront(&Q);//取（子树）根结点（地址）
			LinkQueuePop(&Q);//将（子树）根结点（地址）出队
			printf("%c ", node->data);//打印出（子树）根结点的数据
			if(node->leftChild != NULL)//判断该结点的左树是否为空
				LinkQueuePush(&Q, node->leftChild);//否 将左子树（地址）入队
			if(node->rightChild != NULL) //判断该结点右子树是否为空
				LinkQueuePush(&Q, node->rightChild);//否 将右子树（地址）入队
		}
	}
}

非递归方式二叉树的遍历

**非递归方式二叉树的前序遍历**（需要用到栈结构）

// An highlighted block
void BinTreePreOrder_NoR(BinTree t)
{
	if(t != NULL)//判断二叉树是否为空
	{
		LinkStack st; //申请一个栈
		LinkStackInit(&st);//初始化栈
		LinkStackPush(&st, t);//将二叉树的根结点入栈
		while(!LinkStackEmpty(&st))//判断栈顶是否为空
		{//否
			BinTreeNode *p = LinkStackTop(&st);//获取栈顶结点
			LinkStackPop(&st);//出栈
			printf("%c ", p->data);//打印数据
			/*这里需要注意的是栈结构是先进后出的，所以后访问的结点先入栈*/
			if(p->rightChild != NULL)//判断右子树是否为空
				LinkStackPush(&st, p->rightChild); //否 入栈
			if(p->leftChild != NULL)//判断左子树是否为空
				LinkStackPush(&st, p->leftChild);//否 入栈
		}
	}
}

**非递归方式二叉树的中序遍历**（需要用到栈结构）

// An highlighted block
void BinTreeInOrder_NoR(BinTree t)
{
	if(t != NULL)//判断二叉树是否为空
	{//不空
		LinkStack st;//设置一个栈结构
		LinkStackInit(&st);//初始化栈

		do
		{
			while(t != NULL)
			{
				LinkStackPush(&st, t);//将根结点入栈
				t = t->leftChild;//位置下移
			}
			BinTreeNode *p = LinkStackTop(&st);
			LinkStackPop(&st);//获取栈顶元素
			printf("%c ", p->data);//打印数据
			if(p->rightChild != NULL)//判断右子树是否为空
				t = p->rightChild;//访问右子树
		}
		while(!LinkStackEmpty(&st) || t!=NULL);
	}
}

**非递归方式二叉树的后序遍历**（需要用到栈结构）

// An highlighted block
void BinTreePostOrder_NoR(BinTree t)
{
	if(t != NULL)
	{
		BinTreeNode *prev = NULL;
		LinkStack st;//申请一个栈
		LinkStackInit(&st);//初始化

		do
		{
			while(t != NULL)
			{
				LinkStackPush(&st, t);//入栈
				t = t->leftChild;//指向左子树的根结点
			}
			BinTreeNode *p = LinkStackTop(&st);//获取栈顶元素
			if(p->rightChild==NULL || prev==p->rightChild)
			{
				LinkStackPop(&st);//出栈
				printf("%c ", p->data);
				prev = p;
			}
			else
				t = p->rightChild;
		}while(!LinkStackEmpty(&st));
	}
}

二叉树的其他功能

**二叉树的结点个数**

// An highlighted block
size_t Size(BinTree t)
{
	if(t == NULL)
		return 0;	
	//左孩子＋右孩子节点数+根节点数
	return Size(t->leftChild) + Size(t->rightChild) + 1;
}

**二叉树的高度**

// An highlighted block
size_t Height(BinTree t)
{
	size_t left_h, right_h;
	if(t == NULL)//判断二叉树是否为空，是 记录高度为0
		return 0;
    //求取左子树高度
	left_h = Height(t->leftChild);
	right_h = Height(t->rightChild);//求取右子树高度
	//返回：该二叉树高度=左子树与右子树的最大高度+1
	return (left_h > right_h ? left_h : right_h) + 1;
}

**二叉树叶子节点个数**

// An highlighted block
size_t LeafSize(BinTree t)
{
	if(t == NULL)
		return 0;
	if(t->leftChild==NULL && t->rightChild==NULL)
		return 1;
	return LeafSize(t->leftChild) + LeafSize(t->rightChild);
}

**二叉树第K层结点个数**

// An highlighted block
size_t LevelKSize(BinTree t, int k)
{
	if(t == NULL)
		return 0;
	if(k == 1)
		return 1;
	return LevelKSize(t->leftChild, k-1) + LevelKSize(t->rightChild, k-1);
}

**查找二叉树结点**

// An highlighted block
BinTreeNode* Find(BinTree t, ElemType key)
{
	BinTreeNode *p;
	if(t==NULL || t->data==key)//判断二叉树为空且判断结点值是否等于key值
		return t;
		//或者可以这么写
		//if(t == NULL) //判断二叉树是否为空
		//return NULL; //是  说明不存在，返回空
	//if(t->data == key) //否 判断结点值是否等于key值
		//return t; //是  返回结点地址
	p = Find(t->leftChild, key);//查找左子树
	if(p != NULL)//判断是否找到
		return p;//找到  返回结点地址
	// 没找到
	return Find(t->rightChild, key);// 查找右子树，返回查找结果
}

**查找某结点的父结点**

// An highlighted block
BinTreeNode* Parent(BinTree t, BinTreeNode *p)
{
	BinTreeNode *ret;
	if(t==NULL || t->leftChild==p || t->rightChild==p)
		return t;
	ret = Parent(t->leftChild, p);//查找t的左子树
	if(ret != NULL)//判断左子树中是否找到满足条件的结点
		return ret;
	return Parent(t->rightChild, p);//否，查找右子树
}

**克隆二叉树**

// An highlighted block
BinTreeNode* Clone(BinTree t)
{
	BinTreeNode *p;
	if(t == NULL)//判断t是否为空
		return NULL;//是 则无需拷贝，直接置空
    //把t拷贝到p
	p = (BinTreeNode*)malloc(sizeof(BinTreeNode));
	assert(p != NULL);
	p->data = t->data;
	p->leftChild = Clone(t->leftChild);//拷贝t左子树到p左子树
	p->rightChild = Clone(t->rightChild);//拷贝t右子树到p右子树
	return p;
}

**判断两个二叉树是否相等**

// An highlighted block
bool Equal(BinTree t1, BinTree t2)
{
	if(t1==NULL && t2==NULL)//t1与t2同为空，则返回true
		return true;
	if(t1==NULL || t2==NULL)//只要有一个为空，另外一个不为空则返回false
		return false;
	return ((t1->data==t2->data) && Equal(t1->leftChild, t2->leftChild)
	 && Equal(t1->rightChild, t2->rightChild));
}

**摧毁二叉树**

// An highlighted block
void BinTreeDestroy(BinTree *t)
{
	if(*t != NULL)//判断二叉树是否为空
	{
		BinTreeDestroy(&(*t)->leftChild);//清空左子树
		BinTreeDestroy(&(*t)->rightChild);//清空右子树
		free(*t);//清空（子树）根
		*t = NULL;//预防野指针
	}
}

堆（二叉树的顺序结构）

普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。
概念：
如果有一个关键码的集合K = {k0，k1， k2，…，kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki <= K2i+1 且 Ki<=K2i+2 ，则称为小堆(或大堆)。
将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。
性质：
1.堆中某个节点的值总是不大于或不小于其父节点的值；
2.堆总是一棵完全二叉树。
结构：
在这里插入图片描述

堆的实现

**堆的定义**

// An highlighted block
typedef struct Heap
{
	HeapElemType *heap;
	size_t        capacity;
	size_t        size;
}Heap;

**堆的初始化**

// An highlighted block
void HeapInit(Heap *php, int sz)
{
	php->capacity = sz;
	php->heap = (HeapElemType*)malloc(sizeof(HeapElemType) * php->capacity);
	assert(php->heap != NULL);
	php->size = 0;
}

**堆的创建**

// An highlighted block
void HeapCreate(Heap *php, HeapElemType ar[], int n)
{
	php->capacity = n;
	php->heap = (HeapElemType*)malloc(sizeof(HeapElemType) * php->capacity);
	assert(php->heap != NULL);
	for(int i=0; i<n; ++i)
		php->heap[i] = ar[i];
	php->size = n;
	///
	//调整堆
	int CurPos = (n - 1) / 2; //找到二叉树的最后一个分支
	while(CurPos >= 0)
	{
		_AdjustDown(php, CurPos);//向下调整
		CurPos--;
	}
}

**堆顶元素**

// An highlighted block
HeapElemType HeapTop(Heap *php)
{
	if(HeapIsEmpty(php))
	{
		printf("堆已空，不能取堆顶元素.\n");
		return;
	}
	return php->heap[0];
}

**堆的插入**（将数据插入到数组最后，再进行向上调整。）

// An highlighted block
void HeapInsert(Heap *php, HeapElemType v)
{
	if(HeapIsFull(php))
	{
		printf("堆空间已满，%d不能插入\n", v);
		return;
	}
	php->heap[php->size] = v;
	_AdjustUp(php, php->size);
	php->size++;
}

**堆的删除**（删除堆是删除堆顶的数据。将堆顶的数据和最后一个数据交换，然后删除数组最后一个数据，再进行
向下调整算法。）

// An highlighted block
void HeapRemove(Heap *php)
{
	if(HeapIsEmpty(php))
	{
		printf("堆已空，不能删除数据.\n");
		return;
	}
	//删除数据
	HeapElemType tmp = php->heap[0];
	php->heap[0] = php->heap[php->size-1];
	php->heap[php->size-1] = tmp;
	php->size--;
	//从根开始调整堆
	_AdjustDown(php, 0);
}

**判断二叉树是否是完全二叉树**

// An highlighted block
bool BinaryTreeComplete(BinTree t)
{
	LinkQueue Q;//定义队列
	LinkQueueInit(&Q);//初始化队列
	LinkQueuePush(&Q, t);//根入队
	while(!LinkQueueEmpty(&Q))//队列不空的前提下
	{
		BinTreeNode *p = LinkQueueFront(&Q);//取队头
		LinkQueuePop(&Q);//出队
		if(p != NULL)
		{
			LinkQueuePush(&Q, p->leftChild);//左树入队
			LinkQueuePush(&Q, p->rightChild);//右树入队
		}
		else
		{
			while(!LinkQueueEmpty(&Q))
			{
				p = LinkQueueFront(&Q);
				LinkQueuePop(&Q);
				if(p != NULL)
					return false;
			}
		}
	}
	return true;
}

**堆的展示**

// An highlighted block
void HeapShow(Heap *php)
{
	for(int i=0; i<php->size; ++i)
		printf("%d ", php->heap[i]);
	printf("\n");
}

向下调整算法：
先设定根节点为当前节点(通过下标获取，标记为cur)，比较左右子树的值，找出更小的值，用child来标记。比较child和cur的值，如果child比cur小，则不满足小堆的规则，需要进行交换。如果child比cur大，满足小堆的规则，不需要交换，调整结束。处理完一个节点之后，从当前的child出发，循环之前的过程。向下调整（小堆）示例：
在这里插入图片描述

**向下调整算法**

// An highlighted block
void _AdjustDown(Heap *php, int start)
{
	int i = start;
	int j = 2*i + 1;
	while(j < php->size)
	{
		if(j+1<php->size && php->heap[j+1]>php->heap[j])
			j++;

		if(php->heap[j] > php->heap[i])
		{
			HeapElemType tmp = php->heap[j];
			php->heap[j] = php->heap[i];
			php->heap[i] = tmp;

			i = j;
			j = 2*i + 1;
		}
		else
			break;
	}
}

向上调整算法：
先设定倒数的第一个叶子节点为当前节点(通过下标获取，标记为cur)，找出他的父亲节点，用parent来标记。比较parent和cur的值，如果cur比parent小，则不满足小堆的规则，需要进行交换。如果cur比parent大，满足小堆的规则，不需要交换，调整结束。处理完一个节点之后，从当前的parent出发，循环之前的过程。
在这里插入图片描述

**向上调整算法**

// An highlighted block
void _AdjustUp(Heap *php, int start)
{
	int j = start;
	int i = (j-1) / 2;

	while(j > 0) //说明没有调整到根节点
	{
		if(php->heap[j] > php->heap[i])
		{
			//交换数据
			HeapElemType tmp = php->heap[j];
			php->heap[j] = php->heap[i];
			php->heap[i] = tmp;

			//向上回溯
			j = i;
			i = (j-1) / 2;
		}
		else
			break;
	}
}

**堆的摧毁**

// An highlighted block
void HeapDestroy(Heap* php)
{
	free(php->heap);
	php->heap = NULL;
	php->capacity = php->size = 0;
}

**判断堆是空还是满的**

// An highlighted block
bool HeapIsFull(Heap *php)
{
	return php->size >= php->capacity;
}
bool HeapIsEmpty(Heap *php)
{
	return php->size == 0;
}

堆的排序的基本思想：
将待排序序列构造成一个大顶堆此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n-1个元素的次小值。如此反复执行，便能得到一个有序序列了。

康x呀
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构学习笔记（栈、队列）整理与总结
weixin_44814867的博客
08-21 537
数据结构学习笔记（栈、队列）整理与总结栈栈结构之顺序栈的基本介绍顺序栈的常用操作栈结构之链栈的基本介绍链栈的常用操作队列顺序队列链队列三级目录 栈 栈的概念： 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据也在栈顶。 结构： 栈结构之顺序栈的基本介绍 概念： 栈是限
数据结构学习笔记（一）-链表和栈
weixin_42666900的博客
03-30 1013
数据结构学习笔记（一） 一、预备知识 0 读程序的步骤 0.0数据结构 数据结构是专门研究数据存储的问题 数据的存储包含两个方面：个体的存储+个体关系的存储 算法是对存储数据的操作 0.1 读程序的步骤 流程 功能 试数 1.指针 略 2.结构体 2.1为什么会出现结构体 ​ ①为了表示一些复杂的数据，而普通的基本类型无法满足要求 ​ ②在给所有变量添加一个共同的特征，那相关的变量联系起来 2.2什么叫结构体 ​ 结构体用户根据实际需要自己定义的复合数据类型 2
数据结构学习笔记——树、二叉树和森林
小宇y的博客
07-19 4180
（一）树的概念 （二）结点 叶子结点、孩子结点、双亲结点、兄弟结点： 1、也称为终端结点，它是没有子结点的结点（度为0），例如上图中，D、E、F、G都是叶子结点； 2、一个结点的后继结点称为该结点的，例如上图中，A的孩子结点是B、C； 3、一个结点称为其后继结点的，例如上图中，B、C的双亲结点是A，D、E的双亲结点是B； 4、在同一双亲结点下的孩子结点互为，例如上图中，B、C互为兄弟结点，它们有共同的双亲A，另外D、E互为兄弟结点，它们有共同的双亲B。（三）树的性质 1、树中结点的子结点（孩子）个数称为该，
二叉树学习笔记
ex_voda的博客
08-22 212
二叉树的基本概念和功能代码
二叉树笔记
m0_74053777的博客
01-13 109
二叉树（待补充）
树
candice_blanche的博客
02-18 288
 常用数据逻辑结构 集合——数据元素间除“同属于一个集合”外，无其它关系 线性结构——一个对一个，如线性表、栈、队列 树形结构——一个对多个，如树 图形结构——多个对多个，如图   树形结构特点：非线性结构，只有一个直接前驱， 但可能有多树形结构特点：非线性结构，只有一个直接前驱， 但可能有多个直接后继（1：n）个直接后继（1：n）   树型结构（非线性结构）：结点之间一
二叉树 — 学习笔记(一)
qq_40114716的博客
03-15 1670
学习笔记： 二叉树主要分为满二叉树和完全二叉树（无数值） 满二叉树：1、一棵树只有度为2的节点和度为0的节点。 2、度为0的节点在同一层上 完全二叉树：1、除最底层节点可能没填满外，其余每层节点数都达到最大值。 2、最下面一层的节点都集中在该层最左边的位置。 二叉搜索树 ：有序树。 若左子树不为空，则左子树上所有结点的值均小于它的根节点的值。 若右子树不为空，则右子树上所有结点的值均大于它的根节点的值。 它的左、右子树也分别为二叉排序树。 平衡二叉搜索树：又称为AVL树（Adelson-V
数据结构看书笔记---lazyfennec整理精选
11-15
"数据结构看书笔记---lazyfennec整理精选"是一份由lazyfennec精心整理的数据结构学习资料，旨在帮助学习者深入理解并掌握这一领域的重要概念和算法。 笔记可能涵盖了以下几个关键知识点： 1. **数组**：数组是最...
尚硅谷老韩java版算法和数据结构讲解代码笔记整理.zip
最新发布
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： ...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
考研笔记（数学+802数据结构）.zip
01-16
笔记不仅梳理了基本概念，还深入讲解了各种数据结构的实现及优化策略，如二叉树的遍历、图的DFS与BFS、快速排序与归并排序等，旨在提升考生的实际编程能力和算法分析能力。 总结起来，这份“考研笔记（数学+802数据...
数据结构看书笔记---精选lazyfennec整理
11-15
这份由lazyfennec精心整理的"数据结构看书笔记"涵盖了数据结构的主要内容，对于复习或学习这个主题非常有帮助。 一、线性结构 线性结构是最基础的数据结构，包括数组、链表和队列等。数组是一种静态存储结构，元素...
二叉树知识总结
追光少年的博客
07-19 2610
数组的搜索比较方便，可以直接用下标，但删除和插入就比较麻烦；链表与之相反，删除和插入元素很快，但查找比较慢；此时，二叉树应运而生，二叉树既有链表的好处，也有数组的好处，在处理大批量的动态数据时比较好用，是一种折中的选择。文件系统和数据库系统一般都是采用树（特别是B树）的数据结构数据，主要为排序和检索的效率。二叉树是一种最基本最典型的排序树，用于教学和研究树的特性，本身很少在实际中进行应用，因为缺点太明显，就像冒泡排序一样，因为效率问题并不实用，但也是我们必须会的。//默认null。...
二叉搜索树
qq_44688635的博客
09-27 126
二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。二叉搜索树作为一种经典的数据结构，它既有链表的快速插入与删除操作的特点，又有数组快速查找的优势；所以应用十分广泛，例如在文件系统和数据库系统一般会采用这种数据结构进行高效率的排序与检索操作。 ...
【数据结构与算法】————二叉树全面总结
热门推荐
stormzhuo的博客
02-06 1万+
二叉树 二叉树定义 n（n ≥ 0）个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树的二叉树组成 二叉树有什么特点？ 每个结点最多有两棵子树 二叉树是有序的，其次序不能任意颠倒，即子树有左右之分，顺序不能颠倒 二叉树的基本术语 左斜树： 所有结点都只有左子树的二叉树 右斜树： 所有结点都只有右子树的二叉树 斜树： 左斜树和右斜树的统称 斜树有什么特点呢？ 每一层只有一个结点 结点个数与其深度相同 斜树是树结构的特例，是从树结构
二叉树总结
m0_47296354的博客
05-18 364
一、二叉树的基本知识 1、一些二叉树的定义 1.1满二叉树： 只有度为0和度为2的节点，并且度为0的结点在同一层上 深度为k的满二叉树，有2^k-1个结点 1.2 完全二叉树： 在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。 1.3 二叉搜索树： 面介绍的树，都没有数值的，而二叉搜索树是有数值的了，二叉搜索树是一个有序树。 1、若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 2、若它的右子树不空，则右子树上所有
数据结构基础学习——二叉树的知识总结
m0_60502858的博客
11-19 3001
目录 二叉树的概念和性质 二叉树顺序结构及实现 二叉树链式结构及实现 二叉树的前 、中、后序遍历 二叉树基础题练习 1.二叉树的概念 二叉树是树的结构中最常用的一种结构，它的形式是一个结点最多可以有两个子节点，即左结点和右结点。用图表示如下 可以看出二叉树中不存在度超过2的结点，而且二叉树的子树有左右之分，次序不能颠倒，二叉树是一颗有序树，对于任意一颗二叉树都是由以下几种结构复合而成的。 二叉树中又分有两种特殊的树，即满二叉树和完全二叉树 满二叉树就是该树的每一层的结点数都到达了最大，就是除了最后
数据结构——树和二叉树最全总结（期末复习必备）
weixin_65049289的博客
12-09 4329
数据结构——树和二叉树最全总结（期末复习必备）
【swjtu】数据结构第4次作业.docx
01-10
本次作业涵盖了数据结构中的关键概念，主要涉及二叉树和图的处理。以下是各个部分的知识点详解： 一、二叉树 1. **二叉树的直径**：二叉树的直径是树中任意两个节点之间的最长路径，这条路径至少包含一个根节点。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

康x呀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值