数据结构—树与二叉树(Part Ⅴ)—二叉排序树

已于 2022-03-19 09:24:20 修改
阅读量727 收藏 4
点赞数
分类专栏： 计算机技术 文章标签： 数据结构 算法 二叉排序树 森林 c语言
于 2021-09-02 08:02:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42071236/article/details/119981335
版权

目录

树的存储结构

  • 树的存储方式有多种，既可采用顺序存储结构，又可采用链式存储结构，但无论采用何种存储方式，都要求能唯一地反映树中各结点之间的逻辑关系，这里介绍3种常用的存储结构。

双亲表示法(parent storage structure)—顺序存储

双亲表示法

孩子表示法(child chain storage structure)—顺序存储+链式存储

孩子表示法(按各个结点的度设计结构)

按树的度设计结构

  • 由于树中每个结点的子树个数(即结点的度)不同，如果按各个结点的度设计变长结构，则会因为结点的孩子结点的指针域个数不同而导致算法实现非常麻烦。孩子链存储结构可按树的度(即树中所有结点度的最大值)设计结点的孩子结点的指针域个数。
    在这里插入图片描述
  • 空指针域个数： n ( k − 1 ) + 1 n(k-1)+1 n(k−1)+1，其中n代表总的结点数，k代表树的度。

孩子兄弟表示法(child brother chain storage structure)—链式存储

孩子兄弟表示法

树、森林与二叉树的转化

  • 树、森林与二叉树之间有一个自然的对应关系，它们之间可以互相转换，即任何一个森林或一棵树都可以唯一地对应一棵二叉树，而任一棵二叉树也能唯一地对应到一个森林或一棵树上。正是由于有这样的对应关系，可以把在树中处理的问题对应到二叉树中进行处理，从而把问题简单化。

树转换为二叉树

  • 规则：每个结点左指针指向它的第一个孩子，右指针指向它在树中的相邻右兄弟，这个规则又称“左孩子右兄弟”。由于根结点没有兄弟，所以对应的二叉树没有右子树。
  • 树转换成二叉树的画法：①在兄弟结点之间加一连线；②对每个结点，只保留它与第一个孩子的连线，而与其他孩子的连线全部抹掉；③以树根为轴心，顺时针旋转45°。
    在这里插入图片描述

森林转换为二叉树

  • 规则：先将森林中的每棵树转换为二叉树，由于任何一棵树对应的二叉树的右子树必空，若把森林中第二棵树根视为第一棵树根的右兄弟，即将第二棵树对应的二叉树当作第一棵二叉树根的右子树，将第三棵树对应的二叉树当作第二棵二叉树根的右子树…以此类推，就可以将森林转换为二叉树。
  • 森林转换成二叉树的画法：①将森林中的每棵树转换成相应的二叉树；②每棵树的根也可视为兄弟关系，在每棵树的根之间加一根连线；③以第一棵树的根为轴心顺时针旋转45°。
    在这里插入图片描述

二叉树转换为森林

  • 规则：若二叉树非空，则二叉树的根及其左子树为第一棵树的二叉树形式，故将根的右链断开。二叉树根的右子树又可视为一个由除第一棵树外的森林转换后的二叉树，应用同样的方法，直到最后只剩一棵没有右子树的二叉树为止，最后再将每棵二叉树依次转换成树，就得到了原森林。
    在这里插入图片描述

树、森林的遍历

树的遍历

  • 树的遍历是指用某种方式访问树中的每个结点，且仅访问一次。

先根遍历

  • 若树非空，先访问根结点，再依次遍历根结点的每棵子树，遍历子树时仍遵循先根后子树的规则。其遍历序列与这棵树相应二叉树的先序序列相同。
    在这里插入图片描述

后根遍历

  • 若树非空，先依次遍历根结点的每棵子树，再访问根结点，遍历子树时仍遵循先子树后根的规则。其遍历序列与这棵树相应二叉树的中序序列相同。

在这里插入图片描述

层序遍历

  • 与二叉树的层次遍历思想基本相同，即按层序依次访问各结点。
    在这里插入图片描述
  • 树的先根遍历以及后根遍历又可称为深度优先遍历；树的层序遍历又可称为广度优先遍历。

森林的遍历

先序遍历

  • 方法一：若森林为非空，则按如下规则进行遍历：
  1. 访问森林中第一棵树的根结点。
  2. 先序遍历第一棵树中根结点的子树森林。
  3. 先序遍历除去第一棵树之后剩余的树构成的森林。
    在这里插入图片描述
  • 方法二：将森林转换为对应的二叉树，然后按照二叉树的先序遍历进行访问。
    在这里插入图片描述

中序遍历

方法一：若森林为非空，则按如下规则进行遍历：

  1. 中序遍历森林中第一棵树的根结点的子树森林。
  2. 访问第一棵树的根结点。
  3. 中序遍历除去第一棵树之后剩余的树构成的森林。
    在这里插入图片描述
  • 方法二：将森林转换为对应的二叉树，然后按照二叉树的中序遍历进行访问。
    在这里插入图片描述

总结

树森林二叉树
先根遍历先根遍历先根遍历
后根遍历中根遍历中根遍历

二叉排序树

  • 二叉排序树，又称二叉查找树(BST，Binary Search Tree)。
  • 一棵二叉树或者是空二叉树，或者是具有如下性质的二叉树：左子树上所有结点的关键字均小于根结点的关键字；右子树上所有结点的关键字均大于根结点的关键字。左子树和右子树又各是一棵二叉排序树。
    在这里插入图片描述

查找操作

  • 二叉排序树的查找是从根结点开始，沿某个分支逐层向下比较的过程。若二叉排序树非空，先将给定值与根结点的关键字比较，若相等，则查找成功；若不等，如果小于根结点的关键字，则在根结点的左子树上查找，否则在根结点的右子树上查找。

递归算法

  • 递归算法比较简单，但执行效率较低。
  • 最坏空间复杂度：O(n)

非递归算法

  • 执行效率高，最坏空间复杂度：O(h)，其中h是二叉排序树的深度。

插入操作

  • 二叉排序树作为一种动态树表，其特点是树的结构通常不是一次生成的，而是在查找过程中，当树中不存在关键字值等于给定值的结点时再进行插入的。
  • 插入结点的过程如下：若原二叉排序树为空，则直接插入结点；否则，若关键字k小于根结点值，则插入到左子树，若关键字k大于根结点值，则插入到右子树。插入的结点一定是一个新添加的叶结点，且是查找失败时的查找路径上访问的最后一个结点的左孩子或右孩子。

二叉排序树的构造

  • 从一棵树出发，依次输入元素，将它们插入二叉排序中的合适位置。
  • 不同的关键字序列可能得到同款二叉排序树，也可能得到不同款二叉排序树。

删除操作

  • 在二叉排序树中删除一个结点时，不能把以该结点为根的子树上的结点都删除，必须先把被删除结点从存储二叉排序树的链表上摘下，将因删除结点而断开的二叉链表重新链接起来，同时确保二叉排序树的性质不会丢失。删除操作的实现过程按3种情况来处理：
  1. 若被删除结点z是叶结点，则直接删除，不会破坏二叉排序树的性质。
    在这里插入图片描述
    ②若结点z只有一棵左子树或右子树，则让z的子树成为z父结点的子树，替代z的位置。
    在这里插入图片描述
    在这里插入图片描述

③若结点z有左、右两棵子树，则令z的直接后继(或直接前驱)替代z，然后从二叉排序树中删去这个直接后继(或直接前驱)，这样就转换成了第一或第二种情况。

用直接后继替代z

在这里插入图片描述

用直接前驱替代z

在这里插入图片描述

完整代码

#include<iostream>
using namespace std;
#include<stdio.h>
#include<malloc.h>
#define MaxSize 15
typedef int ElemType;
typedef struct BSTNode
{
	ElemType data;
	struct BSTNode* lchild, * rchild;
}BSTNode, * BSTree;

BSTNode* BST_Search1(BSTree t, ElemType key) //非递归查找
{
	while (t != NULL && key != t->data) //若树空或等于根结点值，则结束循环
	{
		if (key < t->data) t = t->lchild; //小于，则在左子树上查找
		else t = t->rchild; //大于，则在右子树上查找
	}
	return t;
}

BSTNode* BST_Search2(BSTree t, ElemType key) //递归查找
{
	if (t == NULL) return NULL; //树空
	if (key == t->data) return t; //查找成功
	else if (key < t->data) return BST_Search2(t->lchild, key); //在左子树中找
	else return BST_Search2(t->rchild, key); //在右子树中找
}

bool BST_Insert1(BSTree& t, ElemType key) //递归插入
{
	if (t == NULL)
	{
		t = (BSTNode*)malloc(sizeof(BSTNode)); //原树为空，新插入的记录为根结点
		t->data = key;
		t->lchild = t->rchild = NULL;
		return true; //插入成功
	}
	else if (t->data == key) return false; //树中存在相同关键字的结点，插入失败
	else if (t->data > key) return BST_Insert1(t->lchild, key); //插入到t的左子树
	else return BST_Insert1(t->rchild, key); //插入到t的右子树
}

bool BST_Insert2(BSTree& t, ElemType key) //非递归插入
{
	BSTNode* pre = NULL, * p;
	if (t == NULL) //空树
	{
		t = (BSTNode*)malloc(sizeof(BSTNode));
		t->data = key;
		t->lchild = t->rchild = NULL;
		return true; //成功插入
	}
	BSTNode* q = t; //结点q指向根结点
	while (q != NULL) //非空树
	{
		if (q->data == key) return false; //二叉排序树里不可能存在相同的结点，插入失败
		else if (q->data > key)
		{
			pre = q;
			q = q->lchild; //遍历左孩子
		}
		else
		{
			pre = q;
			q = q->rchild; //遍历右孩子
		}
	}
	if (pre->data > key) //插入到左子树
	{
		p = (BSTNode*)malloc(sizeof(BSTNode));
		p->data = key;
		p->lchild = p->rchild = NULL;
		pre->lchild = p;
	}
	else  //插入到右子树
	{
		p = (BSTNode*)malloc(sizeof(BSTNode));
		p->data = key;
		p->lchild = p->rchild = NULL;
		pre->rchild = p;
	}
}

void BST_Create(BSTree& t, int n) //二叉排序树的构造
{
	t = NULL; //初始时t为空树
	ElemType key;
	printf("输入：");
	while (n--)
	{
		scanf("%d", &key);
		BST_Insert2(t, key); //依次将每个关键字插入到二叉排序树中
	}
}

BSTNode* BST_Parent(BSTree t, ElemType key)
{
	BSTNode* pre = NULL;
	while (t != NULL && key != t->data) //若树空或等于根结点值，则结束循环
	{
		if (key < t->data)
		{
			pre = t;
			t = t->lchild; //小于，则在左子树上查找
		}
		else
		{
			pre = t;
			t = t->rchild; //大于，则在右子树上查找
		}
	}
	if (t == NULL) pre = NULL;
	return pre;
}

bool BST_Delete(BSTree& t, ElemType key)
{
	BSTNode* p = t, * q = t, * s;
	int flag;
	p = BST_Parent(t, key);
	if (t == NULL) return false; //空树
	if (p == NULL) //父结点为空的情况：(一)要删除的是根结点 (二)关键字值在二叉排序树中查找不到
	{
		//(一)要删除的是根节点
		//情况①：除根结点外无其他结点
		if (t->data == key && t->lchild == NULL && t->rchild == NULL)
		{
			t = NULL; //删除根结点后变为空树
			return true;
		}
		//情况②：除根结点外还有其他子树
		else if (t->data == key) //如果右子树不空，可以让直接后继代替
		{
			s = t->rchild; //s是要删除结点的右子树中的根结点
			while (s->rchild != NULL) s = s->lchild; //找到右子树中采用中序遍历第一个访问的结点
			int data = s->data; //记录该结点的值
			BST_Delete(t, s->data); //从二叉排序树中删去这个直接前驱
			q->data = data; //最后令直接前驱替代要删除的结点
			return true;
		}
		//else if (t->data == key)  //如果左子树不空，可以让直接前驱代替
		//{
		//	s = t->lchild; //s是要删除结点的左子树中的根结点
		//	while (s->rchild != NULL) s = s->rchild; //找到左子树中采用中序遍历最后一个访问的结点
		//	int data = s->data; //记录该结点的值
		//	BST_Delete(t, s->data); //从二叉排序树中删去这个直接前驱
		//	q->data = data; //最后令直接前驱替代要删除的结点
		//	return true;
		//}
		//(二)关键字值在二叉排序树中查找不到
		else return false;
	}
	if (p->lchild->data == key)
	{
		flag = 0; //表示q是p的左孩子
		q = p->lchild; //q即为要删除的结点
	}
	else if (p->rchild->data == key)
	{
		flag = 1; //表示q是p的右孩子
		q = p->rchild; //q即为要删除的结点
	}
	//要删除的结点是叶结点
	if (q->lchild == NULL && q->rchild == NULL) //q是叶子结点，直接删除
	{
		if (flag == 0) p->lchild = NULL; //要删除的结点是其父结点的左孩子
		else p->rchild = NULL; //要删除的结点是其父结点的右孩子
	}
	//要删除的结点不是叶结点，并且该结点只有右子树
	else if (q->lchild != NULL && q->rchild == NULL) //q没有左孩子，只有右孩子
	{
		if (flag == 0) p->lchild = q->lchild;
		else p->rchild = q->lchild;
	}
	//要删除的结点不是叶结点，并且该结点只有左子树
	else if (q->lchild == NULL && q->rchild != NULL) //q只有左孩子，没有右孩子
	{
		if (flag == 0) p->lchild = q->rchild;
		else p->rchild = q->rchild;
	}
	//else //直接后继替代
	//{
	//	s = q->rchild; //s是要删除结点的右子树中的根结点
	//	while (s->lchild != NULL) s = s->lchild;
	//	int data = s->data;
	//	BST_Delete(t, s->data); //从二叉排序树中删去这个直接后继
	//	q->data = data; //最后令直接后继替代要删除的结点
	//}
	else //直接前驱替代
	{
		s = q->lchild; //s是要删除结点的左子树中的根结点
		while (s->rchild != NULL) s = s->rchild; //找到左子树中采用中序遍历最后一个访问的结点
		int data = s->data; //记录该结点的值
		BST_Delete(t, s->data); //从二叉排序树中删去这个直接前驱
		q->data = data; //最后令直接前驱替代要删除的结点
	}
}

typedef struct
{
	BSTNode* data[MaxSize];
	int front, rear;
}SqQueue;

void InitQueue(SqQueue*& qu)
{
	qu = (SqQueue*)malloc(sizeof(SqQueue));
	qu->rear = qu->front = 0;
}

bool EmptyQueue(SqQueue* qu)
{
	return qu->rear == qu->front;
}

bool enQueue(SqQueue*& qu, BSTNode* b)
{
	if ((qu->rear + 1) % MaxSize == qu->front) return false;
	qu->data[qu->rear] = b;
	qu->rear = (qu->rear + 1) % MaxSize;
}

bool deQueue(SqQueue*& qu, BSTNode*& b)
{
	if (qu->rear == qu->front) return false;
	b = qu->data[qu->front];
	qu->front = (qu->front + 1) % MaxSize;
}

void DestroyQueue(SqQueue*& qu)
{
	free(qu);
}

void LevelOrder(BSTree b) //层次遍历
{
	BSTNode* p;
	SqQueue* qu;
	InitQueue(qu);
	enQueue(qu, b);
	while (!EmptyQueue(qu))
	{
		deQueue(qu, p);
		printf("%d ", p->data);
		if (p->lchild != NULL) enQueue(qu, p->lchild);
		if (p->rchild != NULL) enQueue(qu, p->rchild);
	}
	DestroyQueue(qu);
}

int main()
{
	BSTNode* t;
	int n;
	printf("输入要创建的结点的个数：");
	scanf("%d", &n);
	BST_Create(t, n);
	printf("层序遍历二叉排序树：");
	LevelOrder(t);
	ElemType key;
	printf("\n输入要删除的关键字的值：");
	scanf("%d", &key);
	BSTNode* parent = BST_Parent(t, key);
	if (parent != NULL) printf("关键字值为%d的结点的双亲结点的关键字值为：%d\n", key, parent->data);
	bool result = BST_Delete(t, key);
	cout << boolalpha << "删除成功了吗？— " << result << endl;
	if (result)
	{
		printf("删除关键字为%d的结点之后的二叉排序树(层序遍历)：", key);
		LevelOrder(t);
	}
	return 0;
}

运行结果

在这里插入图片描述

查找效率分析

  • 查找长度—在查找运算中，需要对比关键字的次数称为查找长度，反映了查找操作时间复杂度。
  • 若树高h，找到最下层的一个结点需要对比h次。
    在这里插入图片描述
  • 最坏情况：每个结点只有一个分支，树高h=结点数n。平均查找长度=O(n)
  • 最好情况：n个结点的二叉树最小高度为 ⌊ l o g 2 n ⌋ + 1 ⌊log_2^n⌋+1 ⌊log2n​⌋+1。平均查找长度= O( l o g 2 n log_2^n log2n​)
—Miss. Z—
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
大话数据结构——二叉排序树的查找与插入操作~2020.8.12
fatfairyyy的博客
08-12 308
话不多说，先放出完整的代码与运行结果，再逐一讲解。 完整代码如下： #include <iostream> using namespace std; typedef struct BiTNode{ int data; BiTNode *lchild,*rchild; }BiTNode,*BiTree;//使用typedef为BiTNode赋予两种不同的名字 bool SearchBST(BiTree T,int key,BiTree f,BiTree *p){ /*二叉排序树的查找操作，运
数据结构—树与二叉树(Part Ⅵ)——平衡二叉树&哈夫曼树
Miss Z的博客
09-04 739
平衡二叉树 哈夫曼树和哈夫曼编码 哈夫曼树的定义 在许多应用中，树中结点常常被赋予一个表示某种意义的数值，称为该结点的权。 从树的根到任意结点的路径长度(经过的边数)与该结点上权值的乘积，称为该结点的带权路径长度。 树中所有叶结点的带权路径长度之和称为该树的带权路径长度，记为WPL=∑i=1nwiliWPL=\sum_{i=1}^nw_il_iWPL=∑i=1n​wi​li​，其中，wiw_iwi​是第i个叶结点所带的权值，lil_ili​是该叶结点到根结点的路径长度。 在含有n个带权叶结
数据结构—树与二叉树(PartⅠ)—树的基本概念&二叉树的概念和性质
Miss Z的博客
08-25 1045
数据结构-树与二叉树(第七章)的整理笔记，若有错误，欢迎指正。
【数据结构】—— chapter 05 树与二叉树的应用 (part4)
S_123789的博客
07-15 223
文章目录5.5 树与二叉树的应用5.5.1 二叉排序树1. 二叉排序树的定义 5.5 树与二叉树的应用 5.5.1 二叉排序树 1. 二叉排序树的定义
B-树（B-Tree）与二叉搜索树（BST）：讲讲数据库和文件系统背后的原理（读写比较大块数据的存储系统数据结构与算法原理）...
最新发布
禅与计算机程序设计艺术
11-30 1万+
人类总喜欢发明创造一些新名词（比如说，简写/缩写/简称什么的），并通过这些名词把人群分成了三六九等。弄到最后，把自己都绕晕了。你看，首先就是，B树，不要与Binary tree或B+tree混淆。B 树定义B树是一种的平衡多路查找树，我们把树中结点最大的孩子数目称为B树的阶,通常记为m。一棵m阶B树或为空树，或为满足如下特征的m叉树：1）树中每个结点至多有m棵子树。（即至多含有m-1个关键字）（“...
数据结构与算法_part_8_二叉树
Le0v1n 的博客
07-05 294
数据结构与算法_part_8_二叉树
数据结构期末复习（第六章 树与二叉树）
qq_27846147的博客
07-01 695
数据结构期末复习（第六章 树与二叉树） 文章目录数据结构期末复习（第六章 树与二叉树）Part 1、知识点总结1.1树的基本概念1.2 树的基本术语1.3 树的表示形式2.1 二叉树的概念2.2 二叉树的性质2.3 二叉树的顺序存储结构2.4 二叉树的链式存储结构3.1 二叉树的遍历及其应用3.1.1 概念3.1.2 先序遍历3.1.2 中序遍历3.1.3 后序遍历3.1.4 层次遍历3.2 二叉树的遍历应用3.2.1 输出二叉树的所有结点3.2.2 输出二叉树的叶子节点3.2.3 统计叶子结点数目3.
数据结构C语言 Part5 树与二叉树
Xuefen's happyland
11-07 2040
定义： 树（Tree）是n（n≥0）个结点的有限集，它或为空树（n = 0）；或为非空树，对于非空树T： （1）有且仅有一个称之为根的结点； （2）除根结点以外的其余结点可分为m（m＞0）个互不相交的有限集T1, T2, …, Tm, 其中每一个集合本身又是一棵树，并且称为根的子树（SubTree）。 对于树，我们要明白一些最基本的术语：根节点(root),叶子（终端节点），森林（多颗...
数据结构—查找(Part Ⅱ)—红黑树
Miss Z的博客
09-17 872
B树和B+树 B树，又称多路平衡查找树，B树中所有结点的孩子个数的最大值称为B树的阶，通常用m表示。一棵m阶B树或为空树，或为满足如下特性的m叉树： 树中每个结点至多有m棵子树，即至多含有m-1个关键字。 若根结点不是终端结点，则至少有两棵子树。 除根结点外的所有非叶结点至少有⌈m2⌉⌈\frac m2⌉⌈2m​⌉棵子树，即至少含有⌈m2⌉−1⌈\frac m2⌉-1⌈2m​⌉−1个关键字。 所有非叶结点的结构如下： n P0P_0P0​ K1K_1K1​ P1P_1P1​ K2K_2K2​
树的孩子兄弟表示法完整代码实现
Miss Z的博客
09-01 6871
#include<stdio.h> #include<malloc.h> typedef char ElemType; #define MaxSize 15 typedef struct CSNode { ElemType data; struct CSNode* firstchild, * nextsibling; }CSNode, * CSTree; typedef struct { CSNode* data[MaxSize]; //存放栈中的数据元素 int top;
C语言实现两个多项式相加&相减&相乘运算
Miss Z的博客
11-15 6763
1
树的双亲表示法&孩子表示法代码实现
Miss Z的博客
09-06 6118
孩子表示法 孩子链存储结构的类型声明 typedef struct { int child; //孩子结点在数组中的位置 struct CTNode *next; //下一个孩子 }CTNode; typedef struct { ElemType data; struct CTNode *firstChild; //第一个孩子 }CTBox; typedef struct { CTBox nodes[MAX_TREE_SIZE]; int n,r; //结点数和根的位置 }CTree;
数据结构—共享栈
Miss Z的博客
08-11 5525
数据结构-栈(Ⅳ) 共享栈 利用栈底位置相对不变的特性，可让两个顺序栈共享一个一维数组空间，将两个栈的栈底分别设置在共享空间的两端，两个栈顶向共享空间的中间延伸。 共享栈是为了更有效地利用存储空间，两个栈的空间相互调节，只有在整个存储空间被占满时才发生上溢。其存取数据的时间复杂度均为O(1)，所以对存取效率没有什么影响。 栈空条件：栈0空为top0==-1；栈1空为top==MaxSize。 栈满条件：top0==top1-1。 元素x进栈操作：进栈=操作为top0++；data[top0]=x；
数据结构——图的邻接矩阵法实现代码
Miss Z的博客
09-09 4275
不带权无向图 #include<stdio.h> #define MaxVertenNum 6 //顶点数目的最大值 typedef char VertexType; //顶点的数据类型 typedef int EdgeType; //存放顶点信息 typedef struct { VertexType Vex[MaxVertenNum]; //顶点表 EdgeType Edge[MaxVertenNum][MaxVertenNum]; //邻接矩阵 int vexnum, edgenum
数据结构—图(Part Ⅱ)—最小生成树 & 最短路径
Miss Z的博客
09-13 4147
数据结构-图(第八章)的整理笔记，若有错误，欢迎指正。 图的应用 图的应用主要包括：最小生成(代价)树、最短路径、拓扑排序和关键路径。 最小生成树 一个连通图的生成树包含图的所有顶点，并且只含尽可能少的边。对于生成树来说，若砍去它的一条边，则会使生成树变成非连通图；若给它增加一条边，则会形成图中的一条回路。 对于一个带权连通无向图G=(V,E)，生成树不同，每棵树的权(即树中所有边上的权值之和)也可能不同。 设R为G的所有生成树的集合，若T为R中边的权值之和最小的那棵生成树，则T称为G的最小生成树(
数据结构—串的模式匹配
Miss Z的博客
08-16 3844
数据结构-串(第四章)的整理笔记，若有错误，欢迎指正。
数据结构—排序(Part Ⅰ)—直接插入/折半插入/希尔排序
Miss Z的博客
09-18 3137
数据结构-排序(第十章)的整理笔记，若有错误，欢迎指正。 排序{基本概念{稳定性衡量标准：时间复杂度、空间复杂度内部排序{插入排序{直接插入排序折半插入排序希尔排序交换排序{冒泡排序快速排序选择排序{简单快速排序堆排序归并排序基数排序外部排序——多路归并排序 排序\begin{cases} 基本概念 \begin{cases} 稳定性\\ 衡量标准：时间复杂度、空间复杂度 \end{cases} \\ 内部排序 \begin{cases} 插入排序
单链表中有头结点 & 无头结点的各种基本操作(完整代码)
Miss Z的博客
07-28 2968
基础薄弱，理解尚浅，若有错误，欢迎指正。 线性表-单链表(Ⅲ) 单链表中有头结点 & 无头结点的各种基本操作(完整代码) 有头结点 #include<stdio.h> #include<malloc.h> //用malloc函数开辟新单元时需用此头文件 typedef int ElemType; typedef struct LNode //定义单链表结点类型 { ElemType data; //数据域 struct LNode *next; //指针域 }LNode,
2015考研数据结构：树与二叉树核心考点解析
- 森林与二叉树的转换：一棵树可以转换为一棵二叉树，反之亦然，这在理解和操作树结构时非常有用。 - 遍历：对于树和森林，同样有类似二叉树的遍历方法，只是操作更为复杂，需要考虑兄弟节点之间的关系。 4. **树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值