第六周总结03

已于 2023-04-13 17:56:23 修改
阅读量49 收藏
点赞数
文章标签： 数据结构
于 2023-04-10 11:00:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Laser_song/article/details/130048948
版权

数据结构

树型结构

树的基本概念

  • 一种表示层次关系（一对多）的数据结构
  • 有且仅有一个特定的节点，该节点没有前趋，被称为根节点
  • 剩余的n个不相交的子集，其中每个子集也都是一棵树，被称为它们根节点的子树
  • 注意：树形结构有递归性（树中有树）

树的表示方式：

  • 倒悬树、嵌套法、凹凸法

树的专业术语：

  • 节点：组成树的基本元素，同时它也是一棵树
  • 节点的度：该节点的子树数量
  • 树的度：树中节点的数量
  • 树的层次：从根节点层次为1出发计算
  • 树的深度：树的最大层次数
  • 叶子节点：节点的度为0的节点
  • 双亲和孩子节点：节点的子树称为该节点的孩子节点，该节点就是它们孩子节点的双亲结点
  • 兄弟节点：具有同一个双亲节点，互为兄弟节点
  • 堂兄弟节点：双亲节点在同一层次的节点，互为堂兄弟
  • 祖先节点：从根结点出发到该节点，经过的所有节点都称为该节点的祖先节点
  • 子孙节点：一个节点的子树中任意一个节点都是它的子孙节点
  • 森林：n个不相交的树组成的集合称为森林

树的存储

  • 树可以顺序存储，也可以链式存储，还可以混合存储

  • 由于存储的信息的不同，有以下的存储表示方式：

    • 双亲表示法：

      • 顺序存储：

        • 位置data双亲位置
          0A-1
          1B0
          2C0
          3D0
          4E1
          5F1
          6G3
          7H3
          8I7

        • 优点：方便找到双亲

        • 缺点：查找孩子节点需要遍历，不方便

    • 孩子表示法：

      • 顺序存储：浪费空间

        • 位置data存孩子位置的数组sub_arr[n-1]
          0A1、2、3
          1B4、5
          2C
          3D6、7
          4E
          5F
          6G
          7H8
          8I

      • 链式存储：节约空间

        • 位置dataListHead
          0A1->2->3->N
          1B4->5->N
          2C
          3D6->7->N
          4E
          5F
          6G
          7H8->N
          8I

        • 优点：方便找孩子

        • 缺点：找双亲不方便

    • 兄弟表示法：

      • 双亲只存储第一个子节点，然后链式指向所有的兄弟节点
      • 优点：方便查找到所有的兄弟节点、孩子节点
      • 缺点：不方便找双亲

  • 注意：普通树不常用，一般会把普通树转换成二叉树使用

二叉树

  • 是一种常用的数据结构，处理起来比较简单方便，并且普通树可以很方便地转换成二叉树
  • 普通树转二叉树：孩子变左节点，兄弟变右节点

定义：

  • 节点的度最多为2
  • 在二叉树中，一个元素也称作一个节点
  • 二叉树是n个有限元素的集合，该集合或者为空、或者由一个称为根（root）的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成，是有序树
  • 当集合为空时，该二叉树称为空二叉树

特殊的二叉树：

  • 满二叉树：

    • 二叉树的每层节点数都满足 2^(i-1) 个，则这棵二叉树为满二叉树

  • 完全二叉树：

    • 深度为k，有n个节点的二叉树当且仅当其每一个节点都与深度为k的满二叉树中编号从1到n的节点一一对应时，称为完全二叉树

*二叉树性质：

  • 性质1：二叉树的第i层上至多有2^(i-1)（i≥1）个节点
  • 性质2：深度为h的二叉树中至多含有2^h-1个节点
  • 性质3：若在任意一棵二叉树中，有n0个叶子节点，有n2个度为2的节点，则必有n0=n2+1
  • 性质4：具有n个节点的满二叉树深为log2n+1
  • 性质5：若对一棵有n个节点的完全二叉树进行顺序编号（1≤i≤n），那么，对于编号为i（i≥1）的节点：
    • 当i=1时，该节点为根，它无双亲节点
    • 当i>1时，该节点的双亲节点的编号为i/2
    • 若2i≤n，则有编号为2i的左节点，否则没有左节点
    • 若2i+1≤n，则有编号为2i+1的右节点，否则没有右节点

二叉树的常用操作

  • 构建、销毁 、遍历、高度、密度、添加、删除、查询、求左、求右、求根

二叉树的遍历

前序遍历：

  • 根、左、右

中序遍历

  • 左、根、右

后序遍历

  • 左、右、根

注意：前中后由根节点的遍历次序决定、并且左右子树的次序不会改变

注意：根据 中序+前序 或者 中序+后序 可以还原一棵树，无法通过 前序+后序 还原

层序遍历

  • 从上到下，从左到右依次遍历，必须与队列配合

二叉树的存储

顺序存储：

  • 必须按照完全二叉树的格式存储

  • 空位置使用特殊数据代替

  • 数据项：

    • 存储节点的内存首地址

    • 容量

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include "list_queue.h"

#define TREE_TYPE char

typedef struct BinTree
{
	TREE_TYPE* arr;
	size_t cal;
}BinTree;

//	构建 ‘#’空位置
BinTree* create_tree(const TREE_TYPE* arr,size_t len)
{
	BinTree* tree = malloc(sizeof(BinTree));
	tree->arr = malloc(sizeof(TREE_TYPE)*len);
	memcpy(tree->arr,arr,sizeof(TREE_TYPE)*len);
	tree->cal = len;
	return tree;
}

//	对编号为index的节点进行前序遍历
void _dlr_show(BinTree* tree,size_t index)
{
	//	编号-1=下标
	if(index-1 >= tree->cal || '#' == tree->arr[index-1]) return;
	//	根
	printf("%c ",tree->arr[index-1]);
	//	左
	_dlr_show(tree,index*2);
	//	右
	_dlr_show(tree,index*2+1);
}
//	前序遍历
void dlr_show(BinTree* tree)
{
	_dlr_show(tree,1);
	printf("\n");
}

//	对编号为index的节点进行中序遍历
void _ldr_show(BinTree* tree,size_t index)
{
	if(index-1 >= tree->cal || '#' == tree->arr[index-1]) return;
	_ldr_show(tree,index*2);
	printf("%c ",tree->arr[index-1]);
	_ldr_show(tree,index*2+1);
}
//	中序遍历
void ldr_show(BinTree* tree)
{
	_ldr_show(tree,1);
	printf("\n");
}

//	对编号为index的节点进行后序遍历
void _lrd_show(BinTree* tree,size_t index)
{
	if(index-1 >= tree->cal || '#' == tree->arr[index-1]) return;
	_lrd_show(tree,index*2);
	_lrd_show(tree,index*2+1);
	printf("%c ",tree->arr[index-1]);
}
//	后序遍历
void lrd_show(BinTree* tree)
{
	_lrd_show(tree,1);	
	printf("\n");
}

//	层序遍历
void layer_show(BinTree* tree)
{
	ListQueue* queue = create_list_queue();
	push_list_queue(queue,1);	// 入编号

	while(!empty_list_queue(queue))
	{
		int index = head_list_queue(queue);

		//	入左子树
		int left = index*2;
		if(left-1<tree->cal && '#' != tree->arr[left-1])
			push_list_queue(queue,left);
		//	入右子树
		int right = index*2+1;
		if(right-1<tree->cal && '#' != tree->arr[right-1])
			push_list_queue(queue,right);

		printf("%c ",tree->arr[index-1]);
		pop_list_queue(queue);
	}
	destroy_list_queue(queue);
	printf("\n");
}

//	计算编号index的节点的高度
int _high_tree(BinTree* tree,size_t index)
{
	if(index-1 >= tree->cal || '#' == tree->arr[index-1])
		return 0;
	int left_high = _high_tree(tree,index*2);
	int right_high = _high_tree(tree,index*2+1);
	
	return left_high>right_high ? left_high+1 : right_high+1;
}

//	树的高度
int high_tree(BinTree* tree)
{
	return _high_tree(tree,1);
}

//	计算编号index节点的密度
int _density_tree(BinTree* tree,size_t index)
{
	if(index-1 >= tree->cal || '#' == tree->arr[index-1])
		return 0;
	return _density_tree(tree,index*2) + 
		_density_tree(tree,index*2+1) + 1;
}

//	树的密度
int density_tree(BinTree* tree)
{
//	return _density_tree(tree,1);
	int density = 0;
	for(int i=0; i<tree->cal; i++)
	{
		if('#' != tree->arr[i]) density++;
	}
	return density;
}

//	插入 只能插入到空位置
bool insert_tree(BinTree* tree,TREE_TYPE data,TREE_TYPE pdata)
{
	size_t index = 1;
	while(index-1 < tree->cal)
	{
		if(tree->arr[index-1] == pdata)
		{
			//	扩容
			if(index*2-1 >= tree->cal)
			{
				tree->arr = 
				realloc(tree->arr,tree->cal*2*sizeof(TREE_TYPE));
				for(int i=tree->cal; i<tree->cal*2; i++)
					tree->arr[i] = '#';
				tree->cal *= 2;
			}

			if('#' == tree->arr[index*2-1])
			{
				tree->arr[index*2-1] = data;
				return true;
			}
			else if('#' == tree->arr[index*2])
			{
				tree->arr[index*2] = data;
				return true;
			}
			return false;
		}
		index++;
	}
	return false;
}

//	删除叶子节点
bool del_tree(BinTree* tree,TREE_TYPE data)
{
	size_t index = 1;
	while(index-1 < tree->cal)
	{
		if(data == tree->arr[index-1])
		{
			if(index*2-1 < tree->cal && '#'!=tree->arr[index*2-1])
				return false;
			if(index*2 < tree->cal && '#'!=tree->arr[index*2])
				return false;
			tree->arr[index-1] = '#';
			return true;
		}
		index++;
	}
	return false;
}

//	求左(返回编号)
int left_tree(BinTree* tree,TREE_TYPE data)
{
	size_t index = 1;
	while(index-1 < tree->cal)
	{
		if(data == tree->arr[index-1])	
		{
			if(index*2-1 < tree->cal && '#'!=tree->arr[index*2-1])
				return index*2;
			return 0;
		}
		index++;
	}
	return 0;
}
//	求右
int right_tree(BinTree* tree,TREE_TYPE data)
{
	size_t index = 1;
	while(index-1 < tree->cal)
	{
		if(data == tree->arr[index-1])	
		{
			if(index*2 < tree->cal && '#'!=tree->arr[index*2])
				return index*2+1;
			return 0;
		}
		index++;
	}
	return 0;
}
//	求根节点编号
int root_tree(BinTree* tree,TREE_TYPE data)
{
	size_t index = 1;
	while(index-1 < tree->cal)
	{
		if(data == tree->arr[index-1])	
		{
			return index;
		}
		index++;
	}
	return 0;	
}
//	根据编号显示数据
void index_show_tree(BinTree* tree,size_t index)
{
	if(0 == index || index-1 >= tree->cal) return;
	printf("%c ",tree->arr[index-1]);
}

int main(int argc,const char* argv[])
{
	char* str = "ABCD#EFGH##I##J";
	BinTree* tree = create_tree(str,strlen(str));
	
	insert_tree(tree,'X','B');
	insert_tree(tree,'Y','J');
	del_tree(tree,'H');
	del_tree(tree,'G');
	del_tree(tree,'D');

	dlr_show(tree);
	ldr_show(tree);
	lrd_show(tree);
	layer_show(tree);
	printf("high:%d\n",high_tree(tree));
	printf("density:%d\n",density_tree(tree));
	index_show_tree(tree,left_tree(tree,'C'));
}

链式存储：

  • 由一个个节点组成，每个节点也都是一棵树

  • 数据项：

    • 数据
    • 左子树指针
    • 右子树指针
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define TREE_TYPE char
#define EMPTY '#'
#define END '\0'

// 节点
typedef struct TreeNode
{
	TREE_TYPE data;
	struct TreeNode* left;
	struct TreeNode* right;
}TreeNode;

// 创建节点函数
TreeNode* create_tree_node(TREE_TYPE data)
{
	TreeNode* node = malloc(sizeof(TreeNode));
	node->data = data;
	node->left = NULL;
	node->right = NULL;
	return node;
}
/*
// 构建一棵树 前序
TreeNode* create_tree(void)
{
	TREE_TYPE data = 0;
	scanf("%c",&data);
	if(EMPTY == data) return NULL;
	TreeNode* node = create_tree_node(data);
	node->left = create_tree();
	node->right = create_tree();
	return node;
}
*/

TreeNode* _create_tree(char** str)
{
	if(EMPTY == **str || END == **str) return NULL;
	TreeNode* node = create_tree_node(**str);
	*str += 1;
	node->left = _create_tree(str);
	*str += 1;
	node->right = _create_tree(str);
	return node;
}
// 构建 前序
TreeNode* create_tree(char* str)
{
	_create_tree(&str);
}

// 前序遍历
void dlr_show(TreeNode* root)
{
	if(NULL == root) return;
	printf("%c ",root->data);
	dlr_show(root->left);
	dlr_show(root->right);
}

void ldr_show(TreeNode* root)
{
	if(NULL == root) return;
	ldr_show(root->left);
	printf("%c ",root->data);
	ldr_show(root->right);
}

void lrd_show(TreeNode* root)
{
	if(NULL == root) return;
	lrd_show(root->left);
	lrd_show(root->right);
	printf("%c ",root->data);
}

// 树的高度
int high_tree(TreeNode* root)
{
	if(NULL == root) return 0;

	int lh = high_tree(root->left);
	int rh = high_tree(root->right);

	return lh>rh ? lh+1 : rh+1;
}

// 树的密度
int density_tree(TreeNode* root)
{
	if(NULL == root) return 0;
	return density_tree(root->left)+density_tree(root->right)+1;
}

// 求左
TreeNode* left_tree(TreeNode* root,TREE_TYPE data)
{
	if(NULL == root) return NULL;
	if(root->data == data)
		return root->left;
	TreeNode* left = left_tree(root->left,data);
	TreeNode* right = left_tree(root->right,data);

	return left?left:right;
}

// 插入
bool insert_tree(TreeNode* root,TREE_TYPE pdata,TREE_TYPE data)
{
	if(NULL == root) return false;
	if(root->data == pdata)
	{
		if(NULL == root->left)
			return root->left = create_tree_node(data);
		if(NULL == root->right)
			return root->right = create_tree_node(data);
		return false;
	}
	if(insert_tree(root->left,pdata,data)) return true;
	return insert_tree(root->right,pdata,data);
}

// 删除
bool del_tree(TreeNode** root,TREE_TYPE data)
{
	if(NULL == root) return false;
	if((*root)->data == data)
	{
		if((*root)->left || (*root)->right) return false;
		free(*root);
		*root = NULL;
		return true;
	}
	if(del_tree(&(*root)->left,data)) return true;
	return del_tree(&(*root)->right,data);
}

// 销毁
void destroy_tree(TreeNode* root)
{
	if(NULL == root) return;
	destroy_tree(root->left);
	destroy_tree(root->right);
	free(root);
}

int main(int argc,const char* argv[])
{
	TreeNode* root = create_tree("ABDG##H###CEI###F#J##");
	// ABDG##H###CEI###F#J##

	insert_tree(root,'B','X');

	del_tree(&root,'G');

	dlr_show(root);
	printf("\n");
	ldr_show(root);
	printf("\n");
	lrd_show(root);
	printf("\n%c\n",left_tree(root,'A')->data);
	destroy_tree(root);
	root = NULL;
}
Laser_song
关注
Java学习第六周学习总结
10-16
内容包括集合框架，泛型以及实用类
520_第六周学习总结1
08-08
在本篇520第六周学习总结中，主要讨论了动态规划（Dynamic Programming，简称DP）、深度优先搜索（Depth First Search，简称DFS）以及字典树（Trie）的应用，并涉及了双向广度优先搜索（BFS）的模板代码。...
学院第六周政治理论学习活动总结.docx
02-19
学院第六周政治理论学习活动总结.docx
第六周实习总结实习学习总结.doc
12-06
在第六周的实习过程中，我深入参与了多项关键的建筑工程任务，这不仅加深了我对理论知识的理解，也强化了我的实践技能。以下是我对本周实习学习的一些主要总结。 首先，我参与了承台梁线的放射与浇筑工作。放射线是...
Java第三周总结图片
12-01
在Java编程语言的学习过程中，第三周的总结涵盖了多个核心概念，这些都是成为一名熟练的Java开发者的基础。以下是关于这些关键知识点的详细解释： 1. **基础语法**：Java的基础语法是学习的起点，包括变量声明、...
数据结构：树的定义及其性质
pranaa的博客
09-24 708
树是一种重要的非线性数据结构，树作为一种逻辑结构，同时也是一种分层结构。具有以下两个特点：1.树的根结点没有前驱，除根结点意外的节点只有一个前驱2.树中所有结点都可以有0个或多个后继树结构在多个领域都有广泛应用，如表示文件系统的结构、数据库的索引、层次数据关系等。具体来说，树是由n（n≥0）个节点组成的有限集合。当n=0时，称为空树；当n>0时，为非空树。
数据结构之——栈
m0_71974552的博客
09-24 1187
栈：数据结构的基石
matlab的‌基础语法和数据类型
weixin_45710581的博客
09-25 582
MATLAB中的函数用于封装可重复使用的代码块。
数据结构：详解搜索二叉树
最新发布
Another_Shi的博客
09-28 778
搜索二叉树的结构跟二叉树差不多——两个指针来指向左右子树，一个对象来存放数据。
数据结构：树、森林
pranaa的博客
09-24 1005
此外，访问子节点和父节点的索引计算也会变得复杂，因为需要额外的数据结构（如指针或索引数组）来跟踪每个节点的子节点位置。在转换为二叉树时，我们可以将节点的第一个孩子视为二叉树的左孩子，将节点的下一个兄弟视为二叉树的右孩子。这种转换在处理树形结构的问题时非常有用，因为二叉树具有一些特殊的性质（如左子树和右子树的明确区分）和高效的算法（如二叉搜索树、堆等）。二叉树和树的顺序存储结构在本质上是相似的，但由于二叉树结构的特殊性，它在顺序存储中更加高效和直接。二叉树转换为树的过程是上述转换的逆过程。
代码随想录算法训练营 | 二叉树理论基础
jiabao0520的博客
09-22 596
训练营：二叉树理论基础
数据结构：串 及串的模式匹配（KMP）
pranaa的博客
09-23 1178
串（String）是由零个或多个字符组成的有限序列，又名叫字符串。在计算机科学中，串是一种重要的数据结构，用于表示文本数据。串中的元素称为字符，字符可以是字母、数字或其他符号，这些字符可以是任意字符集中的成员。串是许多编程语言中的基本数据类型，用于处理文本数据。
数据结构——红黑树
l_tian_tian_的博客
09-22 309
红黑树是一种特化的二叉查找树，它在每个节点上增加了一个存储位来表示节点的颜色，颜色只能是红色或黑色。
数据结构：二叉树的遍历和线索二叉树
pranaa的博客
09-24 785
在普通二叉树中，每个节点有两个指针域，分别指向左右子节点，但在很多情况下，这两个指针域可能为空，这些空指针域就称为“空域”。线索二叉树就是将这些空域利用起来，存储指向该节点在某种遍历次序下的前驱和后继节点的指针（或线索）。二叉树的遍历是二叉树的一种重要的操作，指按照某种顺序访问树中的每个节点，并且每个节点仅被访问一次。首先访问根节点，然后递归地进行前序遍历左子树，最后递归地进行前序遍历右子树。首先递归地进行后序遍历左子树，然后递归地进行后序遍历右子树，最后访问根节点。遍历完左子树后，访问根节点，然后根据。
数据结构总结
m0_73504072的博客
09-25 1033
顺序表是数组是一块连续存储的存储元素 ，每个元素的地址是连续的而链表是存放在内存碎片中的他的存储是不连续的 链表是包含指针域和数据域的顺序表在索引的时候可通过下标可直接查看到数据 时间复杂度为O（1）而链表在进行索引的时候他的时间复杂度则是O（n）；顺序表在进行删除和添加的时候需要大量移动数据这样会增加他的时间复杂度而链表在进行 添加和删除时并不需要大量的移动数据队列是先进先出栈是后进先出。
Java-数据结构-排序-(二) (๑¯∀¯๑)
2303_80388948的博客
09-22 1295
OK，我们这次的博客就到这里就结束了，我们这次博客虽然我们只介绍了 一类排序——交换排序，但是呢我们这篇博客是非常重要的，因为我们的快速排序是经常使用的排序方法，所以要多加理解这个排序。我们在下一篇博客就会把排序收尾，让我们尽情期待吧！！！拜拜~~~。
【数据结构和算法实践-排序-总结】
Mao_c的博客
09-25 694
排序算法 原理 时间复杂度 空间复杂度 稳定性 备注 冒泡排序 通过重复遍历要排序的数列，比较相邻元素的值，若发现顺序错误则交换它们的位置，直到没有需要交换的元素为止，表示数列已经排序完成。 平均和最坏情况：O(n^2)最好情况：O(n)（已排序） O(1) 稳定 简单的排序算法，适用于小规模数据。 选择排序 遍历数组，每次从未排序的部分找到最小（或最大）的元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。 平均、最好和最坏情
数据结构：二叉树OJ题（基础版）
2303_78940834的博客
09-22 1011
更完两期二叉树的知识之后，来做几道oj题巩固一下基础。
数据结构：栈 及其应用
pranaa的博客
09-23 1369
栈（Stack）是一种遵循后进先出（LIFO, Last In First Out）原则的有序集合 （受限的线性表）。这种数据结构只允许在栈顶进行添加（push）或删除（pop）元素的操作。栈是一种非常基础且重要的数据结构，广泛应用于计算机科学和软件开发中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值