数据结构——树

最新推荐文章于 2024-05-19 17:03:37 发布
最新推荐文章于 2024-05-19 17:03:37 发布
阅读量183 收藏 1
点赞数
文章标签： 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mingbo64/article/details/117252774
版权

树型结构：

1、树的基本概念

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

2、树的表示方法：

    倒悬树、嵌套法、凹凸法

3、树的专业术语

    节点：      组成树的基础元素，同时它也是一棵树
    节点的度：  该节点的子树的数量,与该节点有直接关系的
    树的度(密度)：树中节的度的最大值
    树的深度：  树的最大层次树为树的深度
    节点的层次：根节点的层次为1，它的孩子层次为2，孩子的孩子层次为3，以此类推
    叶子节点：  节点的度为0的节点
    双亲和孩子：节点的子树称为它的孩子节点，则该节点为孩子节点的双亲
    兄弟节点：  具有同一个双亲节点的节点 
    祖先：    从根节点出发到该节点，经过的所有节点都被称为该节点的祖先
    子孙：  一个节点的子树中任意的一个节点都被称为它的子孙
    堂兄弟： 双亲不是同一个节点，但是双亲在同一层的节点互为堂兄弟     
    森林：  n个不相交的树的集合称为森林

4、树的存储

在这里插入图片描述

    树可以顺序存储、链式存储，也可以混合存储，由于存储的信息不同，有以下表示方式：
        位置    data  双亲 
         0       A    -1
         1       B     0
         2       C     0
         3       D     1
         4       E     2
         5       F     2
         6       G     3
         7       H     4
         8       I     4
    优点：方便找到双亲
    缺点：查找孩子节点不方便

在这里插入图片描述
list_queue.h

#ifndef LIST_QUEUE_H
#define LIST_QUEUE_H

#include <stdlib.h>
#include <stdbool.h>

#define TYPE int

//	设计节点
typedef struct Node
{
	TYPE data;
	struct Node* next;
}Node;

//	设计链式队列结构
typedef struct ListQueue
{
	Node* head;	//	指向队头节点的指针
	Node* tail;	//	指向队尾节点的指针
	size_t size;//	节点个数
}ListQueue;

//	创建节点
Node* create_node(TYPE val);

//	创建队列结构
ListQueue* create_list_queue(void);

//	队空
bool empty_list_queue(ListQueue* queue);

//	入队
void push_list_queue(ListQueue* queue,TYPE val);

//	出队
bool pop_list_queue(ListQueue* queue);

//	队头
TYPE head_list_queue(ListQueue* queue);

//	队尾
TYPE tail_list_queue(ListQueue* queue);

//	数量
size_t size_list_queue(ListQueue* queue);

//	销毁
void destory_list_queue(ListQueue* queue);

#endif//LIST_QUEUE_H

list_queue.c

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

//	顺序存储 双亲表示法

//	设计节点
typedef struct TreeNode
{
	char data;	//	数据
	int parent;	//	双亲节点下标
}TreeNode;

//	设计树的顺序结构
typedef struct Tree
{
	TreeNode* arr;	//	存储节点内存的首地址
	size_t cal;		//	容量
	size_t cnt;		//	节点个数
}Tree;

//	创建
Tree* create_tree(size_t cal)
{
	Tree* tree = malloc(sizeof(Tree));
	tree->arr = malloc(sizeof(TreeNode)*cal);//申请出一块连续的存储节点的内存
	tree->cal = cal;
	tree->cnt = 0;
	return tree;
}

//	parent是双亲的data
//  添加子树
bool add_tree(Tree* tree,char data,char parent)
{
	//	树不存在满的情况，可以扩容
	if(tree->cnt >= tree->cal)
	{
		tree->cal *= 2;
		tree->arr = realloc(tree->arr,sizeof(TreeNode)*tree->cal);//扩容tree->arr,sizeof(TreeNode)*tree->cal是扩容后的大小）
	}

	//	默认根节点的双亲是'\0'
	if('\0' == parent)
	{
		tree->arr[0].data = data;
		tree->arr[0].parent = -1;
		tree->cnt = 1;
		return true;
	}

	for(int i=0; i<tree->cnt; i++)
	{
		if(tree->arr[i].data == parent)
		{
			tree->arr[tree->cnt].data = data;
			tree->arr[tree->cnt++].parent = i;
			return true;
		}
	}
	return false;
}

void show_tree(Tree* tree)
{
	for(int i=0; i<tree->cnt; i++)
	{
		printf("index: %d  data: %c parent： %d\n",
			i,tree->arr[i].data,tree->arr[i].parent);
	}
}

//	计算节点的度
int node_count(Tree* tree,char data)
{
	int count = 0,index = -1;
	for(int i=0; i<tree->cnt; i++)
	{
		if(data == tree->arr[i].data)
		{
			index = i;
			break;
		}	
	}
	if(-1 == index) return -1;
	for(int i=0; i<tree->cnt; i++)
	{
		if(index == tree->arr[i].parent)
		{
			count++;	
		}
	}
	return count;
}

//	层序遍历 
void level_show_tree(Tree* tree)
{
	//	创建一个队列
	ListQueue* queue = create_list_queue();//创建queue队列

	//	根节点入队
	push_list_queue(queue,tree->arr[0].data);//入队

	while(!empty_list_queue(queue))//队列为空时结束
	{
		//	出队队头并显示
		char data = head_list_queue(queue);//查看队头，赋给data
		printf("%c ",data);
		pop_list_queue(queue);//出队

		//	找出该节点的子节点并入队
		int index = -1;
		for(int i=0; i<tree->cnt; i++)
		{
			if(data == tree->arr[i].data)
			{
				index = i;
				break;
			}
		}
		for(int i=0; i<tree->cnt; i++)
		{
			if(index == tree->arr[i].parent)
			{
				push_list_queue(queue,tree->arr[i].data);	
			}
		}
	}
	//	销毁队列，queue是自己创的，次数多了的话会造成内存泄露
	destory_list_queue(queue);
}

int main(int argc,const char* argv[])
{
	Tree* tree = create_tree(10);
	add_tree(tree,'A','\0');
	add_tree(tree,'B','A');
	add_tree(tree,'C','A');
	add_tree(tree,'D','B');
	add_tree(tree,'E','C');
	add_tree(tree,'F','C');
	add_tree(tree,'G','D');
	add_tree(tree,'H','E');
	add_tree(tree,'I','E');
	add_tree(tree,'X','B');
	add_tree(tree,'Y','B');
	show_tree(tree);
	printf("count:%d\n",node_count(tree,'C'));
	level_show_tree(tree);
}

孩子表示法：

        顺序：  浪费内存
        位置    data  sub_arr(存储子节点下标的数组)
        0       A    1、2
        1       B    3
        2       C    4、5
        3       D    6
        4       E    7、8
        5       F    
        6       G     
        7       H     
        8       I     
        链式：  节约空间
        位置    data  ListHead
        0       A    1->2->N
        1       B    3-N
        2       C    4->5->N
        3       D    6->N
        4       E    7->8->N
        5       F    
        6       G     
        7       H     
        8       I 
        优点：方便找孩子
        缺点：查找双亲节点麻烦

兄弟表示法：

        双亲只存储第一个子节点，然后链式地指向所有的兄弟节点
        数据域：
            第一个子节点，数据，兄弟节点指针
        优点：可以方便地查询到所有的兄弟节点
        缺点：查找双亲麻烦
    
    总结：普通树不常用，一般需要转换为二叉树使用

二叉树：

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

特殊的二叉树：

    每层的节点数都是2^(i-1)，这种树叫做满二叉树
    深度为k，有n个结点的二叉树当且仅当其每一个结点都与深度为k的满二叉树中编号从1到n的结点一一对应时，称为完全二叉树

二叉树的性质：

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

二叉树的操作：

    构建、销毁、遍历、深度、密度、插入、删除、查询、求左、求右、求根

二叉树的遍历：

在这里插入图片描述

    前序：根、左、右
    中序：左、根、右
    后序：左、右、根
    注意：前中后序由根节点决定，并且左右子树的次序不能改变
    注意：前序+中序、后序+中序 能够还原一棵树，前序+后序是无法还原的(因为无法确定根的左右子树)
    
    层序：从上到下、从左到右遍历一棵树，必须与队列配合使用

gcc -std=gnu99 list_queue.c bin_array_tree.c

二叉树的存储：

顺序：

    必须按照完全二叉树的格式存储，空位置使用特殊数据代替
        数据项：
            容量

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

#define TREE_TYPE char
#define EMPTY '#'

typedef struct BinTree
{
	TREE_TYPE* arr; // 存储节点的内存首地址
	size_t cal;
}BinTree;

//	构建
BinTree* create_tree(TREE_TYPE* arr,size_t len)//数组长度
{
	BinTree* tree = malloc(sizeof(BinTree));
	tree->arr = malloc(sizeof(TREE_TYPE)*len);
	//	把arr拷贝到tree->arr
	memcpy(tree->arr,arr,sizeof(TREE_TYPE)*len);
	tree->cal = len;
	return tree;
}

//	销毁
void destory_tree(BinTree* tree) 
{
	free(tree->arr);
	free(tree);
}

void _dlr_show(BinTree* tree,size_t index)
{
	if(index-1 >= tree->cal || EMPTY == 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");
}

void _ldr_show(BinTree* tree,size_t index)
{
	if(index-1 >= tree->cal || EMPTY == 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");
}

void _lrd_show(BinTree* tree,size_t index)
{
	if(index-1 >= tree->cal || EMPTY == 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 level_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 && EMPTY != tree->arr[left-1])
		{
			push_list_queue(queue,left);
		}
		int right = index*2+1;
		if(right-1 < tree->cal && EMPTY != tree->arr[right-1])
		{
			push_list_queue(queue,right);	
		}
	//	打印队头
		printf("%c ",tree->arr[index-1]);
	//	队头出队
		pop_list_queue(queue);
	}
	destory_list_queue(queue);
}

int _high_tree(BinTree* tree,size_t index)
{
	//	出口
	if(index-1 >= tree->cal || EMPTY == tree->arr[index-1]) 
		return 0;
	int lh = _high_tree(tree,index*2);
	int rh = _high_tree(tree,index*2+1);
	return lh > rh ? lh+1 : rh+1;
}

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

int _density_tree(BinTree* tree,size_t index)
{
	if(index-1 >= tree->cal || EMPTY == tree->arr[index-1])
		return 0;
	return 1+_density_tree(tree,index*2)+_density_tree(tree,index*2+1);
}

//	树的密度 求节点总个数
int density_tree(BinTree* tree)
{
	//	return _density_tree(tree,1);
	//  循环比递归快
	
	int density = 0;
	for(int i=0; i<tree->cal; i++)
	{
		if(EMPTY != tree->arr[i]) density++;
	}
	return density;
	
}

//	插入
bool insert_tree(BinTree* tree,TREE_TYPE pdata,TREE_TYPE data)
{
	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+1);
				for(int i=tree->cal; i<(tree->cal*2+1); i++)
					tree->arr[i] = EMPTY;
				tree->cal = tree->cal*2+1;
			}
			
			if(EMPTY == tree->arr[index*2-1])
				return tree->arr[index*2-1] = data;
			if(EMPTY == tree->arr[index*2])
				return tree->arr[index*2] = data;
			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])
		{
			//	左右子树超出范围，一定是叶子节点
			//	如果不超范围，左右都为空也一定是叶子节点
			//  也可以用高度判断叶子节点，叶子结点的高度为1，如果高度为其他数则不是
			if(index*2-1 < tree->cal && EMPTY != tree->arr[index*2-1])
				return false;
			if(index*2 < tree->cal && EMPTY != tree->arr[index*2])
				return false;
			tree->arr[index-1] = EMPTY;
			return true;
		}
		index++;
	}
	return false;
}


//	求左子树的下标
int left_tree(BinTree* tree,TREE_TYPE data)
{
	int index = 1;
	while(index-1 < tree->cal)
	{
		if(tree->arr[index-1] == data)
		{
			if(index*2-1 < tree->cal && EMPTY != tree->arr[index*2-1])
			{
				return index*2-1;	//左子树的下标  
			}
			return -1;
		}
		index++;
	}
	return -1;
}

//	求右
int right_tree(BinTree* tree,TREE_TYPE data)
{
	int index = 1;
	while(index-1 < tree->cal)
	{
		if(tree->arr[index-1] == data)
		{
			if(index*2 < tree->cal && EMPTY != tree->arr[index*2])
			{
				return index*2;	
			}
			return -1;
		}
		index++;
	}
	return -1;
}

//	求根
int root_tree(BinTree* tree,TREE_TYPE data)
{
	int index = 1;
	while(index-1 < tree->cal)
	{
		if(tree->arr[index-1] == data)
		{
			return index-1;	
		}
		index++;
	}
	return -1;
}

int main(int argc,const char* argv[])
{
	BinTree* tree = create_tree("ABCD#EFG###HI",13);
	dlr_show(tree);
	ldr_show(tree);
	lrd_show(tree);
	level_show(tree);
	printf("\nhigh:%d\n",high_tree(tree));
	printf("density:%d\n",density_tree(tree));
	printf("left:%d\n",left_tree(tree,'H'));
	insert_tree(tree,'G','X');
	dlr_show(tree);
	del_tree(tree,'A');
	dlr_show(tree);
}

链式：

    由一个个的节点组成，每个节点就是一棵树
        节点数据项：
            数据
            左子树指针
            右子树指针

#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)//*str的指向一直在被改变，所以要传二级指针，共享这个指针
{
	if(EMPTY == **str || END == **str) return NULL;
	TreeNode* node = create_tree_node(**str);
	*str += 1;
	node->left = _create_tree(str);//这里的str已经并定义成二级指针 
	*str += 1;
	node->right = _create_tree(str);
	return node;//返回给他的调用者，即上一个指向他的地址
}	

//	构建二叉树 调用者按照前序结果来构建
TreeNode* create_tree(char* str)
{
	return _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 1+density_tree(root->left)+density_tree(root->right);
}

//	求左
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);
	if(left) return left;
	TreeNode* right = left_tree(root->right,data);
	if(right) return right;
	return NULL;
}

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

//	求根
TreeNode* root_tree(TreeNode* root,TREE_TYPE data);


//	插入
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;
	}
	bool lflag = insert_tree(root->left,pdata,data);
	bool rflag = insert_tree(root->right,pdata,data);
	return lflag || rflag;
}

//	删除
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;
	}
	bool lflag = del_tree(&(*root)->left,data);
	bool rflag = del_tree(&(*root)->right,data);
	return lflag || rflag;
}

int main(int argc,const char* argv[])
{
	TreeNode* root = create_tree("ABDG####CEH##I##F##\0");
/*	printf("high:%d\n",high_tree(root));
	printf("density:%d\n",density_tree(root));
	TreeNode* left = right_tree(root,'C');
	printf("%c\n",left->data);
	insert_tree(root,'F','X');
	insert_tree(root,'F','Y');
*/
	del_tree(&root,'H');
	del_tree(&root,'A');
	ldr_show(root);
}

在这里插入图片描述

有序二叉树：

左子树的数据小于根，右子树的数据大于等于根，这种二叉树称为有序二叉树
注意：有序二叉树的中序遍历就是从小到大，所以有序二叉树也是一种排序算法
对有序二叉树的查找又天然是二分查找，所以经常考
注意：由于这种树的节点需要频繁地插入删除，因此不适合用顺序存储
![在这里插入图片描述](https://img-blog.csdnimg.cn/20210528111425197.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmdibzY0,size_16,color_FFFFFF,t_70)

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

//	有序二叉树

typedef struct TreeNode
{
	int data;
	struct TreeNode* left;
	struct TreeNode* right;
}TreeNode;

TreeNode* create_tree_node(int data)
{
	TreeNode* node = malloc(sizeof(TreeNode));
	node->data = data;
	node->left = NULL;
	node->right = NULL;
	return node;
}

void _insert_tree(TreeNode** root,TreeNode* node)
{
	if(NULL == *root)	//*root指83，即根
	{
		*root = node;
		return;
	}
	if((*root)->data > node->data)
		_insert_tree(&(*root)->left,node);//*root是解一次引用，相当于TreeNode*,是一个指向节点的指针，对指针取地址相当于变成了二级指针
	else
		_insert_tree(&(*root)->right,node);
}

//	插入 有序二叉树重点是插入
void insert_tree(TreeNode** root,int data)//类似不带头节点的链表，需要二级指针
{
	_insert_tree(root,create_tree_node(data));
}

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

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

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

//	查询
bool query_tree(TreeNode* root,int data)
{
	if(NULL == root) return false;
	if(root->data == data) return true;

	if(root->data > data)
		return query_tree(root->left,data);
	else
		return query_tree(root->right,data);
}

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

//	高度
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;
}

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

//	按照中序来查找数据
bool _access_tree(TreeNode* root,size_t index,int* count,int* val)
{
	if(NULL == root) return false;
	_access_tree(root->right,index,count,val);
	if((*count)++ == index)
	{
		*val = root->data;
		return true;
	}
	_access_tree(root->left,index,count,val);
}

//	访问第index小的数
bool access_tree(TreeNode* root,size_t index,int* val)
{
	int count = 1;
	return _access_tree(root,index,&count,val);
}


//	按值删除
bool del_tree(TreeNode** root,int data)
{
	if(NULL == *root) return false;
	if((*root)->data == data)//（*root)->
	{
		TreeNode* temp = *root;
		*root = temp->left;
		if(temp->right)
			_insert_tree(root,temp->right);//需要加判断temp->right 是否为空，若为空加进去会出现段错误
		free(temp);
		return true;
	}
	if(data < (*root)->data)
		return del_tree(&(*root)->left,data);
	else
		return del_tree(&(*root)->right,data);

}

/*-------------------------*/
//	镜像树
void mirror_tree(TreeNode* root)
{
	if(NULL  == root) return false;
	TreeNode* temp = root->left;
	root->left = root->right;
	root->right = temp;
	mirror_tree(root->left);
	mirror_tree(root->right);
}

bool _is_sym(TreeNode* root1,TreeNode* root2)
{
	if(root1->data != root2->data) return false;
	if(NULL == root1 && NULL != root2) return false;
	if(NULL != root1 && NULL == root2) return false;
	if(NULL == root1 && NULL == root2) return true;

	bool lflag = _is_sym(root1->left,root2->right);
	bool rflag = _is_sym(root1->right,root2->left);
	return lflag && rflag;
}

//	对称
bool is_sym(TreeNode* root)
{
	return _is_sym(root->left,root->right);	
}

//	两课树比较
bool treecmp(TreeNode* r1,TreeNode* r2)
{
	if(NULL == r1 && NULL == r2) return true;
	if(NULL == r1 && NULL != r2) return false;
	if(NULL != r1 && NULL == r2) return true;
	
	if(r1->data != r2->data) return false;
	return treecmp(r1->left,r2->left) && treecmp(r1->right,r2->right);
}

//	判断子结构
bool is_son(TreeNode* root1,TreeNode* root2)
{
	if(NULL == root1) return false;

	if(root1->data == root2->data)
		return treecmp(root1,root2);
	return is_son(root1->left,root2) || is_son(root1->right,root2);
}

void __add_tail_list(TreeNode** head,TreeNode* node)
{
	printf("%d\n",node->data);
	if(NULL == *head)
	{
		*head = node;	
	}
	else
	{
		(*head)->left->right = node;
		node->left = (*head)->left;
	}
	(*head)->left = node;
//	 node->right = *head;
}

void _tree_to_list(TreeNode* root,TreeNode** head)
{
	if(NULL == root) return;
	//按照中序添加进链表
	_tree_to_list(root->left,head);
	__add_tail_list(head,root);
	_tree_to_list(root->right,head);
}

//	有序二叉树转有序双向链表
TreeNode* tree_to_list(TreeNode* root)
{
	//	不带头节点的链表
	TreeNode* head = NULL;
	_tree_to_list(root,&head);
	head->left->right = head;	
	return head;
}

void z_show(TreeNode* root)
{
	ListStack* s1 = create_list_stack();
	ListStack* s2 = create_list_stack();

	//	根入s1
	push_list_stack(s1,root);

	while(!empty_list_stack(s1) || !empty_list_stack(s2))
	{
		while(!empty_list_stack(s1))
		{
			TreeNode* node = top_list_stack(s1);
			pop_list_stack(s1);
			printf("%d ",node->data);
			if(node->left) 	push_list_stack(s2,node->left);
			if(node->right)	push_list_stack(s2,node->right);
		}
		while(!empty_list_stack(s2))
		{
			TreeNode* node = top_list_stack(s2);
			pop_list_stack(s2);
			printf("%d ",node->data);
			if(node->right) push_list_stack(s1,node->right);
			if(node->left) 	push_list_stack(s1,node->left);
		}
	}
}

int main(int argc,const char* argv[])
{
	TreeNode* root = NULL;
	for(int i=0; i<10; i++)
	{
		int data = rand()%100;
		insert_tree(&root,data);
	}
	z_show(root);
	/*dd
	TreeNode* head = tree_to_list(root);
	TreeNode* n = head;
	do{
		printf("%d ",n->data);
		n = n->right;
	}while(n!=head);
	TreeNode* root2 = NULL;
	insert_tree(&root2,93);
	insert_tree(&root2,86);
	insert_tree(&root2,92);
	printf("flag=%d\n",is_son(root,root2));
	printf("\n");
	ldr_show(root);
	printf("\n%d\n",query_tree(root,93));
	int num = 0;
	access_tree(root,100,&num);
	printf("num=%d\n",num);
	*/
}

作业：

1、把一棵二叉树转换成它的镜像树

//	镜像树
void mirror_tree(TreeNode* root)
{
	if(NULL  == root) return false;
	TreeNode* temp = root->left;
	root->left = root->right;
	root->right = temp;
	mirror_tree(root->left);
	mirror_tree(root->right);
}

2、输入两棵二叉树A,B，判断B是不是A的子结构（约定空树不是任何树的子结构）

//	两课树比较
bool treecmp(TreeNode* r1,TreeNode* r2)
{
	if(NULL == r1 && NULL == r2) return true;
	if(NULL == r1 && NULL != r2) return false;
	if(NULL != r1 && NULL == r2) return true;
	
	if(r1->data != r2->data) return false;
	return treecmp(r1->left,r2->left) && treecmp(r1->right,r2->right);
}

//	判断子结构
bool is_son(TreeNode* root1,TreeNode* root2)
{
	if(NULL == root1) return false;

	if(root1->data == root2->data)
		return treecmp(root1,root2);
	return is_son(root1->left,root2) || is_son(root1->right,root2);
}


3、将一棵有序二叉树转换为有序的双向链表

void __add_tail_list(TreeNode** head,TreeNode* node)//尾添加
{
	printf("%d\n", node->data);
	if(NULL == head)
	{
		*head = node;
	}
	else
	{
		(*head)->left->right = node;
		node->left=(*head)->left;
	}
			(*head)->left = node;
}
void _tree_to_list(TreeNode* root,TreeNode** head)
{
	if(NULL == root) return;
	_tree_to_list(root->left,head);
	__add_tail_list（head,node）'
	_tree_to_list(root->right,head);
}
//	有序二叉树转有序双向链表
TreeNode* tree_to_list(TreeNode* root)
{
	TreeNode* head = NULL;
	_tree_to_list(root,*head);
	head->left->right = head;
	return head;
}

4、计算出有序二叉树的第K大的值是多少
5、判断一棵二叉树是否对称的

bool _is_sym(TreeNode* root1,TreeNode* root2)
{
	if(root1->data != root2->data) return false;
	if(NULL == root1 && NULL !=root2) return flase;
	if(NULL != root1 && NULL == root2) return false;
	if(NULL == root1 && NULL == root2) return true;
	 
	int lflag = _is_sym(root1->left,root2->right);
	int rflag = _is_sym(root1->right,root2->left);
	return lflag && rflag;
}

6、请实现一个函数，该函数按照Z字型遍历打印二叉树，即第一行从左到右打印节点，第二行从右

在这里插入图片描述

void z_show(TreeNode* root)
{
	ListStack* s1 = create_list_stack();
	ListStack* s2 = create_list_stack();

	//	根入s1
	push_list_stack(s1,root);

	while(!empty_list_stack(s1) || !empty_list_stack(s2))
	{
		while(!empty_list_stack(s1))
		{
			TreeNode* node = top_list_stack(s1);
			pop_list_stack(s1);
			printf("%d ",node->data);
			if(node->left) 	push_list_stack(s2,node->left);
			if(node->right)	push_list_stack(s2,node->right);
		}
		while(!empty_list_stack(s2))
		{
			TreeNode* node = top_list_stack(s2);
			pop_list_stack(s2);
			printf("%d ",node->data);
			if(node->right) push_list_stack(s1,node->right);
			if(node->left) 	push_list_stack(s1,node->left);
		}
	}
}

线索二叉树：

规律：在有n个节点的链式二叉树中，必定存在n+1个空指针域

链式二叉树中有很多的空指针域，可以让这些右指针指向下一个节点，这样在遍历树时可以不用递归而是使用循环，可以提高树的遍历速度

中序线索二叉树节点数据项：
    数据
    左子树指针
    右子树指针
    右子树指针标志  (假表示指向的是右子树，真表示指向下一个节点)

实现过程：
    1、按照中序遍历过程创建线索
    2、按照线索来进行遍历(循环)

在这里插入图片描述

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

//	线索二叉树
typedef struct TreeNode
{
	int data;
	struct TreeNode* left;
	struct TreeNode* right;
	bool rclue;		//为真时右子树为线索
}TreeNode;

TreeNode* create_node(int data)
{
	TreeNode* node = malloc(sizeof(TreeNode));
	node->data = data;
	node->left = NULL;
	node->right = NULL;
	node->rclue = false;
	return node;
}

void _insert_tree(TreeNode** root,TreeNode* node)
{
	if(NULL == *root)
	{
		*root = node;
		return;
	}
	if(node->data < (*root)->data)
		_insert_tree(&(*root)->left,node);
	else
		_insert_tree(&(*root)->right,node);
}

void insert_tree(TreeNode** root,int data)
{
	_insert_tree(root,create_node(data));
}

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


//	上一个节点
TreeNode* prev = NULL;

//	按照中序遍历，并创建线索
void create_clue(TreeNode* root)
{
	if(NULL == root) return;//return跳出此时的create函数
	//	左
	create_clue(root->left);

	//	根
	//	通过中序遍历找到root的上一个节点prve，如果该节点存在，并且右子树为空，则右子树指向下一个节点root
	if(NULL != prev && NULL == prev->right)
	{
		prev->right = root;
		prev->rclue = true;
	}
	//	处理完后，root就成为了上一个节点
	prev = root;

	//	右
	create_clue(root->right);
}

//	按照线索进行遍历
void clue_show(TreeNode* root)
{
	while(root)
	{
		while(root->left)
			root = root->left;
		printf("%d ",root->data);
		while(root->rclue)
		{
			root = root->right;
			printf("%d ",root->data);
		}
		root = root->right;
	}
}

int main(int argc,const char* argv[])
{
	TreeNode* root = NULL;
	for(int i=0; i<10; i++)
	{
		int data = rand()%100;
		printf("%d ",data);
		insert_tree(&root,data);
	}
	printf("\n");
//	ldr_show(root);	按照递归遍历
	create_clue(root);
	clue_show(root);//按照循环遍历
}

选择树：(胜者树、败者树)

是一种完全二叉树，把所有要比较的数据放在最后一层，根节点是左右子树中的一个，是它们的最大或最小，选择树的功能是快速地找出其中的最大或者最小值

在这里插入图片描述

在这里插入图片描述

堆：

是一种完全二叉树，不适合链式存储
大顶堆(大根堆)：
    根节点比左右子树大
小顶堆(小根堆)：
    根节点比左右子树小

在这里插入图片描述

数据项：
    存储节点的内存的首地址
    容量
    数量
运算：
    创建、添加、删除、堆满、堆空、堆顶

堆可以实现优先队列的效果

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

#define swap(a,b) {typeof(a) (t)=(a);(a)=(b);(b)=(t);}//typeof(int*) a,b;等价于：   int *a,*b;
#define TYPE int 

typedef struct Heap
{
	TYPE* arr;
	size_t cal;
	size_t cnt;
}Heap;

//	创建
Heap* create_heap(size_t cal)
{
	Heap* heap = malloc(sizeof(Heap));
	heap->arr = malloc(sizeof(TYPE)*cal);
	heap->cal = cal;
	heap->cnt = 0;
	return heap;
}

//	空堆
bool empty_heap(Heap* heap)
{
	return !heap->cnt;	
}

//	满堆
bool full_heap(Heap* heap)
{
	return heap->cnt == heap->cal;
}

//	添加
bool add_heap(Heap* heap,TYPE data)//这里heap不要二级指针，这是顺序的，指针指向不会改变，顺序是定好的
{
	if(full_heap(heap))	return false;

	heap->arr[heap->cnt++] = data;

	//	调整成大顶堆
	//	编号
	int i = heap->cnt;
	while(i > 1)
	{
		if(heap->arr[i-1] > heap->arr[i/2-1])	
		{
			swap(heap->arr[i-1],heap->arr[i/2-1]);
		}
		i = i/2;
	}
	return true;
}

//	删除
bool del_heap(Heap* heap)
{
	if(empty_heap(heap)) return false;

	//	交换堆顶和末尾
	swap(heap->arr[0],heap->arr[heap->cnt-1]);
	//	删除末尾
	heap->cnt--;

	//	从上到下，调整成大顶堆
	int i = 1;
	while(i-1 < heap->cnt)
	{
		//	右子树存在，比较左右子树，左子树中放左右的最大值
		if(i*2 < heap->cnt && heap->arr[i*2] > heap->arr[i*2-1])
		{
			swap(heap->arr[i*2],heap->arr[i*2-1]);	
		}
		// 左子树存在，比较根与左子树，根放最大值
		if(i*2-1 < heap->cnt && heap->arr[i*2-1] > heap->arr[i-1])
		{
			swap(heap->arr[i*2-1],heap->arr[i-1]);	
			i = i*2;
		}
		else
		{
			break;
		}
	}
	return true;
}

//	堆顶
TYPE top_heap(Heap* heap)
{
	return heap->arr[0];
}

//	遍历
void show_heap(Heap* heap)
{
	for(int i=0; i<heap->cal; i++)
	{
		printf("%d ",heap->arr[i]);	
	}
	printf("\n");
}

//	堆排序
void sort_heap(int* arr,int len)
{
	//	把数组调整成堆结构
	for(int i=len; i>1; i--)
	{
		int j = i;
		while(1 < j)
		{
			if(arr[j-1] > arr[j/2-1])	swap(arr[j-1],arr[j/2-1]);
			j = j/2;
		}
	}
	//	删除堆顶，并从上到下调整，直到堆为空
	while(len > 1)
	{
		swap(arr[0],arr[len-1]);
		len--;

		int i = 1;
		while(i-1 < len)
		{
			if(i*2 < len && arr[i*2] > arr[i*2-1])
				swap(arr[i*2],arr[i*2-1]);
			if(i*2-1 < len && arr[i*2-1] > arr[i-1])
				swap(arr[i*2-1],arr[i-1]);
			i = i*2;
		}
	}

}


int main(int argc,const char* argv[])
{
	int arr[10] = {};
	for(int i=0; i<10; i++)
	{
		arr[i] = rand()%100;	
	}
	sort_heap(arr,10);

	for(int i=0; i<10; i++)
	{
		printf("%d ",arr[i]);	
	}
	/*
	Heap* heap = create_heap(10);
	for(int i=0; i<10; i++)
	{
		int data = rand()%100;
		add_heap(heap,data);
	}
	//show_heap(heap);
	for(int i=0; i<10; i++)
	{
		printf("top:%d\n",top_heap(heap));
		del_heap(heap);
	}
	*/
}

让下标与编号相等版

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

#define TYPE int
#define swap(a,b) {typeof(a) t=(a);(a)=(b);(b)=t;}

typedef struct Heap
{
	TYPE* arr;
	size_t cal;
	size_t cnt;
}Heap;

Heap* create_heap(size_t cal)
{
	Heap* heap = malloc(sizeof(Heap));
	//	第一个位置不使用，让下标与编号相等
	heap->arr = malloc(sizeof(TYPE)*(cal+1));
	heap->cal = cal;
	heap->cnt = 0;
	return heap;
}

//	销毁堆
void destory_heap(Heap* heap)
{
	free(heap->arr);
	free(heap);
}

//	堆空
bool empty_heap(Heap* heap)
{
	return !heap->cnt;	
}
//	堆满
bool full_heap(Heap* heap)
{
	return heap->cnt == heap->cal;	
}

//	添加
bool add_heap(Heap* heap,TYPE data)
{
	if(full_heap(heap)) return false;
	heap->arr[++heap->cnt] = data;

	//	从下到上调整
	int i = heap->cnt;
	while(i > 1)
	{
		if(heap->arr[i] > heap->arr[i/2])	
			swap(heap->arr[i],heap->arr[i/2]);
		i = i/2;
	}
	return true;
}

//	删除
bool del_heap(Heap* heap)
{
	if(empty_heap(heap)) return false;

	swap(heap->arr[1],heap->arr[heap->cnt]);
	heap->cnt--;

	//	从上到下调整
	int i = 1;
	while(i <= heap->cnt)
	{
		if(i*2+1 <= heap->cnt && heap->arr[i*2+1] > heap->arr[i*2])
			swap(heap->arr[i*2+1],heap->arr[i*2]);
		if(i*2 <= heap->cnt && heap->arr[i*2] > heap->arr[i])
			swap(heap->arr[i*2],heap->arr[i]);
		i = i*2;
	}
	return true;
}

//	遍历
void show_heap(Heap* heap)
{
	for(int i=1; i<=heap->cal; i++)
	{
		printf("%d ",heap->arr[i]);	
	}
	printf("\n");
}

int main(int argc,const char* argv[])
{
	Heap* heap = create_heap(10);
	for(int i=0; i<10; i++)
	{
		int	data = rand()%100;
		add_heap(heap,data);
	}
	do{
		show_heap(heap);
	}while(del_heap(heap));
}

在这里插入图片描述

平衡二叉树：

前提是有序的二叉树，它的左右子树高度相差不超过1，它所有的子树也要满足这个要求
如果一个有序的二叉树呈单支状(接近单支)，它的效率接近链表，查找、访问效率较低，因此当达到平衡时它的效率才最高
由于节点的位置受到值的影响，因此只能调整，而不能强行修改

二叉树不平衡的基础原因：
        x                                   y
       / \                                /   \
      y   t1     以y为轴向右旋转          z     x
     / \                                / \   / \
    z  t2                              t3 t4 t2 t1
   / \
  t3 t4

        x                                   y
       / \      以y为轴向左旋转            /   \   
      t1  y                              x     z
         / \                            / \   / \
        t2  z                          t1 t2 t3 t4
           / \
          t3  t4 

        x                  x                z
       / \                / \             /   \
      y   t1             z   t1          y     x
     / \                / \             / \   / \
    t2  z              y  t4           t2 t3 t4 t1
       / \            / \
      t3  t4         t2  t3
以z为轴向左旋转    以z为轴向右旋转       最终达到平衡

      x                 x                   z
     / \               / \                /   \
    t1  y             t1  z              x     y
       / \               / \            / \   / \
      z   t2            t3  y          t1 t3 t4 t2
     / \                   / \    
    t3 t4                 t4  t2
以z为轴向右旋转       以z为轴向左旋转   最终达到平衡

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

typedef struct TreeNode
{
	int data;
	struct TreeNode* left;
	struct TreeNode* right;
}TreeNode;

TreeNode* create_node(int data)
{
	TreeNode* node = malloc(sizeof(TreeNode));
	node->data = data;
	node->left = NULL;
	node->right = NULL;
	return node;
}

//	求高度
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 is_balance(TreeNode* root)
{
	return high_tree(root->left) - high_tree(root->right);	
}

//	左旋转
TreeNode* left_rotate(TreeNode* x)
{
	TreeNode* y = x->right;
	TreeNode* t2 = y->left;

	y->left = x;
	x->right = t2;

	return y;
}

//	右旋转
TreeNode* right_rotate(TreeNode* x)
{
	TreeNode* y = x->left;
	TreeNode* t2 = y->right;

	y->right = x;
	x->left = t2;

	return y;
}

//	自动平衡
TreeNode* auto_balance(TreeNode* x)
{
	if(NULL == x) return NULL;
	int lh = high_tree(x->left);
	int rh = high_tree(x->right);
	if(lh - rh >1)
	{
		//	左子树高
		//	y的左子树高于等于右子树
		if(is_balance(x->left) >= 0)
		{
			//	右旋转
			x = right_rotate(x);
		}
		else
		{
			//	左旋转
			x->left = left_rotate(x->left);
			//	右旋转
			x = right_rotate(x);
		}
	}

	if(rh - lh >1)
	{
		//	右子树高
		//	y的右子树高于等于左子树
		if(is_balance(x->right) <= 0)
		{
			//	左旋转	
			x = left_rotate(x);

		}
		else
		{
			//	右旋转
			x->right = right_rotate(x->right);
			//	左旋转
			x = left_rotate(x);
		}
	}

	return x;
}


//	插入
TreeNode* insert_tree(TreeNode* root,int data)
{
	if(NULL == root)
		return create_node(data);
	if(data < root->data)
		root->left = insert_tree(root->left,data);
	else
		root->right = insert_tree(root->right,data);
	
	//	调整成平衡
	root = auto_balance(root);
	return root;
}

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

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

/*
	删除节点
		1、待删除的节点是叶子节点，直接删除
		2、待删除的节点左或者右子树为空，则使用非空节点替换
		3、待删除的节点左右子树非空，根据左右子树的高度，选择左边的最大节点替换，或者右边的最小节点替换

*/

TreeNode* max_tree(TreeNode* root)
{
	TreeNode* max = root;
	while(max->right) max = max->right;
	return max;
}

TreeNode* min_tree(TreeNode* root)
{
	TreeNode* min = root;
	while(min->left) min = min->left;
	return min;
}

TreeNode* del_tree(TreeNode* root,int data)
{
	if(NULL == root) return NULL;
	if(root->data == data)
	{
		//	1、左右子树都为空
		if(NULL == root->left && NULL == root->right)
		{
			free(root);
			return NULL;
		}
		//	2、左子树为空,替换为右子树
		if(NULL == root->left)
		{
			TreeNode* temp = root->right;
			free(root);
			return temp;
		}
		//	3、右子树为空，替换为左子树
		if(NULL == root->right)
		{
			TreeNode* temp = root->left;
			free(root);
			return temp;
		}

		int lh = high_tree(root->left);
		int rh = high_tree(root->right);
		if(lh >= rh)
		{
			//	获取左子树最大节点
			TreeNode* node = max_tree(root->left);
			//	替换值
			root->data = node->data;
			//	删除node
			root->left = del_tree(root->left,root->data);
		}
		else
		{
			//	获取右子树最小节点
			TreeNode* node = min_tree(root->right);
			root->data = node->data;
			root->right = del_tree(root->right,root->data);
		}
		return root;
	}
	if(data < root->data)
		root->left = del_tree(root->left,data);
	else
		root->right = del_tree(root->right,data);
	//	调整平衡
	root = auto_balance(root);
	return root;
}


int main(int argc,const char* argv[])
{
	TreeNode* root = NULL;
	for(int i=0; i<10; i++)
	{
		int data = rand()%100;
		root = insert_tree(root,i);//需要用root接一下，因为这里调用的是一级指针，如果不接root不改变 
	}

	root = del_tree(root,2);
	root = del_tree(root,0);

	printf("high:%d\n",high_tree(root));
	ldr_show(root);
	printf("\n");
	dlr_show(root);
}

在这里插入图片描述

红黑树：

是一种自平衡的树，它的平衡不是根据子树的高度来调整的，而是给节点设置一个颜色，来达到平衡。
优点：插入和删除的效率，比AVL树要高
缺点：没有AVL树均匀，所以查找、访问效率没有AVL树高
规则：
1.节点是红色或黑色 
2.根节点是黑色。
3.每个叶子节点都是黑色的空节点（NIL节点）。
4 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)
5.从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。

在这里插入图片描述

明泊
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
06 数据结构与算法 树
zheng131511的博客
08-19 223
树
【数据结构】树和二叉树1——树
FishC的博客
10-24 135
【数据结构】树和二叉树1——树
王道数据结构5（树与二叉树）
沉晨尘宸的博客
08-12 644
特点：①每个结点至多只有两棵子树 ②左右子树不能颠倒（二叉树是有序树）二叉树(Binary tree )是n(n≥0)个结点的有限集合。若n=0时称为空树,否则:(1)有且只有一个特殊的称为树的根(Root)结点;(2)若n>1时，其余的结点被分成为二个互不相交的子集TTT1,TTT2,分别称之为左、右子树，并且左、右子树又都是二叉树。由此可知，二叉树的定义是递归的。特点：二叉树结构简单，存储效率高，树的操作算法相对简单，且任何树都很容易转化成二叉树。...............
关于二叉树的介绍
qq_44126789的博客
07-23 344
树是一种元素之间存在一对多关系的数据结构，常用于表示组织结构、辅助排序、查找等，一般以倒悬树的形式显示，根在上支在下。 树相关的术语： 根：树的最顶层的元素，有且仅有一个。 双亲：指的是上一层元素。 孩子：指的是下一层元素 度："孩子"的数量 深度：树的层数 密度：树的元素个数 结点：一个元素就是一个结点 普通树：孩子的数量无限制。 普通树的顺存储。 一、对结点的存储顺没有要求 0 A -1 1 ...
数据结构：树之定义与一些基本术语
JeansPocket的博客
08-01 936
数据结构之树
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 39万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
数据结构——树的遍历
不如打代码
05-02 3158
数据结构——树的遍历 1.树的基本概念 树是一种非常有用的数据结构，数据库的实现很多底层实现是基于树结构的，比如mysql innodb存储引擎的索引就是基于B+树的。树是一种由节点组成的数据结构，但它比链表更加高级，在链表中，一个节点连接着另一个节点，树也是由许多的节点构成的，唯一的区别就是一个树节点可以连接多个树节点，一颗树只有一个根节点，根节点作为起源，由它展开一个树状的数据结构。 在实现树之前，我们来了解一下树的基本定义： 在树中，每个节点都含有自己的数值，以及与之相连的子节点，连接节点的线叫做相连
C语言数据结构——树
01-10
C语言数据结构，树相关知识，整理了一段时间，差不多有个雏形，大家可以参考学习。
自定义数据结构——树 v1.1.zip
06-03
实现了一个自定义的数据结构 —— 树，该自定义结构不同于二叉树及其他数据结构，每个节点的子节点个数不受限制，最大限度保留了数据的原始结构，并实现了其前序和后序遍历的方法。优点是节省了内存，但缺点则是基于...
算法与数据结构教材四(数据结构——树).doc
06-08
算法与数据结构教材四(数据结构——树).doc
mysql事务(原理)
最新发布
m0_74347016的博客
05-19 519
mysql事务原理
数据库SQL编写规范-SQL书写规范整理（SQL语句书写规范全解-Word原件）
xx_123321456的博客
05-14 304
​​​​​​工作安排任务书，可行性分析报告，立项申请审批表，产品需求规格说明书，需求调研计划，用户需求调查单，用户需求说明书，概要设计说明书，技术解决方案，数据库设计说明书，详细设计说明书，单元测试报告，总体测试计划，单元测试计划，产品集成计划，集成测试报告，集成测试计划，系统测试报告，产品交接验收单，验收报告，验收测试报告，压力测试报告，项目总结报告，立项结项审批表，成本估算表，项目计划，项目周报月报，风险管理计划，质量保证措施，项目甘特图，项目管理工具，操作手册，接口设计文档，软件实施方案，运维方案，安
php centos选择sqlserver的驱动和扩展选择版本的说明
Z.X的博客
05-14 440
2023年2月23日13:41:48首先是php php扩展 驱动 数据库的关系 官方文档说明： https://learn.microsoft.com/zh-cn/sql/connect/php/step-1-configure-development-environment-for-php-development?view=sql-server-2017https://learn.microsoft.com/zh-cn/sql/connect/php/system-requirements-for-th
生产报表工具PI DataLInk 与 行列视之间的区别
2401_83701843的博客
05-17 247
行列视，全名“行列视生产数据应用系统”，行列视品牌所面对的业务范围远远超越了PIDatalink报表工具，他首先是一款本地部署的在线Excel文档管理系统，解决个人报表在线管理问题，其次，她和PIDataLInk一样，也是面向实时数据库报表需求的一套工具，其区别在于行列视品牌兼容国内外大多数实时数据库，也可以同时连接多个数据源，也就是她完全可以替代PI-DataLINk，同时也适用于其他品牌下的实时数据库系统；
MySQL存储过程添加二十万条数据日常练习
mi_mx的博客
05-17 304
【代码】MySQL日常练习。
linux中查找某个文件或文件夹
DN金猿的博客
05-18 238
locate命令将会在整个系统中搜索文件和文件夹，并通过正则表达式匹配以"/folder_name"结尾的路径。这将会在指定的路径（/path/to/search）中递归地列出所有文件和文件夹，并使用grep命令匹配以"/folder_name"结尾的行。该命令将会在指定的路径（/path/to/search）中查找名称为"folder_name"的文件夹。此方法与第2种方法类似，但使用了find命令来递归搜索文件夹，并使用grep命令来匹配以"/folder_name"结尾的行。
MongoDB聚合运算符：$zip
superatom01的博客
05-15 356
摘要：`$zip`用于将输入数组的元素重新组合转换为新的数组，重组转换的的规则是使用输入数组的第一个元素重组为第一个数组，使用第二个元素重组为第二个数组，以此类推。
怎么在KeilMDK里使用数据结构——树
05-16
在这个示例代码中，我们首先定义了一个树节点结构体，包含了节点数据和左右子节点指针。然后我们定义了创建节点和插入节点的函数，使用递归的方式实现。最后我们定义了计算树深度的函数，并在main函数中使用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值