山东大学数据结构与算法实验11搜索树（二叉搜索树）

于 2024-07-27 09:51:07 发布
阅读量640 收藏 6
点赞数 15
分类专栏： 山东大学 数据结构与算法 文章标签： 数据结构 算法 c++ 搜索树 二叉搜索树 山东大学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Water_Star1/article/details/140730729
版权

题目描述

创建带索引的二叉搜索树类。存储结构使用链表，提供操作:插入、删除、按名次删除、查找、按名次查找、升序输出所有元素。

输入输出格式

输入格式

输入第一行一个数字 m (m<=1000000)，表示有 m 个操作。
接下来 m 行，每一行有两个数字 a，b：

  • 当输入的第一个数字 a 为 0 时，输入的第二个数字 b 表示向搜索树中插入 b
  • 当输入的第一个数字 a 为 1 时，输入的第二个数字 b 表示向搜索树中查找 b
  • 当输入的第一个数字 a 为 2 时，输入的第二个数字 b 表示向搜索树中删除 b
  • 当输入的第一个数字 a 为 3 时，输入的第二个数字 b 表示查找搜索树中名次为 b 的元素
  • 当输入的第一个数字 a 为 4 时，输入的第二个数字 b 表示删除搜索树中名次为 b 的元素

输出格式

对于输入中的每一种操作，输出执行操作的过程中依次比较的元素值的异或值。

注意

  • 查询与删除操作中，待查询的元素也需要异或入答案中
  • 查找（删除）操作中，如果未找到，或者插入操作，已存在，输出 0（不插入），不需要输出异或和
  • 查找（删除）第 b 大，如果不存在，输出 0
  • 删除操作中，如果当前元素有两个孩子，替换的为 右子树中最小的，如果只有一个孩子，直接用该孩子替换当前元素，如果没有孩子，直接删除
  • 删除操作的替换过程中所有比较操作不计入答案

 

数据结构与算法描述    

构造带索引的二叉搜索树节点的结构体，成员有元素、左子树节点数、左右孩子、构造函数。

struct indexedBStreeNode {
	int element;//元素 
	int leftsize;//左子树节点数 
	indexedBStreeNode* leftchild;
	indexedBStreeNode* rightchild;
	indexedBStreeNode(int a) {
		element = a;
		leftsize = 0;
		leftchild = NULL;
		rightchild = NULL;
	}
};

构造带索引的二叉搜索树类，私有成员为跟几点、树的大小。公有成员有插入、删除、按名次删除、查找、按名次查找函数。

class indexedBStree {
private:
	indexedBStreeNode* root;
	int size;//树的大小 
public:
	indexedBStree() {
		root = NULL;
		size = 0;
	}
	void insert(int b);//插入
	void find(int b);//查找b
	void erase(int b);//删除b
	void get(int index);//查找名次为b的元素
	void idelete(int index);//删除名次为b的元素
};

插入函数：声明一个初始化为根节点的搜索指针，和一个搜索指针的父节点的指针。插入的大则向右子树，插入的小则向左子树。找到节点后，如果树为空则新节点在根上，其他的插在搜索指针的父节点的子节点上。再更新左子树的节点个数，即如果插入的树小于该节点元素说明在这个节点的左子树，所以该节点的左子树个数要加一。

void indexedBStree::insert(int b) {//插入 
	indexedBStreeNode* p = root;//搜索指针 
	indexedBStreeNode* pp = NULL;//p的父节点的指针 
	int result = 0;
	while (p != NULL) {
		pp = p;//pp向下移动 
		result ^= p->element;
		if (b < p->element) {
			p = p->leftchild;
		}
		else if (b > p->element) {
			p = p->rightchild;
		}
		else {//已经存在输出0 
			cout << 0 << endl;
			return;
		}
	}
	indexedBStreeNode* newNode = new indexedBStreeNode(b);//为插入的元素建立新的节点 ，作为pp的子节点 
	if (root != NULL) {//树非空 
		if (b < pp->element)pp->leftchild = newNode;
		else pp->rightchild = newNode;
	}
	else {
		root = newNode;
	}
	size++;
	p = root;
	while (p->element!=b) {//更新左子树的节点个数 
		if (b < p->element) {//如果插入的元素比该节点元素小，说明其在该节点的左子树，leftsize++ 
			p->leftsize++;
			p = p->leftchild;
		}
		else if (b > p->element) {
			p = p->rightchild;
		}
	}
	cout << result << endl;
}

查找函数：从跟开始搜索，查找元素大则向右子树，插入元素小则向左子树。

void indexedBStree::find(int b) {//查找b
	int result = 0;
	indexedBStreeNode* p=root;//从根开始搜索 
	while (p != NULL) {
		result ^= p->element;
		if (b < p->element) {
			p = p->leftchild;
		}
		else if (b > p->element) {
			p = p->rightchild;
		}
		else {//找到则返回异或值 
			cout << result << endl;
			return;
		}
	}
	cout << 0 << endl;//没找到 
}

删除元素：和插入函数类似，找到要删除的节点p和其父节点pp。然后更新左子树节点个数。如果有两个孩子要转换成有0个或者1个孩子的情况。要找右子树的最小元素s，以及s的父节点ps，然后声明一个可以替代p指针的q指针，让q指针作为pp的孩子，让pp指向要删除节点(s)的父节点，将删除节点替换为s，删除节点两个孩子的情况改为0个或1个孩子的情况。保存删除节点的孩子指针，然后将孩子指针连接上pp。

void indexedBStree::erase(int b) {//删除b 
	int result = 0;
	indexedBStreeNode* p = root;//搜索指针 
	indexedBStreeNode* pp = NULL;//p的父节点的指针 
	while (p != NULL && p->element != b) {//找到元素b所在的位置 
		pp = p;
		if (b < p->element) {
			p = p->leftchild;
		}
		else {
			p = p->rightchild;
		}
	}
	if (p == NULL) {//不存在该元素 
		cout << 0 << endl;
		return;
	}
	p = root;
	while (p != NULL && p->element != b) {//更新左子树节点个数 
		result ^= p->element;
		if (b < p->element) {
			p->leftsize--;
			p = p->leftchild;
		}
		else {
			p = p->rightchild;
		}
	}
	result ^= p->element;
	if (p->leftchild != NULL && p->rightchild != NULL) {//有两个孩子，转换成有0或1个孩子 
		indexedBStreeNode* s = p->rightchild;//找p的右子树的最小元素 
		indexedBStreeNode* ps = p;//s的父节点 
		while (s->leftchild != NULL) {//小元素在左孩子处 
			s->leftsize--;//更新左子树节点个数 
			ps = s;
			s = s->leftchild;
		}
		indexedBStreeNode* q=new indexedBStreeNode(s->element);//声明一个可以替代p指针的q指针 
		q->leftsize = p->leftsize;
		q->leftchild = p->leftchild;
		q->rightchild = p->rightchild;
		//让q指针作为pp的孩子 
		if (pp == NULL) {
			root = q;
		}
		else if (p == pp->leftchild) {
			pp->leftchild = q;
		}
		else {
			pp->rightchild = q;
		}
		//让pp指向要删除节点(s)的父节点 
		if (ps == p) {
			pp = q;
		}
		else {
			pp = ps;
		}
		delete p;
		p = s;//删除节点替换为s
		//删除节点两个孩子的情况改为0个或1个孩子的情况 
	}
	indexedBStreeNode* c;//保存删除节点的孩子指针
	if (p->leftchild != NULL) {
		c = p->leftchild;
	}
	else {
		c = p->rightchild;
	}
	//将孩子指针连接上 
	if (p == root) {
		root = c;
	}
	else {
		if (p == pp->leftchild) {
			pp->leftchild = c;
		}
		else {
			pp->rightchild = c;
		}
	}
	size--;//树的节点数减一 
	delete p;
	cout << result << endl;
}

按索引查找元素：索引减一才表示左子树的节点个数，索引小于左子树节点个数时，说明该节点在左子树；大于的时候，在右子树，更新索引为原索引减去左子树个数和根。

void indexedBStree::get(int index) {
	index--;//索引减一才表示左子树的节点个数 
	int result = 0;
	indexedBStreeNode* p = root;
	while (p != NULL && p->leftsize != index) {
		result ^= p->element;
		if (index < p->leftsize) {//索引小于左子树节点个数时，说明该节点在左子树 
			p = p->leftchild;
		}
		else {//大于的时候，在右子树 
			index -= (p->leftsize + 1);//在右子树，更新索引，原索引减去左子树个数和根 
			p = p->rightchild;
		}
	}
	if (p == NULL) {//没找到 
		cout << 0 << endl;
		return;
	}
	else {
		result ^= p->element;
		cout << result << endl;
	}
}

按索引删除元素：先按索引查找，同时找到查找到的节点的父节点，然后就知道了该索引位置元素的大小，剩余和删除函数类似。

void indexedBStree::idelete(int index) {
	index--;//索引减一才表示左子树的节点个数 
	int result = 0;
	indexedBStreeNode* p = root;//搜索指针 
	indexedBStreeNode* pp = NULL;//p的父节点 
	while (p != NULL && p->leftsize != index) {
		pp = p;
		result ^= p->element;
		if (index < p->leftsize) {//索引小于左子树节点个数时，说明该节点在左子树 
			p = p->leftchild;
		}
		else {//大于的时候，在右子树 
			index -= (p->leftsize + 1);//在右子树，更新索引，原索引减去左子树个数和根 
			p = p->rightchild;
		}
	}
	if (p == NULL) {//没找到 
		cout << 0 << endl;
		return;
	}
	result ^= p->element;
	int b = p->element;//索引的位置所对应的元素，剩下的步骤和erase函数类似 
	p = root;
	while (p != NULL && p->element != b) {//更新leftsize 
		if (b < p->element) {
			p->leftsize--;
			p = p->leftchild;
		}
		else {
			p = p->rightchild;
		}
	}
	if (p->leftchild != NULL && p->rightchild != NULL) {//有两个孩子，转换成有0或1个孩子
		indexedBStreeNode* s = p->rightchild;//找p的右子树的最小元素 
		indexedBStreeNode* ps = p;//s的父节点
		while (s->leftchild != NULL) {//小元素在左孩子处 
			s->leftsize--;//更新左子树节点个数 
			ps = s;
			s = s->leftchild;
		}
		indexedBStreeNode* q = new indexedBStreeNode(s->element);//声明一个可以替代p指针的q指针 
		q->leftsize = p->leftsize;
		q->leftchild = p->leftchild;
		q->rightchild = p->rightchild;
		//让q指针作为pp的孩子 
		if (pp == NULL) {
			root = q;
		}
		else if (p == pp->leftchild) {
			pp->leftchild = q;
		}
		else {
			pp->rightchild = q;
		}
		//让pp指向要删除节点(s)的父节点 
		if (ps == p) {
			pp = q;
		}
		else {
			pp = ps;
		}
		delete p;
		p = s;//删除节点替换为s
		//删除节点两个孩子的情况改为0个或1个孩子的情况 
	}
	indexedBStreeNode* c;//保存删除节点的孩子指针
	if (p->leftchild != NULL) {
		c = p->leftchild;
	}
	else {
		c = p->rightchild;
	}
	//将孩子指针连接上 
	if (p == root) {
		root = c;
	}
	else {
		if (p == pp->leftchild) {
			pp->leftchild = c;
		}
		else {
			pp->rightchild = c;
		}
	}
	size--;//树节点树减一 
	delete p;
	cout << result << endl;
}

完整代码（含注释）

#include<iostream>
#include<stdio.h>
using namespace std;
struct indexedBStreeNode {
	int element;//元素 
	int leftsize;//左子树节点数 
	indexedBStreeNode* leftchild;
	indexedBStreeNode* rightchild;
	indexedBStreeNode(int a) {
		element = a;
		leftsize = 0;
		leftchild = NULL;
		rightchild = NULL;
	}
};
class indexedBStree {
private:
	indexedBStreeNode* root;
	int size;//树的大小 
public:
	indexedBStree() {
		root = NULL;
		size = 0;
	}
	void insert(int b);//插入
	void find(int b);//查找b
	void erase(int b);//删除b
	void get(int index);//查找名次为b的元素
	void idelete(int index);//删除名次为b的元素
};
void indexedBStree::insert(int b) {//插入 
	indexedBStreeNode* p = root;//搜索指针 
	indexedBStreeNode* pp = NULL;//p的父节点的指针 
	int result = 0;
	while (p != NULL) {
		pp = p;//pp向下移动 
		result ^= p->element;
		if (b < p->element) {
			p = p->leftchild;
		}
		else if (b > p->element) {
			p = p->rightchild;
		}
		else {//已经存在输出0 
			cout << 0 << endl;
			return;
		}
	}
	indexedBStreeNode* newNode = new indexedBStreeNode(b);//为插入的元素建立新的节点 ，作为pp的子节点 
	if (root != NULL) {//树非空 
		if (b < pp->element)pp->leftchild = newNode;
		else pp->rightchild = newNode;
	}
	else {
		root = newNode;
	}
	size++;
	p = root;
	while (p->element!=b) {//更新左子树的节点个数 
		if (b < p->element) {//如果插入的元素比该节点元素小，说明其在该节点的左子树，leftsize++ 
			p->leftsize++;
			p = p->leftchild;
		}
		else if (b > p->element) {
			p = p->rightchild;
		}
	}
	cout << result << endl;
}
void indexedBStree::find(int b) {//查找b
	int result = 0;
	indexedBStreeNode* p=root;//从根开始搜索 
	while (p != NULL) {
		result ^= p->element;
		if (b < p->element) {
			p = p->leftchild;
		}
		else if (b > p->element) {
			p = p->rightchild;
		}
		else {//找到则返回异或值 
			cout << result << endl;
			return;
		}
	}
	cout << 0 << endl;//没找到 
}
void indexedBStree::erase(int b) {//删除b 
	int result = 0;
	indexedBStreeNode* p = root;//搜索指针 
	indexedBStreeNode* pp = NULL;//p的父节点的指针 
	while (p != NULL && p->element != b) {//找到元素b所在的位置 
		pp = p;
		if (b < p->element) {
			p = p->leftchild;
		}
		else {
			p = p->rightchild;
		}
	}
	if (p == NULL) {//不存在该元素 
		cout << 0 << endl;
		return;
	}
	p = root;
	while (p != NULL && p->element != b) {//更新左子树节点个数 
		result ^= p->element;
		if (b < p->element) {
			p->leftsize--;
			p = p->leftchild;
		}
		else {
			p = p->rightchild;
		}
	}
	result ^= p->element;
	if (p->leftchild != NULL && p->rightchild != NULL) {//有两个孩子，转换成有0或1个孩子 
		indexedBStreeNode* s = p->rightchild;//找p的右子树的最小元素 
		indexedBStreeNode* ps = p;//s的父节点 
		while (s->leftchild != NULL) {//小元素在左孩子处 
			s->leftsize--;//更新左子树节点个数 
			ps = s;
			s = s->leftchild;
		}
		indexedBStreeNode* q=new indexedBStreeNode(s->element);//声明一个可以替代p指针的q指针 
		q->leftsize = p->leftsize;
		q->leftchild = p->leftchild;
		q->rightchild = p->rightchild;
		//让q指针作为pp的孩子 
		if (pp == NULL) {
			root = q;
		}
		else if (p == pp->leftchild) {
			pp->leftchild = q;
		}
		else {
			pp->rightchild = q;
		}
		//让pp指向要删除节点(s)的父节点 
		if (ps == p) {
			pp = q;
		}
		else {
			pp = ps;
		}
		delete p;
		p = s;//删除节点替换为s
		//删除节点两个孩子的情况改为0个或1个孩子的情况 
	}
	indexedBStreeNode* c;//保存删除节点的孩子指针
	if (p->leftchild != NULL) {
		c = p->leftchild;
	}
	else {
		c = p->rightchild;
	}
	//将孩子指针连接上 
	if (p == root) {
		root = c;
	}
	else {
		if (p == pp->leftchild) {
			pp->leftchild = c;
		}
		else {
			pp->rightchild = c;
		}
	}
	size--;//树的节点数减一 
	delete p;
	cout << result << endl;
}
void indexedBStree::get(int index) {
	index--;//索引减一才表示左子树的节点个数 
	int result = 0;
	indexedBStreeNode* p = root;
	while (p != NULL && p->leftsize != index) {
		result ^= p->element;
		if (index < p->leftsize) {//索引小于左子树节点个数时，说明该节点在左子树 
			p = p->leftchild;
		}
		else {//大于的时候，在右子树 
			index -= (p->leftsize + 1);//在右子树，更新索引，原索引减去左子树个数和根 
			p = p->rightchild;
		}
	}
	if (p == NULL) {//没找到 
		cout << 0 << endl;
		return;
	}
	else {
		result ^= p->element;
		cout << result << endl;
	}
}
void indexedBStree::idelete(int index) {
	index--;//索引减一才表示左子树的节点个数 
	int result = 0;
	indexedBStreeNode* p = root;//搜索指针 
	indexedBStreeNode* pp = NULL;//p的父节点 
	while (p != NULL && p->leftsize != index) {
		pp = p;
		result ^= p->element;
		if (index < p->leftsize) {//索引小于左子树节点个数时，说明该节点在左子树 
			p = p->leftchild;
		}
		else {//大于的时候，在右子树 
			index -= (p->leftsize + 1);//在右子树，更新索引，原索引减去左子树个数和根 
			p = p->rightchild;
		}
	}
	if (p == NULL) {//没找到 
		cout << 0 << endl;
		return;
	}
	result ^= p->element;
	int b = p->element;//索引的位置所对应的元素，剩下的步骤和erase函数类似 
	p = root;
	while (p != NULL && p->element != b) {//更新leftsize 
		if (b < p->element) {
			p->leftsize--;
			p = p->leftchild;
		}
		else {
			p = p->rightchild;
		}
	}
	if (p->leftchild != NULL && p->rightchild != NULL) {//有两个孩子，转换成有0或1个孩子
		indexedBStreeNode* s = p->rightchild;//找p的右子树的最小元素 
		indexedBStreeNode* ps = p;//s的父节点
		while (s->leftchild != NULL) {//小元素在左孩子处 
			s->leftsize--;//更新左子树节点个数 
			ps = s;
			s = s->leftchild;
		}
		indexedBStreeNode* q = new indexedBStreeNode(s->element);//声明一个可以替代p指针的q指针 
		q->leftsize = p->leftsize;
		q->leftchild = p->leftchild;
		q->rightchild = p->rightchild;
		//让q指针作为pp的孩子 
		if (pp == NULL) {
			root = q;
		}
		else if (p == pp->leftchild) {
			pp->leftchild = q;
		}
		else {
			pp->rightchild = q;
		}
		//让pp指向要删除节点(s)的父节点 
		if (ps == p) {
			pp = q;
		}
		else {
			pp = ps;
		}
		delete p;
		p = s;//删除节点替换为s
		//删除节点两个孩子的情况改为0个或1个孩子的情况 
	}
	indexedBStreeNode* c;//保存删除节点的孩子指针
	if (p->leftchild != NULL) {
		c = p->leftchild;
	}
	else {
		c = p->rightchild;
	}
	//将孩子指针连接上 
	if (p == root) {
		root = c;
	}
	else {
		if (p == pp->leftchild) {
			pp->leftchild = c;
		}
		else {
			pp->rightchild = c;
		}
	}
	size--;//树节点树减一 
	delete p;
	cout << result << endl;
}
int main() {
	int m;
	scanf("%d", &m);
	indexedBStree x;
	for (int i = 0; i < m; i++) {
		int a,b;
		scanf("%d %d", &a, &b);
		if (a == 0) {
			x.insert(b);
		}
		else if (a == 1) {
			x.find(b);
		}
		else if (a == 2) {
			x.erase(b);
		}
		else if (a == 3) {
			x.get(b);
		}
		else if (a == 4) {
			x.idelete(b);
		}
	}
	return 0;
}

如能打赏，不胜感激[叩谢]。

Star223333
关注
  • 15
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
山东大学大二上数据结构实验搜索树实验报告（含源码）
11-23
在“山东大学大二上数据结构实验搜索树实验报告”中，主要涉及了以下几个知识点： 1. **链表存储结构**：链表是一种线性数据结构，它通过指针链接各个节点，而不是像数组那样通过物理位置相邻。在二叉搜索树的实现...
山东大学《数据结构》实验指导04树和二叉树.docx
12-17
"山东大学《数据结构》实验指导04树和二叉树" 二叉树是数据结构中的一种重要类型，广泛应用于计算机科学和信息技术领域。本文将详细介绍二叉树的定义、结构特点、链式存储表示和遍历算法。 一、 二叉树的定义 ...
山东大学数据结构实验11搜索树
m0_73802120的博客
11-16 148
不要直接复制粘贴2023秋季做的话千万不要复制粘贴这个实验需要注意使用C++的输入流cin获取输入比使用C风格的scanf要慢。
山东大学数据结构实验11 搜索树
qq_62819443的博客
04-26 298
创建带索引的二叉搜索树类。存储结构使用链表，提供操作:插入、删除、按名次删除、查找、按名次查找、升序输出所有元素。
山东大学数据结构实验七堆和搜索树
weixin_52099599的博客
12-12 810
1、 输入一系列不为零的正整数（最多不超过20个），遇到0代表输入结束（不包含0）。 2、 根据上面输入的数据序列，用初始化方法创建最大堆（不要用节点依次插入的办法创建最大堆），然后输出最大堆的层次序列。 3、 输出用堆排序后的排序结果。 4、 根据上面输入的数据，创建二叉搜索树（关键字不允许重复，如遇重复，则不重复插入该关键字），输出二叉搜索树的前序序列、中序序列（分行输出）。 #include <iostream> using namespace std; void bigHeap(i
山东大学数据结构与算法课程设计实验3模拟文件目录系统
Water_Star1的博客
07-11 1171
设计并实现目录树 CatalogTree 的ADT，用它来表达字符串集合组成的有序树。应用以上CatalogTree结构设计并实现一文件目录系统的模拟程序，并提供模拟操作界面。 针对于目录系统，CatalogTree 的结点存放的数据内容为字符串，每个结点对应一个目录项，该目录项可以是目录，也可以是文件，如果是目录就可以再存放其它目录或文件，即非叶结点；如果是文件就是叶结点。从根结点到该结点路径所有结点的字符串用“/”进行组合后就是该目录项的绝对路径，用来唯一的标识该目录。
山东大学数据结构课程设计—AVL搜索树
11-24
二叉搜索树（Binary Search Tree，BST）是一种特殊的数据结构，每个节点包含一个键（key）、一个关联值、一个指向左子树的引用和一个指向右子树的引用。在二叉搜索树中，对于任意节点，其左子树中所有节点的键均小于...
山东大学数据结构实验报告
12-28
本实验报告聚焦于山东大学的数据结构课程，涵盖了矩阵、算法、递归、二叉树、搜索树、图以及堆栈等多个关键主题。这些主题都是构建高效软件系统的基础，对理解和解决问题具有深远的影响。 首先，让我们深入了解矩阵...
山东大学2020数据结构实验报告
01-12
本实验报告基于山东大学2020年的教学大纲，旨在通过实践加深对数据结构理论的理解，并提高编程能力。报告中包含了完整的代码，可以直接运行，这对于学习和理解各种数据结构及其算法提供了直观的示例。 1. **数组**...
c语言（7.23）
fhgfyrsg的博客
07-23 363
【代码】c语言（7.23）
数据结构---二叉树
weixin_47808575的博客
07-22 317
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 754
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
【数据结构】搜索二叉树
最新发布
dab112的博客
07-24 1206
介绍了二叉搜索树的实现与模拟
【数据结构-前缀和】力扣2550.统计范围内的元音字符串数
sjsjs11的博客
07-22 488
计算前缀和数组的时间是 O(n)，然后计算 q 个查询的答案，计算每个查询的答案的时间是 O(1)，因此时间复杂度是 O(n+q)。输入：words = [“aba”,“bcb”,“ece”,“aa”,“e”], queries = [[0,2],[1,4],[1,1]]输入：words = [“a”,“e”,“i”], queries = [[0,2],[0,1],[2,2]]查询 [1,4] 结果为 3（字符串 “ece”、“aa”、“e”）。返回结果 [2,3,0]。输出：[3,2,1]
《数据结构1800题》基础回合总结——第2章 线性表
前端，算法，MATLAB，统计学爱好者，目前主攻Web全栈+考研内容
07-23 419
和删除第一个结点不必另作判断。另外，不论链表是否为空，链表指针不变。这个要能够表达清楚。如果不设置头结点，边界情况需要特殊处理~应用题看了一下，不想在基础回合更新了，其实程序填空各位也可以暂时忽略——主要是使插入和删除等操作统一，在第一个元素之前插入。如果能保证客观题正确率100%，这本题就没白刷~刷《1800》的意义在于，
数据结构之判断完全二叉树详解与示例（C，C++）
qq_35320456的博客
07-23 362
通过上述C和C++的实现示例，我们可以看到判断一个二叉树是否为完全二叉树的基本方法是使用层序遍历。在遍历过程中，我们通过设置一个标记来区分节点是否应该为叶子节点，从而判断二叉树是否满足完全二叉树的条件。这种方法的时间复杂度为O(n)，其中n是二叉树中节点的数量，因为每个节点最多只会被访问一次。在实际应用中，完全二叉树由于其特殊的结构，常用于堆的实现，因为它可以在数组中有效地表示，同时保持堆的操作效率。理解并掌握判断完全二叉树的方法，对于深入理解二叉树结构和相关算法有重要意义。
数据结构（特殊二叉树－线索二叉树）
weixin_65029285的博客
07-22 348
链式二叉树中有很多的空指针，可以让这些空指针指向前一个节点\后一个节点，从而在有序遍历（中序遍历）二叉树时，不需要使用递归而通过循环即可以完成，并且效率要比递归快得多。首先需要有一颗搜索二叉树，然后通过中序遍历并生成线索，通过检查右子树是否为空来决定是否生成线索，让右子树指向下一个节点。bool lflag;// 左子树是否是线索 为真时，左子树是线索 指向前一个节点。bool rflag;// 右子树是否是线索 为真时，右子树是线索 指向下一个节点。
华清数据结构day5 24-7-22
m0_62859255的博客
07-22 367
【代码】华清数据结构day5 24-7-22。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值