动态数组实现顺序表，折半查找，二叉排序树建树，删除

最新推荐文章于 2024-10-02 23:40:03 发布
最新推荐文章于 2024-10-02 23:40:03 发布
阅读量773 收藏 16
点赞数 23
分类专栏： 数据结构 文章标签： 算法 C语言 数据结构 c++ 数据结构和算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57342311/article/details/141534139
版权

数据结构的学习笔记

目录

1.用动态数组实现顺序表

2.折半查找

3.二叉排序树建树

4.二叉排序树删除

1.用动态数组实现顺序表

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
//用动态数组实现顺序表

typedef int ElemType;

//顺序表
typedef struct SqList {
	ElemType* data;//指针，指向一块内存的起始地址
	int length;//存储动态数组的长度
}SqList;

//顺序表初始化
void initSqList(SqList& L, int len) {
	L.length = len;
	L.data = (ElemType*)malloc(sizeof(ElemType) * L.length);//分配空间
	srand(time(NULL));//随机数生成
	for (int i = 0; i < L.length; i++)
	{
		L.data[i] = rand() % 100;//随机生成数字存入顺序表，对100取余是为了规范存入的数据是0-99
	}
}

//顺序表打印
void printSqList(SqList L) {
	for (int i = 0; i < L.length; i++)
	{
		printf("%3d", L.data[i]);
	}
	printf("\n");
}

//顺序查找顺序表中的元素
int searchElemInSqList(SqList L, ElemType e) {
	int i;
	for (i = 0; i < L.length; i++) {
		if (L.data[i] == e)
		{
			break;
		}
	}
	return i + 1;//返回的位置刚好是下标对应的位置
}

int main() {
	SqList L;//定义一个顺序表
	initSqList(L, 10);//初始化顺序表，分配10个空间
	printSqList(L);//打印顺序表中的值
	ElemType e;//需要查询的元素
	printf("请输入要搜索的元素值:");
	scanf_s("%d", &e);
	int pos;//存储查询元素的位置
	pos = searchElemInSqList(L, e);//查询元素
	if (pos)
	{
		printf("查找成功，位置为：%d\n", pos);
	}
	else
	{
		printf("查找失败\n");
	}
	return 0;
}

这段代码实现了使用动态数组来创建和操作顺序表的功能，包括顺序表的初始化、打印，以及顺序查找功能。代码的功能和执行步骤如下：

1. 定义顺序表结构体

  • 定义了一个结构体 SqList，包含了一个指针 data，用于指向动态分配的内存空间，用于存储顺序表中的元素；另一个成员变量 length 用于表示顺序表的当前长度。

2. 顺序表初始化函数

  • initSqList(SqList& L, int len) 函数用于初始化顺序表。它的步骤包括：
    • 设置顺序表的长度 length 为用户指定的长度 len。
    • 使用 malloc 函数为顺序表的 data 指针分配内存空间，以存储顺序表中的元素。
    • 使用 srand(time(NULL)) 初始化随机数生成器。
    • 通过 rand() 函数生成随机数，并将其对 100 取余后的值（0-99）存入顺序表。

3. 顺序表打印函数

  • printSqList(SqList L) 函数用于打印顺序表中的所有元素。
    • 使用循环遍历顺序表的 data 数组，将每个元素按顺序输出到控制台。

4. 顺序查找函数

  • searchElemInSqList(SqList L, ElemType e) 函数用于在顺序表中查找指定的元素 e。
    • 该函数通过遍历顺序表中的每个元素，如果找到匹配的元素，则返回其位置（下标加 1），如果没有找到，则返回 L.length + 1，即大于顺序表长度的位置。

5. 主函数

  • main() 函数是程序的入口，包含以下步骤：
    • 定义一个顺序表 L。
    • 调用 initSqList(L, 10) 函数，初始化顺序表，并为其分配 10 个元素空间。
    • 使用 printSqList(L) 函数打印顺序表中的所有元素。
    • 通过控制台输入用户需要查找的元素值，并存储在 e 变量中。
    • 调用 searchElemInSqList(L, e) 函数查找该元素，并返回其在顺序表中的位置 pos。
    • 根据查找结果，输出成功或失败的消息。

总结

这段代码通过动态内存分配，实现了一个简单的顺序表操作，并具备随机初始化、打印及顺序查找的功能。用户可以通过输入一个数字，查看其在顺序表中的位置。

2.折半查找

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

//用动态数组实现顺序表

typedef int ElemType;

//顺序表
typedef struct SqList {
	ElemType* data;//指针，指向一块内存的起始地址
	int length;//存储动态数组的长度
}SqList;

//顺序表初始化
void initSqList(SqList& L, int len) {
	L.length = len;
	L.data = (ElemType*)malloc(sizeof(ElemType) * L.length);//分配空间
	
	for (int i = 0; i < L.length; i++)
	{
		L.data[i] = i + 1;//从小到大放入一些数据
	}
}

//顺序表打印
void printSqList(SqList L) {
	for (int i = 0; i < L.length; i++)
	{
		printf("%3d", L.data[i]);
	}
	printf("\n");
}

//顺序查找顺序表中的元素
int searchElemInSqList(SqList L, ElemType e) {
	int i;
	for (i = 0; i < L.length; i++) {
		if (L.data[i] == e)
		{
			return i + 1;//返回的位置刚好是下标对应的位置
		}
	}
	return -1;//查找失败
}

//折半查找
int binarySearch(SqList L, ElemType e) {
	int low = 0, high = L.length - 1;//指向第一个结点和最后一个结点
	int mid;
	while (low <= high)
	{
		mid = (low + high) / 2;
		if (L.data[mid] == e) {
			return mid + 1;//返回的是位置，下标+1
		}
		else if (L.data[mid] < e) {
			low = mid + 1;
		}
		else
		{
			high = mid - 1;
		}
	}
	return -1;//查找失败
}

//折半查找顺序表中的元素

int main() {
	SqList L;//定义一个顺序表
	initSqList(L, 10);//初始化顺序表，分配10个空间
	printSqList(L);//打印顺序表中的值
	ElemType e;//需要查询的元素
	printf("请输入要搜索的元素值:");
	scanf_s("%d", &e);
	int pos;//存储查询元素的位置
	//pos = searchElemInSqList(L, e);//顺序查询元素
	pos = binarySearch(L, e);//折半查询元素
	if (pos != -1)
	{
		printf("查找成功，位置为：%d\n", pos);
	}
	else
	{
		printf("查找失败\n");
	}
	return 0;
}

这段代码实现了使用动态数组来创建和操作顺序表的功能，包含顺序表的初始化、打印、顺序查找和折半查找。代码的功能和执行步骤如下：

1. 定义顺序表结构体

  • 定义了一个结构体 SqList，包含一个指针 data，指向动态分配的内存空间，用于存储顺序表中的元素；另一个成员变量 length 用于表示顺序表的当前长度。

2. 顺序表初始化函数

  • initSqList(SqList& L, int len) 函数用于初始化顺序表。它的步骤包括：
    • 设置顺序表的长度 length 为用户指定的长度 len。
    • 使用 malloc 函数为顺序表的 data 指针分配内存空间，以存储顺序表中的元素。
    • 将顺序表中的数据从 1 开始按顺序填充，即 L.data[i] = i + 1。

3. 顺序表打印函数

  • printSqList(SqList L) 函数用于打印顺序表中的所有元素。
    • 使用循环遍历顺序表的 data 数组，将每个元素按顺序输出到控制台。

4. 顺序查找函数

  • searchElemInSqList(SqList L, ElemType e) 函数用于在顺序表中顺序查找指定的元素 e。
    • 通过遍历顺序表中的每个元素，如果找到匹配的元素，则返回其位置（下标加 1），如果没有找到，则返回 -1。

5. 折半查找函数

  • binarySearch(SqList L, ElemType e) 函数用于在顺序表中使用折半查找（即二分查找）来查找指定的元素 e。前提是顺序表中的数据必须是有序的。
    • 初始化 low 和 high 指针分别指向顺序表的第一个和最后一个元素。
    • 使用 while 循环进行查找，每次通过计算中间位置 mid 来比较目标元素 e 与中间元素 L.data[mid] 的大小关系：
      • 如果 L.data[mid] 等于 e，则返回位置（下标加 1）。
      • 如果 L.data[mid] 小于 e，则调整 low 指针。
      • 如果 L.data[mid] 大于 e，则调整 high 指针。
    • 如果查找失败，返回 -1。

6. 主函数

  • main() 函数是程序的入口，包含以下步骤：
    • 定义一个顺序表 L。
    • 调用 initSqList(L, 10) 函数，初始化顺序表，并为其分配 10 个元素空间。
    • 使用 printSqList(L) 函数打印顺序表中的所有元素。
    • 通过控制台输入用户需要查找的元素值，并存储在 e 变量中。
    • 使用 binarySearch(L, e) 函数在顺序表中进行折半查找，并返回元素的位置 pos。
    • 根据查找结果，输出成功或失败的消息。

总结

这段代码通过动态内存分配实现了一个简单的顺序表操作，并具备初始化、打印、顺序查找和折半查找的功能。特别注意的是，在使用折半查找之前，顺序表中的数据必须是有序的。

3.二叉排序树建树

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

// 二叉排序树建树

typedef int KeyType;

typedef struct BSTNode {
	KeyType key;
	struct BSTNode* lchild, * rchild;
}BSTNode, * BSTree;

//排序二叉树插入结点(非递归)
int BSTInsert(BSTree& T, KeyType key) {
	BSTNode* newNode = (BSTNode*)calloc(1, sizeof(BSTNode)); //为新结点分配空间
	newNode->key = key;
	if (T == NULL) { //树为空，新结点作为树的根
		T = newNode;
		return 1; //插入成功
	}
	BSTNode* p, * parent; //p用来查找树结点，parent用来保存其父亲
	p = parent = T; //从树根开始查
	while (p)
	{
		parent = p;
		if (key < p->key) //key小于当前结点的值，进入左孩子
		{
			p = p->lchild;
		}
		else if (key > p->key) //key大于当前结点的值，进入右孩子
		{
			p = p->rchild;
		}
		else //key等于当前元素的值，不插入
		{
			return 0;
		}
	}
	if (key < parent->key)
	{
		parent->lchild = newNode; //新结点作为父亲的左孩子
	}
	else
	{
		parent->rchild = newNode; //新结点作为父亲的右孩子
	}
	return 1; //插入成功
}

//排序二叉树插入结点(递归)
int BSTInsert2(BSTree& T, KeyType key) {
	if (T == NULL)
	{	//给新结点分配空间，树为空，新结点作为树的根
		T = (BSTree)calloc(1, sizeof(BSTNode));
		T->key = key;
		return 1; //插入成功
	}
	if (key == T->key) //相同元素，不插入
		return 0;
	else if (key < T->key)//key小于当前结点的值
		return BSTInsert2(T->lchild, key);
	else
		return BSTInsert2(T->rchild, key);
}

//创建二叉排序树
void createBST(BSTree& T, KeyType* arr, int len) {
	int i;
	for (i = 0; i < len; i++)//把结点一个一个的放进二叉排序树
	{
		BSTInsert2(T, arr[i]);
	}
}

// 查找结点
bool BSTSearch(BSTree T, KeyType key, BSTNode*& search, BSTNode*& parent) {
	while (T != NULL && T->key != key)
	{
		parent = T; //获取查找结点的父结点
		if (key < T->key) {
			T = T->lchild;
		}
		else
		{
			T = T->rchild;
		}
	}
	search = T; //获取查找到的树结点
	if (search == NULL) //查找失败search一定等于NULL
	{
		return false;
	}
	return true;
}

//中序遍历，用来验证二叉排序树是否建立正确
void midOrder(BSTree T) {
	if (T)
	{
		midOrder(T->lchild);
		printf("%3d", T->key);
		midOrder(T->rchild);
	}
}

int main() {
	BSTree bst = NULL; //定义二叉排序树
	KeyType arr[7] = { 48,14,60,34,22,73,52 }; //将要放入二叉排序树的元素
	createBST(bst, arr, 7); //建立二叉排序树
	midOrder(bst); //中序遍历二叉排序树
	printf("\n");
	BSTNode* search = NULL, * parent = NULL;
	bool result;
	result = BSTSearch(bst, 48, search, parent);
	if (result)
	{
		printf("%d查找成功\n", search->key);
	}
	else
	{
		printf("查找失败\n");
	}
	return 0;
}

这段代码实现了二叉排序树（Binary Search Tree, BST）的基本操作，包括插入节点、查找节点和中序遍历。代码的功能和执行步骤如下：

1. 定义二叉排序树节点结构体

  • 定义了一个结构体 BSTNode，包含以下成员：
    • key：存储节点的关键值。
    • lchild 和 rchild：指向左右子节点的指针。
  • BSTree 是 BSTNode* 的别名，表示树的根节点。

2. 排序二叉树插入节点（非递归）

  • BSTInsert(BSTree& T, KeyType key) 函数用于在二叉排序树中插入一个新的节点。步骤包括：
    • 为新节点分配内存，并设置其 key 值。
    • 如果树为空，新节点作为树的根节点。
    • 否则，从根节点开始查找合适的位置，将新节点插入到正确的位置。
    • 如果找到相同的关键值，则不插入节点。
    • 根据新节点的值决定将其插入到父节点的左子树还是右子树。

3. 排序二叉树插入节点（递归）

  • BSTInsert2(BSTree& T, KeyType key) 函数用于在二叉排序树中递归插入一个新的节点。步骤包括：
    • 如果树为空，新节点作为树的根节点。
    • 如果关键值与当前节点相同，则不插入。
    • 根据关键值的大小，递归地在左子树或右子树中插入新节点。

4. 创建二叉排序树

  • createBST(BSTree& T, KeyType* arr, int len) 函数用于从数组中创建一个二叉排序树。步骤包括：
    • 遍历数组中的每个元素，使用 BSTInsert2 函数将元素插入到树中。

5. 查找节点

  • BSTSearch(BSTree T, KeyType key, BSTNode*& search, BSTNode*& parent) 函数用于在二叉排序树中查找指定的节点。步骤包括：
    • 从树的根节点开始查找，更新 parent 指针以记录当前节点的父节点。
    • 如果找到匹配的节点，设置 search 指针指向该节点。
    • 如果未找到节点，search 将为 NULL，函数返回 false。

6. 中序遍历

  • midOrder(BSTree T) 函数用于中序遍历二叉排序树。步骤包括：
    • 递归遍历左子树，打印当前节点的关键值，然后递归遍历右子树。
    • 中序遍历可以验证二叉排序树的节点是否按顺序排列。

7. 主函数

  • main() 函数是程序的入口，包含以下步骤：
    • 定义一个空的二叉排序树 bst。
    • 定义一个数组 arr，包含要插入到二叉排序树中的元素。
    • 调用 createBST(bst, arr, 7) 函数创建二叉排序树。
    • 使用 midOrder(bst) 函数打印中序遍历的结果，以验证树的正确性。
    • 查找关键值为 48 的节点，并输出查找结果。

总结

这段代码实现了一个简单的二叉排序树的构建、节点插入、节点查找和中序遍历功能。二叉排序树的插入操作可以通过递归或非递归方式实现，查找操作通过中序遍历可以验证树的结构。

4.二叉排序树删除

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

// 二叉排序树建树

typedef int KeyType;

typedef struct BSTNode {
	KeyType key;
	struct BSTNode* lchild, * rchild;
}BSTNode, * BSTree;

//排序二叉树插入结点(非递归)
int BSTInsert(BSTree& T, KeyType key) {
	BSTNode* newNode = (BSTNode*)calloc(1, sizeof(BSTNode)); //为新结点分配空间
	newNode->key = key;
	if (T == NULL) { //树为空，新结点作为树的根
		T = newNode;
		return 1; //插入成功
	}
	BSTNode* p, * parent; //p用来查找树结点，parent用来保存其父亲
	p = parent = T; //从树根开始查
	while (p)
	{
		parent = p;
		if (key < p->key) //key小于当前结点的值，进入左孩子
		{
			p = p->lchild;
		}
		else if (key > p->key) //key大于当前结点的值，进入右孩子
		{
			p = p->rchild;
		}
		else //key等于当前元素的值，不插入
		{
			return 0;
		}
	}
	if (key < parent->key)
	{
		parent->lchild = newNode; //新结点作为父亲的左孩子
	}
	else
	{
		parent->rchild = newNode; //新结点作为父亲的右孩子
	}
	return 1; //插入成功
}

//排序二叉树插入结点(递归)
int BSTInsert2(BSTree& T, KeyType key) {
	if (T == NULL)
	{	//给新结点分配空间，树为空，新结点作为树的根
		T = (BSTree)calloc(1, sizeof(BSTNode));
		T->key = key;
		return 1; //插入成功
	}
	if (key == T->key) //相同元素，不插入
		return 0;
	else if (key < T->key)//key小于当前结点的值
		return BSTInsert2(T->lchild, key);
	else
		return BSTInsert2(T->rchild, key);
}

//创建二叉排序树
void createBST(BSTree& T, KeyType* arr, int len) {
	int i;
	for (i = 0; i < len; i++)//把结点一个一个的放进二叉排序树
	{
		BSTInsert2(T, arr[i]);
	}
}

// 查找结点
bool BSTSearch(BSTree T, KeyType key, BSTNode*& search, BSTNode*& parent) {
	while (T != NULL && T->key != key)
	{
		parent = T; //获取查找结点的父结点
		if (key < T->key) {
			T = T->lchild;
		}
		else
		{
			T = T->rchild;
		}
	}
	search = T; //获取查找到的树结点
	if (search == NULL) //查找失败search一定等于NULL
	{
		return false;
	}
	return true;
}

// 删除二叉排序树的结点
bool deleteBSTNode(BSTree& T, KeyType key) {
	if (T == NULL) {
		return false;
	}
	if (key < T->key) { //key小于当前树结点的值，往左子树找
		deleteBSTNode(T->lchild, key);
	}
	else if (key > T->key) { //key大于当前树结点的值，往右子树找
		deleteBSTNode(T->rchild, key);
	}
	else { //相等，找到要删除的结点
		if (T->lchild == NULL) { //要删除的结点左子树为空，右子树直接顶上去
			BSTNode* tempNode = T; //存放要删除的结点
			T = T->rchild; //右子树顶上去
			free(tempNode); //释放要删除结点的空间
			return true;
		}
		else if (T->rchild == NULL) { //要删除的结点右子树为空，左子树直接顶上去
			BSTNode* tempNode = T; //存放要删除的结点
			T = T->lchild; //左子树顶上去
			free(tempNode); //释放要删除结点的空间
			return true;
		}
		else { //要删除的结点左右子树都不为空
			   //一般的删除策略是用左子树的最大数据(最右结点) 或 右子树的最小数据代替
			   //这里采用查找左子树最大数据来代替
			BSTNode* tempNode = T->lchild; //保存要删除结点的左子树
			while (tempNode->rchild != NULL) //循环找到左子树最右结点
			{
				tempNode = tempNode->rchild;
			}
			T->key = tempNode->key; //将左子树最右结点的值赋给要删除的结点
			deleteBSTNode(T->lchild, tempNode->key); //递归删除左子树的最右结点
			return true;
		}
	}
}

//中序遍历，用来验证二叉排序树是否建立正确
void midOrder(BSTree T) {
	if (T)
	{
		midOrder(T->lchild);
		printf("%3d", T->key);
		midOrder(T->rchild);
	}
}

int main() {
	BSTree bst = NULL; //定义二叉排序树
	KeyType arr[7] = { 48,14,60,34,22,73,52 }; //将要放入二叉排序树的元素
	createBST(bst, arr, 7); //建立二叉排序树
	midOrder(bst); //中序遍历二叉排序树
	printf("\n");
	BSTNode* search = NULL, * parent = NULL;
	bool result;
	result = BSTSearch(bst, 48, search, parent);
	if (result)
	{
		printf("%d查找成功\n", search->key);
	}
	else
	{
		printf("查找失败\n");
	}
	
	result = deleteBSTNode(bst, 34);
	if (result)
	{
		printf("删除成功\n");
	}
	else
	{
		printf("删除失败\n");
	}
	midOrder(bst);
	return 0;
}

这段代码实现了一个二叉排序树（Binary Search Tree, BST）的基本操作，包括节点插入、查找、删除和中序遍历。代码的功能和执行步骤如下：

1. 定义二叉排序树节点结构体

  • BSTNode 结构体定义了二叉排序树的节点，包含以下成员：
    • key：存储节点的关键值。
    • lchild 和 rchild：指向左子节点和右子节点的指针。
  • BSTree 是 BSTNode* 的别名，表示树的根节点。

2. 排序二叉树插入节点（非递归）

  • BSTInsert(BSTree& T, KeyType key) 函数用于在二叉排序树中插入一个新的节点。步骤包括：
    • 为新节点分配内存，并设置其 key 值。
    • 如果树为空，新节点作为树的根节点。
    • 否则，从根节点开始查找合适的位置，将新节点插入到正确的位置。
    • 如果找到相同的关键值，则不插入节点。
    • 根据新节点的值决定将其插入到父节点的左子树还是右子树。

3. 排序二叉树插入节点（递归）

  • BSTInsert2(BSTree& T, KeyType key) 函数用于在二叉排序树中递归插入一个新的节点。步骤包括：
    • 如果树为空，新节点作为树的根节点。
    • 如果关键值与当前节点相同，则不插入。
    • 根据关键值的大小，递归地在左子树或右子树中插入新节点。

4. 创建二叉排序树

  • createBST(BSTree& T, KeyType* arr, int len) 函数用于从数组中创建一个二叉排序树。步骤包括：
    • 遍历数组中的每个元素，使用 BSTInsert2 函数将元素插入到树中。

5. 查找节点

  • BSTSearch(BSTree T, KeyType key, BSTNode*& search, BSTNode*& parent) 函数用于在二叉排序树中查找指定的节点。步骤包括：
    • 从树的根节点开始查找，更新 parent 指针以记录当前节点的父节点。
    • 如果找到匹配的节点，设置 search 指针指向该节点。
    • 如果未找到节点，search 将为 NULL，函数返回 false。

6. 删除节点

  • deleteBSTNode(BSTree& T, KeyType key) 函数用于删除二叉排序树中的指定节点。步骤包括：
    • 如果树为空，返回删除失败。
    • 如果关键值小于当前节点的值，递归删除左子树中的节点。
    • 如果关键值大于当前节点的值，递归删除右子树中的节点。
    • 如果找到要删除的节点，处理删除操作：
      • 如果要删除的节点没有左子树，将右子树顶替到要删除节点的位置。
      • 如果要删除的节点没有右子树，将左子树顶替到要删除节点的位置。
      • 如果要删除的节点有左右子树，找到左子树中的最大节点（最右节点），用其值替代要删除的节点，并递归删除该最大节点。

7. 中序遍历

  • midOrder(BSTree T) 函数用于中序遍历二叉排序树。步骤包括：
    • 递归遍历左子树，打印当前节点的关键值，然后递归遍历右子树。
    • 中序遍历可以验证二叉排序树的节点是否按顺序排列。

8. 主函数

  • main() 函数是程序的入口，包含以下步骤：
    • 定义一个空的二叉排序树 bst。
    • 定义一个数组 arr，包含要插入到二叉排序树中的元素。
    • 调用 createBST(bst, arr, 7) 函数创建二叉排序树。
    • 使用 midOrder(bst) 函数打印中序遍历的结果，以验证树的正确性。
    • 查找关键值为 48 的节点，并输出查找结果。
    • 删除关键值为 34 的节点，并输出删除结果。
    • 再次使用 midOrder(bst) 函数打印中序遍历的结果，验证删除操作的正确性。

总结

这段代码实现了二叉排序树的基本操作，包括节点的插入、查找、删除和中序遍历。通过这些操作，可以创建一个二叉排序树，维护树的结构，并执行基本的树操作。

juechen333
关注
专栏目录
算法与数据结构(十) 二叉排序树的查找、插入与删除
csao204282的博客
01-05 1370
在上一篇博客中，我们主要介绍了四种查找的方法，包括顺序查找、折半查找、插入查找以及Fibonacci查找。上面这几种查找方式都是基于线性表的查找方式，今天博客中我们来介绍一下基于二叉树结构的查找，也就是我们今天要聊的二叉排序树。今天主要聊的是二叉排序树的查找、插入与删除的内容，二叉排序的创建过程其实就是不断查找与插入的过程，也就是说当我们在创建二叉排序树时，我们会先搜索该节点在二叉排序树中的位置，
数据结构-实验五  查找算法
热门推荐
brandong
09-26 1万+
广州大学学生实验报告   开课实验室：计算机科学与工程实验（电子楼417）     2018年06月13日 学院 计算机科学与教育软件学院 年级、专业、班 网络161 姓名 卟咚君 学号 1606100*** 实...
【数据结构】查找：顺序查找、折半查找、二叉排序树、平衡二叉树、B树、哈希查找
Bobby's Blog
09-22 4643
整理内容来源：zzu信息工程学院数据结构ppt 本节讨论两类不同的查找表：静态查找表和动态查找表，给出在不同查找表上进行查找的不同算法和性能分析以及动态查找表的创建方法。 1 查找的基本概念 静态查找： 基于线性表的查找 动态查找： 基于树的查找（二叉排序树、平衡二叉排序树、B-树和B+树） 基于散列表的查找 2 基于线性表的查找 2.1 定义和分类 基于线性表的查找主要是两部分：（索引顺序表用的不是很多） 顺序查找（适用于两种存储结构） 折半查找（有序表） 注意区分 “有序” 和 “
[数据结构]【C++】实验七 查找实验 7.1 实验目的(1) 掌握顺序表的查找方法，尤其是二分查找方法。(2) 掌握二叉排序树的建立及查找。 查找是软件设计中的最常用的运算，查找所涉
m0_73952999的博客
06-19 553
首先，如前面的任务一样，根据文件读写到的数据查找二叉排序树中的对应节点，在传入数据中，利用lu_all来记录查找的次数。前者可通过顺序排序后进行二分查找的方法进行查找。此题我有两种实现方法，首先第一种通过输入的各个元素值，构建正确的二叉排序树，通过返回对应的二叉树根节点指针与题中所给的数据挨个元素经行对比，进行中序遍历，与题中数据对比后，若有数据不同则二叉排序树并非正确。测试数据：在任务(1)中第一组测试数据所构造的二叉排序树中，分别查找下列元素： 150，70，160，190，10，55，175。
【C语言督学训练营 第十五天】常用的查找算法----顺序查找、二分查找、二叉排序树
一个非常Cool的人
06-25 408
本篇博客会介绍到数据结构中常用到的查找算法，合理的使用查找算法可以让我们很轻松找到自己想要的答案。本小节必须掌握的是顺序查找、二分查找、二叉排序树的建立，有剩余时间可以实现二叉排序树的节点删除。
数据结构实验四 : 查找和排序算法实现
imbzz的博客
01-31 1289
数据结构实验四 : 查找和排序算法实现
数据结构实验-顺序表的查找
qq_62899367的博客
11-08 2800
数据结构实验-顺序表的查找，仅供参考。
【数据结构(C语言)】数据结构-查找
PKM of bk
01-01 1313
主要内容： 一、基本概念：包括查找表、关键字、查找； 二、查找算法的性能分析：包括平均查找长度(Average Search Length)； 三、基于线性表的查找：包括存储结构的定义、静态查找表的顺序查找、有序顺序表的折半查找； 四、基于树的查找：包括二叉排序树、平衡二叉树、B-树、B+树； 五、基于散列表的查找：包括、定义和术语、散列函数需要考虑的因素、散列函数的构造方法、处理冲突的方法、实现。
【考研—数据结构】查找合集
高斯的博客
08-31 3965
静态查找（顺序、二分、分块）、动态查找(平衡树系列)、散列查找（hash)
c语言数据结构算法演示(Windows版)
11-03
（1）在二叉排序树上进行查找(bstsrch)、插入结点(ins_bstree)和删除结点(del_bstree) （2）在二叉平衡树上插入结点(ins_AVLtree) 和删除结点(del_AVLtree) （3）在 B-树上插入结点(Ins_BTree) 和 删除结点(Del_...
2022春季数据结构期中考试总结
努力的小白马
04-28 4992
Table of contents判断题1.若用平方探测法解决冲突，则插入新元素时，若散列表容量为质数，插入就一定可以成功。2.算法分析的两个主要方面是时间复杂度和空间复杂度的分析。3.在散列中，函数“插入”和“查找”具有同样的时间复杂度。4.在具有N个结点的单链表中，访问结点和增加结点的时间复杂度分别对应为O(1)和O(N)。5.非空二叉树的形态：一棵非空二叉树，若先序遍历与后序遍历的序列相反，则该二叉树只有一个叶子结....
数据结构 第五章 树与二叉树 习题
AnthonyM08的博客
11-08 1986
@TOC 5.1 树的基本概念 定义 在任意一棵非空树中应满足： 1）有且仅有一个特定的称为根的结点。 2）当n>1n>1n>1时，其余节点可分为mmm个互不相交的有限集T1T2...TmT_1T_2...T_mT1​T2​...Tm​，其中每个集合本身又是一棵树，称为根的子树。 特点 树是一种递归的数据结构。 1）树的根结点没有前驱，除根节点外的所有结点有且只有一个前驱。 2）树中所有结点可以有零个或多个后继。 树适合表示有层次的数据结构，某个结点（除根节点外）最多只和其父节点有直接关系
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1278
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
二叉树最小深度
2301_80161204的博客
09-27 467
25[0, 105]
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1004
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
【理论科学与实践技术】数学与经济管理中的学科与实用算法
最新发布
wnm23的专栏
10-02 506
在现代商业环境中，数学与经济管理的结合为企业提供了强大的决策支持。本文将介绍几个主要学科，包括数学基础、经济学模型、管理学及风险管理，并探讨相关的实用算法和这些算法在中国及全球知名企业中的实际应用。
DAY17||654.最大二叉树 |617.合并二叉树 |700.二叉搜索树中的搜索 |
2301_79865280的博客
09-29 1279
给定一个不含重复元素的整数数组。通过给定的数组构建最大二叉树，并且输出这个树的根节点。示例 ：构造二叉树一定要，因为要先找到中，才能分割左右子树。本题图解思路：本题做过上一题构建数组确实变得容易很多。代码优化方向有，不用每次找左右子树的时候构建新的数组的话效率就会高很多。（即直接用下标索引直接在原数组上操作）关于加不加if的问题，如果允许空节点进入递归，就不加。
【韩顺平Java笔记】第6章：数组、排序和查找
随手写写
10-02 491
排序是将多个数据，依指定的顺序进行排列的过程。
优化查找策略：顺序、折半与二叉排序树的数据结构实现
实验目标包括理解查找表的基本概念，掌握顺序查找、折半查找以及二叉排序树（BST）的操作方法，同时分析其性能并计算平均查找长度。 首先，实验开始于介绍查找表的基础知识，特别是静态查找表，包括顺序查找表。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

juechen333

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

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

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

打赏作者

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

抵扣说明：

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

余额充值