数据结构—— 再探二叉树

已于 2024-08-21 12:04:54 修改
阅读量595 收藏 17
点赞数 12
分类专栏： 数据结构 文章标签： 数据结构
于 2024-08-21 12:03:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hedhjd/article/details/141328888
版权

1. TOP-K问题

TOP-K问题：求数据结合中前K个最大或者最小的数据

比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等

思路：

1. 用数据集合中前K个数据来建堆：
                                                            a.  前k个最大的数据，则建小堆
                                                            b.  前k个最小的数据，则建大堆

                                          一般推荐建小堆   

2. 用剩余的数据依次与堆顶的数据来比较，如果比堆顶的数据大就替换堆顶数据（覆盖位置，向下调整）

将剩余的数据依次与堆顶元素比完之后，堆中剩余的数据就是所求的前K个最小或最大的元素

通俗来讲就是：用前K个数建立一个小堆，然后剩下的数依次遍历和堆顶最小的数据比较，如果比堆顶的数据大,就把大的数赋给堆顶，再向下调整，最后堆里剩下的K个数就是最大的K个 ，因为小堆的堆顶一定是最小的数，只要随便拿个数比他大就交换他俩，大的那个数进入堆后再建小堆，大的数就沉在最下面，所以最后堆里面一定是K个最大的数

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
 
void AdjustDown(HPDataType* a, int size, int parent)
{
	int child = parent * 2 + 1;
	while (child < size) {
		if (child + 1 < size && a[child + 1] < a[child]) {
			child++;
		}
		if (a[child] < a[parent]) {
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 - 1;
		}
		else {
			break;
		}
	}
}	
 
 
void CreateNData()
{
	int n = 100000;
	srand(time(0));
	const char* file = "data.txt";
	FILE* fin = fopen(file, "w");
	if (fin == NULL)
	{
		perror("fopen error");
		return;
	}
	for (size_t i = 0; i < n; i++) {
		int x = rand() % 10000000;
		fprintf(fin, "%d\n", x);
	}
	fclose(fin);
}
 
void PrintTopK(int k)
{
	const char* file = "data.txt";
	FILE* fout = fopen(file, "r");
	if (fout == NULL)
	{
		perror("fopen error");
		return;
	}
	int* kminheap = (int*)malloc(sizeof(int) * k);
	if (kminheap == NULL)
	{
		perror("malloc error");
		return;
	}
 
	for (int i = 0; i < k; i++)
	{
		fscanf(fout, "%d", &kminheap[i]);
	}
	// 建小堆
	for (int i = (k - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(kminheap, k, i);
	}
 
	int val = 0;
	while (!feof(fout))
	{
		fscanf(fout, "%d", &val);
		if (val > kminheap[0])
		{
			kminheap[0] = val;
			AdjustDown(kminheap, k, 0);
		}
	}
 
	for (int i = 0; i < k; i++)
	{
		printf("%d ", kminheap[i]);
	}
	printf("\n");
	fclose(fout);
}
 
int main()
{
	CreateNData();
	PrintTopK(5);
	return 0;
}

2. 二叉树（BinaryTree）

2.1 介绍

前面我们的完全二叉树和满二叉树是使用数组来存储，如果不是完全二叉树和满二叉树就不适合使用数组存储，更适合链式结构来存储

二叉树是：

                1. 空树

                2. 非空：根结点，根结点的左子树、根结点的右子树组成的

                3.二叉树是递归结构

二叉树是整棵树拆分为根和子树，然后拆分过的子树再作为根继续拆分 ，一直这样持续至最后一个没有子树的根

在遍历之前先手搓一个二叉树的基础模板（Creat Binary Tree）：

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
#include<stdbool.h>


typedef int BTDataType;
typedef struct BinaryTreeNode
{
	BTDataType val;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;

BTNode* BuyNode(int x)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		return NULL;
	}

	node->val = x;
	node->left = NULL;
	node->right = NULL;

	return node;
}

BTNode* CreatBinaryTree()
{
	BTNode* node1 = BuyNode(1);
	BTNode* node2 = BuyNode(2);
	BTNode* node3 = BuyNode(3);
	BTNode* node4 = BuyNode(4);
	BTNode* node5 = BuyNode(5);
	BTNode* node6 = BuyNode(6);

	//node1的左和右指向node2和node4
	node1->left = node2;
	node1->right = node4;

	//node1的左指向node3
	node2->left = node3;

	//node4的左和右指向node5和node6
	node4->left = node5;
	node4->right = node6;

	return node1;
}



int main()
{
	//root:根   CreatBinaryTree：创建二叉树
	BTNode* root = CreatBinaryTree();

	return 0;
}

2.2 二叉树的遍历

前序遍历 （Prer Order）   

访问顺序：（根  左子树 右子树  )任何一棵树的访问，都要符合前序，被拆成根   左子树  右子树

访问顺序为：

 

//前序
void PrerOrder(BTNode* root)
{
	//如果根为空
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	else
	{
        //打印根的数
		printf("%d\n", root->val);
        //打印完之后访问根的左子树和右子树
		PrerOrder(root->left);
		PrerOrder(root->right);
	}
}

                        代码执行完成之后就进行递归调用，一直到遇到空根结束

int main()
{
	//root:根   CreatBinaryTree：创建二叉树
	BTNode* root = CreatBinaryTree();
	PrerOrder(root);
	printf("\n");
	return 0;
}

中序遍历（In Order）

访问顺序：（左子树   根  右子树 ）任何一棵树的访问，都要符合中序，被拆成左子树   根  右子树

访问顺序为：


//中序
void InOrder(BTNode* root)
{
	//如果根为空
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	else
	{
		//先访问左子树
		InOrder(root->left);
		//打印根的数
		printf("%d\n", root->val);
		//打印完之后访问根的右子树
		InOrder(root->right);
	}
}

int main()
{
	//root:根   CreatBinaryTree：创建二叉树
	BTNode* root = CreatBinaryTree();
	
	//中序
	//InOrder(root);

	printf("\n");
	return 0;
}

后序遍历（Post Order）

访问顺序：（左子树  右子树   根）任何一棵树的访问，都要符合后序，被拆成左子树  右子树   根

访问顺序为： 

//后序
void PostOrder(BTNode* root)
{
	//如果根为空
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	else
	{
		//先访问左子树和右子树
		PostOrder(root->left);			
		PostOrder(root->right);
		//再打印根的数
		printf("%d\n", root->val);
	}
}

int main()
{
	//root:根   CreatBinaryTree：创建二叉树
	BTNode* root = CreatBinaryTree();
	//前序
	//PrerOrder(root);
	//中序
	//InOrder(root);
	//后序
	PostOrder(root);
	printf("\n");
	return 0;
}

求二叉树节点的个数 （Tree Size）：

节点个数：

                1.如果为空，则为0

                2.如果不为空，则是左子树 + 右子树 + 1

//求整棵树节点的个数
int TreeSize(BTNode* root)
{
	//如果为空则返回0，不为空则返回左子树加右子树加1
	return root == NULL ? 0 :TreeSize(root->left) + TreeSize(root->right) + 1;
}

int main()
{
	//root:根   CreatBinaryTree：创建二叉树
	BTNode* root = CreatBinaryTree();
	//前序
	//PrerOrder(root);
	//中序
	//InOrder(root);
	//后序
	//PostOrder(root);
	//printf("\n");
    
    //求整棵树节点的个数
	printf("TreeSize:%d\n", TreeSize(root));
	
	return 0;
}

获取叶子节点个数（Tree Leaf Size）：

叶子：就是度为0，不包括任何子节点，通俗来讲就是没有孩子的节点

//获取叶子节点个数
int TreeLeafSize(BTNode* root)
{
	if (root == NULL)
		return 0;

	if (root->left == NULL && root->right == NULL)
		return 1;

	return TreeLeafSize(root->left)
		+ TreeLeafSize(root->right);
}
int main()
{
	//root:根   CreatBinaryTree：创建二叉树
	BTNode* root = CreatBinaryTree();
	//前序
	//PrerOrder(root);
	//中序
	//InOrder(root);
	//后序
	//PostOrder(root);
	//printf("\n");
    //求整棵树节点的个数
	//printf("TreeSize:%d\n", TreeSize(root));

    //获取叶子节点个数
	printf("TreeLeafSize:%d\n", TreeLeafSize(root));
	
	return 0;
}

二叉树的高度 （Tree Height）：

                        二叉树的高度是有几层高度就是几

//二叉树的高度
int TreeHeight(BTNode* root)
{
	if (root == NULL)
		return 0;
	//使用两个变量记录下来，避免重复计算
	int leftHeight = TreeHeight(root->left);
	int rightHeight = TreeHeight(root->right);

	return leftHeight > rightHeight ?
		leftHeight + 1 : rightHeight + 1;
}

int main()
{
	//root:根   CreatBinaryTree：创建二叉树
	BTNode* root = CreatBinaryTree();
	//前序
	//PrerOrder(root);
	//中序
	//InOrder(root);
	//后序
	//PostOrder(root);
	//printf("\n");
	 //求整棵树节点的个数
	//printf("TreeSize:%d\n", TreeSize(root));

    //获取叶子节点个数
	//printf("TreeLeafSize:%d\n", TreeLeafSize(root));

    //二叉树的高度
	printf("TreeHeight:%d\n", TreeHeight(root));

	return 0;
}

 二叉树第k层结点个数：

// 二叉树第k层节点个数
int TreeLevelKSize(BTNode* root, int k)
{
	if (root == NULL)
		return 0;

	if (k == 1)
		return 1;

	// 子问题
	return TreeLevelKSize(root->left, k - 1)
		+ TreeLevelKSize(root->right, k - 1);
}

二叉树查找值为x的结点：

// 二叉树查找值为x的节点
BTNode* TreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)
		return NULL;

	if (root->val == x)
		return root;

	BTNode* ret1 = TreeFind(root->left, x);
    //如果找到了直接返回数值，没有找到直接返回空
	if (ret1)
		return ret1;

	BTNode* ret2 = TreeFind(root->right, x);
    //如果找到了直接返回数值，没有找到直接返回空
	if (ret2)
		return ret2;

	return NULL;
}

                                                            休息一下，马上回来~                                                            

迷迭所归处
关注
  • 12
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
正弦定理的博客
12-09 35万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
数据结构—— 树与二叉树
m0_63105539的博客
03-26 1270
一、树的定义与基本术语 1、树的基本概念 树是n（n大于等于0）个结点的有限集合。n=0时，称为空树。 2、树的相关术语 （1）结点：包含一个数据元素及若干指向其他结点的分支信息。 （2）结点的度：一个结点的子树个数称为此结点的度。 （3）叶结点：度为0的结点，即无后继的结点，也称为终端结点。 （4）分支结点：度不为0的结点，也称非终端结点。 （5）结点的层次：从根结点开始定义，根结点的层次为1，根的直接后继结点为2，以此类推。 （6）树的度：树中所有节点的度的最大值。 （7）树的深度：
数据结构——树与二叉树
yue152152的博客
04-10 2940
从树到二叉树的概念及结构，文末附上了二叉树顺序结构和链式结构实现的入口
【数据结构】——二叉树详解
atwdy的博客
07-28 5万+
二叉树(Binary Tree)是由n个结点构成的有限集(n≥0)，n=0时为空树，n>0时为非空树。对于非空树TTT有且仅有一个根结点；除根结点外的其余结点又可分为两个不相交的子集TLT_LTL​和TRT_RTR​，分别称为TTT的左子树和右子树，且TLT_LTL​和TRT_RTR​本身又都是二叉树。很明显该定义属于递归定义，所以有关二叉树的操作使用递归往往更容易理解和实现。从定义也可以看出二叉树与一般树的区别主要是两点，一是每个结点的度最多为2；
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 41万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
数据结构——树和二叉树
x3185531971的博客
05-05 1121
介绍了树和二叉树的基本术语
数据结构——树，二叉树详解
Lucky_mzc的博客
03-05 1602
一. 树 1.1 树的定义 树是n个结点的有限集合，有且仅有一个根结点，其余结点可分为m个根结点的子树。 1.2 树的概念 树（tree）是包含 n(n≥0)个结点，当 n=0 时，称为空树，非空树中条边的有穷集，在非空树中：（1）每个元素称为结点（node）。 （2）有一个特定的结点被称为根结点或树根（root）。 结点的度: 一个结点拥有子树的个数称为度。比如A的度为3，B的度为2，C的度为0。度为0的结点称为叶子结点（C,E,G,H,I）。树的度是树中所有结点的度的最大值，此树..
【数据结构——树和二叉树】
weixin_64993156的博客
03-13 170
树是一种递归定义的数据结构有序树——逻辑上看，树中结点的各子树从左至右是有次序的，不能互换无序树——逻辑上看，树中结点的各子树从左至右是无次序的。可以互换有次序还是无次序是具体看你用树来存什么，是否需要用结点的左右位置来反映某些逻辑关系森林：森林是m(m>=0)棵互不相交的树的集合二叉树的顺序结构，只适合存储完全二叉树完全二叉树的常考性质二叉树的存储方式。
数据结构——树——二叉树图解动画
06-04 2066
文章目录二叉树简介二叉树遍历前序遍历中序遍历后序遍历层序遍历二叉树操作二叉树插入节点二叉树删除节点 二叉树简介 在计算机科学中，二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 一棵深度为k，且有2^k-1个结点的二叉树，称为满二叉树。这种树的特点是每一层上的结点数都是最大结点数。而在一棵二叉树中，除最后一层外，若其余层都是满的，并且或者最后一层是满的，或者是在右边缺少连续若干结点，
C++数据结构——中序遍历二叉树
weixin_44546342的博客
05-13 2637
中序遍历二叉树 按完全二叉树的层次遍历给出一棵二叉树的遍历序列（其中用0表示虚结点），要求输出该二叉树的深度及中序遍历该二叉树得到的序列。 输入格式: 首先输入一个整数T，表示测试数据的组数，然后是T组测试数据。每组测试数据首先输入一个正整数n（n≤1000），代表给出的二叉树的结点总数（当然，其中可能包含虚结点）。结点编号均为正整数,且各不相同。 然后输入n个正整数，表示按完全二叉树（即第1层1个结点，第2层2个，第3层4个，第4层有8个……）的层次遍历给出的二叉树遍历序列，如果某个结点不存在（虚结
广工数据结构实验——平衡二叉树
07-06
本实验“广工数据结构实验——平衡二叉树”着重探讨了一种特殊类型的数据结构，即平衡二叉树。平衡二叉树是二叉搜索树（Binary Search Tree, BST）的一个变体，它通过保持树的高度平衡来确保查找、插入和删除操作的...
数据结构——二叉树
02-06
该文件包括二叉树的头文件（BitTree开头）和堆栈的头文件（Seq开头），另外还实现了编写按层次顺序（同一层自左至右）遍历二叉树的算法、后序递归遍历计算二叉树的深度的算法、判断给定二叉树是否为完全二叉树（通过...
数据结构——二叉树 线索化二叉树 C语言
03-16
中序线索二叉树，反方向进行中序遍历(要求非递归，顺前驱进行)。 （1）建立二叉树； (2) 按先序、中序、后序输出二叉树; （3）复制二叉树； （4）在字符模式下画出无缺陷的二叉树
数据结构——二叉树的实现.zip
09-18
这个压缩包文件"数据结构——二叉树的实现.zip"显然包含了关于二叉树实现的详细内容，特别是二叉链表和左子右兄弟两种不同的实现方法。 首先，我们来探讨二叉链表的实现。二叉链表是最基础的二叉树存储方式，每个...
数据结构——二叉树的生成与遍历
02-18
数据结构，实现二叉树的生成与遍历的算法。包含利用先序、中序、后序遍历二叉树算法，二叉树基本操作。（注意没有左子树或右子树时用@或#作为结束符号）
数据结构之---堆（2）
2301_81684056的博客
08-15 633
出堆是指将堆顶数据出堆。出堆完成后要保证剩余数据还是满足原来堆的性质。所以我们把堆顶数据和堆底最后一个数据交换，取出新堆底数据，之后通过向下调整算法将剩下的数据重新排列成一个堆。大堆经过出堆操作得出的数据是升序的小堆经过出堆操作得出的数据是降序的。
深入理解MySQL索引：原理、数据结构与优化策略
乙壳虫的博客
08-16 907
索引类似于一本书的目录，它可以帮助我们快速定位到需要的内容。没有索引时，MySQL 需要遍历整个表来找到目标记录，而索引通过构建特定的结构，可以加速查找的过程。索引的主要作用是提高数据库查询效率，减少数据库检索的行数，从而提升查询速度。B-Tree 索引：这是 MySQL 中最常见的索引结构，适用于大多数场景。B-Tree 是平衡树的一种，能够保持数据有序，从而加快查找速度。哈希索引（Hash Index）：通过将键映射为固定大小的哈希值来加速查找，适用于精确查找。
数据结构之树的存储结构
最新发布
DKPT的博客
08-16 567
孩子链表表示法将树中所有节点存储在一个顺序表中，每个数据元素有两个域：数据域和存放该节点第一个孩子地址的指针域。同时，为树中每个节点构建一个单链表，链表中的节点也有两个域：存放该孩子节点在顺序表中的数组下标和指向下一个孩子的指针。对于完全二叉树，如果父节点的索引是i（假设从0开始计数），那么它的左子节点的索引是2i+1，右子节点的索引是2i+2。数组的第一个元素存储树的根节点。双亲表示法通过采用一维数组来存储树中的节点，其中每个节点被赋予一个结构体类型，包含数据域和父节点位置域（parent域）。
数据结构——时间复杂度和空间复杂度
2301_80373479的博客
08-15 919
带你了解时间复杂度和空间复杂度
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值