[数据结构]二叉树之堆的实现

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

🥁作者： 华丞臧.
📕​​​​专栏：【数据结构】
各位读者老爷如果觉得博主写的不错，请诸位多多支持(点赞+收藏+关注)。如果有错误的地方，欢迎在评论区指出。
推荐一款刷题网站 👉 LeetCode刷题网站

文章目录

一、堆

普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。

1.1 堆的概念及结构

如果有一个关键码的集合K = { k0，k1 ，k2 ，…，kn-1 }，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki <=K2i+1 且Ki <=K2i+2 ( Ki >=K2i+1 且Ki >=K2i+2 ) i = 0，1，2…，则称为小堆(或大堆)。

  • 最大堆或大根堆:根节点最大的堆。
  • 最小堆或小根堆:根节点最小的堆。

堆的性质：

  1. 堆中某个节点的值总是不大于或不小于其父节点的值；
  2. 堆总是一棵完全二叉树。

在这里插入图片描述

二、堆的实现

2.1 堆的接口

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>


typedef int HPDataType;

typedef struct Heap
{
	HPDataType* data;
	int size;
	int capacity;
}HP;


//初始化堆
void HeapInit(HP* php);

//堆销毁
void HeapDestroy(HP* php);

//堆插入
void HeapPush(HP* php, HPDataType x);

//堆删除
void HeapPop(HP* php);

//打印
void HeapPrint(HP* hp);

//取堆顶元素
HPDataType HeapTop(HP* hp);

//堆的数据个数
int HeapSize(HP* hp);

//判空
bool HeapEmpty(HP* hp);

🚀初始化堆

初始化堆。

//初始化堆
void HeapInit(HP* php)
{
	assert(php);

	php->data = NULL;
	php->size = php->capacity = 0;
}

🚀销毁堆

//堆销毁
void HeapDestroy(HP* php)
{
	assert(php);

	free(php->data);

	php->data = NULL;
	php->size = php->capacity = 0;
}

🚀堆插入

先将元素插入到堆的尾部，如果插入之后堆的性质遭到破坏，将新插入的元素顺着其双亲往上调整到合适的位置上即可。

//交换
void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//向上调整
void AdjustUp(HPDataType* a, int child)
{
	assert(a);

	int parent = (child - 1) / 2;

	while (parent >= 0)
	{
		if (a[parent] > a[child])
		{
			/*HPDataType tmp = a[parent];
			a[parent] = a[child];
			a[child] = tmp;*/
			Swap(&a[parent], &a[child]);

			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}


//堆插入
void HeapPush(HP* php, HPDataType x)
{
	assert(php);

	//检查是否需要扩容
	if (php->size == php->capacity)
	{
		int newCapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
		HPDataType* tmp = (HPDataType*)realloc(php->data,sizeof(HPDataType) * newCapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}

		php->data = tmp;
		php->capacity = newCapacity;
	}

	php->data[php->size] = x;
	++php->size;

	//向上调整
	AdjustUp(php->data,php->size - 1);
}

🚀堆删除

删除堆是删除堆顶的数据，将堆顶的数据和最后一个数据交换，然后删除数据最后一个数据即size 减一，再进行向下调整，把堆顶元素向下调整到满足堆的特性即可。

//向下调整
void AdjustDown(HPDataType* a, int size)
{
	assert(a);

	int parent = 0;
	int minchild = parent * 2 + 1;
	

	while (parent < size && minchild < size)
	{
		if (minchild < size && a[minchild] > a[minchild + 1])
		{
			minchild += 1;
		}

		if (a[minchild] < a[parent])
		{
			/*HPDataType tmp = a[parent];
			a[parent] = a[minchild];
			a[minchild] = tmp;*/
			Swap(&a[parent], &a[minchild]);

			parent = minchild;
			minchild = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

//堆删除
void HeapPop(HP* php)
{
	assert(php);
	assert(!HeapEmpty(php));

	HPDataType tmp = php->data[0];
	php->data[0] = php->data[php->size - 1];
	php->data[php->size - 1] = tmp;
	--php->size;

	//向下调整
	AdjustDown(php->data, php->size);
}

🚀取堆定元素

堆顶也就是数组下标为 0 的位置。

//取堆顶元素
HPDataType HeapTop(HP* php)
{
	assert(php);

	return php->data[0];
}

🚀堆的数据个数

size 表示堆的有效数据的个数。

//堆的数据个数
int HeapSize(HP* php)
{
	assert(php);

	return php->size;
}

🚀堆判空

当 size 等于 0 时，堆为空。

//判空
bool HeapEmpty(HP* php)
{
	assert(php);

	return php->size == 0;
}

🚀打印

//打印
void HeapPrint(HP* php)
{
	int i = 0;

	while (i < php->size)
	{
		printf("%d ", php->data[i]);
		i++;
	}
	printf("\n");
}

三、堆的应用

3.1 堆排序

堆排序即利用堆的思想来进行排序，分为两个步骤：

  1. 建堆

直接插入建堆：

  • 升序：建大堆
  • 降序：建小堆
  1. 利用堆删除思想来进行排序

用向下调整算法来进行排序，依次选数，从后往前排。

3.1.1 建堆的方式

🚀向下调整建堆

在这里插入图片描述
调整次数 = 每一层节点数 * 这一层节点最坏调整次数

T(N) = 20 *(h-1)+21 *(h-2)+22 *(h-3)+……+2(h-3) *2+2(h-2) *1 ----(1)

2 * T(N) = 21 *(h-1)+22 *(h-2)+23 *(h-3)+……+2(h-2) *2+2(h-1)*1 ----(2)
上面两式(1)-(2)相减可得： T(N) = 20 +21 +22 +……+2(h-3) +2(h-2) +2(h-1) -h = 2h-1-h
高度为h,节点数量为N的完全二叉树：

  • N = 2h-1
  • h = log2(N+1)

所以T(N) = N-log2(N+1) ≈ N
因此：建堆的时间复杂度为O(N)。

🚀向上调整建堆

在这里插入图片描述
调整次数 = 每一层节点数 * 这一层节点最坏调整次数

T(N) = 20 *1+21 *2+22 *3+……+2(h-2) *(h-2)+2(h-1) *(h-1) ----(1)
2 * T(N) = 21 *1+22 *2+23 *3+……+2(h-1) *(h-2)+2h *(h-1) ----(2)
上面两式(1)-(2)相减可得： T(N) = 21 *1+22 *2+23 *3+……+2(h-1) +2h *(h-1) - 20
高度为h,节点数量为N的完全二叉树：

  • N = 2h-1
  • h = log2(N+1)

所以T(N) = 2(h-1)+2h * (h-1) -2 ≈ 2h * h
因此：建堆的时间复杂度为O(N*log2N)

对比两个建堆方式，向下调整建堆更好，其时间复杂度较小。

3.1.2 堆排序实现

堆排序的大思路是选数排序，依次选数，从后往前排。堆的最后是叶子节点，叶子结点单独可以看做一个堆不用进行向下调整，所以从堆的倒数第一个非叶子节点开始调整，一直调整到根；而最后一个非叶子节点也就是最后一个父亲节点，就是最后节点非父节点。

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

void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//向下调整
void AdjustDown(int* a, int size,int parent)
{
	assert(a);

	int minchild = parent * 2 + 1;


	while ( minchild < size)
	{
		if (minchild + 1 < size && a[minchild] > a[minchild + 1])
		{
			minchild += 1;
		}

		if (a[minchild] < a[parent])
		{
			Swap(&a[parent], &a[minchild]);

			parent = minchild;
			minchild = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void HeapSort(int* a, int n)
{
	//向下调整建堆 -- O(N)
	for (int i = (n-2) / 2; i >= 0; --i)
	{
		AdjustDown(a, n,i);
	}

	//选数
	int i = 1;
	while (i < n)
	{
		Swap(&a[0],&a[n - i]);
		AdjustDown(a,n - i,0);
		++i;
	}
}


int main()
{
	int a[] = { 1,5,3,8,7,6 };
	HeapSort(a,sizeof(a)/sizeof(a[0]));

	for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
	{
		printf("%d ",a[i]);
	}
	return 0;
}

3.2 TOP-K问题

TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。
比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。
对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决，基本思路如下：

  1. 用数据集合中前K个元素来建堆
    • 前k个最大的元素，则建小堆
    • 前k个最小的元素，则建大堆
  2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素

3.2.1 代码实现

🚀数据量不大

当数据量不大的时候，可以直接把数据存放在内存当中进行选 TOP-K 的操作。

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


void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//向下调整
void AdjustDown(int* a, int size,int parent)
{
	assert(a);

	int minchild = parent * 2 + 1;


	while ( minchild < size)
	{
		if (minchild + 1 < size && a[minchild] > a[minchild + 1])
		{
			minchild += 1;
		}

		if (a[minchild] < a[parent])
		{
			Swap(&a[parent], &a[minchild]);

			parent = minchild;
			minchild = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void HeapSort(int* a, int n)
{
	//向下调整建堆 -- O(N)
	for (int i = (n-2) / 2; i >= 0; --i)
	{
		AdjustDown(a, n,i);
	}

	//选数
	int i = 1;
	while (i < n)
	{
		Swap(&a[0],&a[n - i]);
		AdjustDown(a,n - i,0);
		++i;
	}
}


void PrintTopK(int* a, int n, int k)
{
	// 1. 建堆--用a中前k个元素建堆
	for (int i = (k - 2) / 2; i > 0; --i)
	{
		AdjustDown(a,k,i);
	}

	// 2. 将剩余n-k个元素依次与堆顶元素交换，不满则则替换
	int i = k;
	while (i < n)
	{
		if (a[0] < a[i])
		{
			Swap(&a[0], &a[i]);
			AdjustDown(a,k,0);
		}
		i++;
	}

	HeapSort(a, k);

	for (i = 0; i < k; i++)
	{
		printf("%d ",a[i]);
	}
}

void TestTopk()
{
	int n = 10000;
	int* a = (int*)malloc(sizeof(int) * n);
	if (a == NULL)
	{
		perror("malloc fail");
		return;
	}
	srand(time(0));
	for (size_t i = 0; i < (size_t)n; ++i)
	{
		a[i] = rand() % 1000000;
	}
	a[5] = 1000000 + 1;
	a[1231] = 1000000 + 2;
	a[531] = 1000000 + 3;
	a[5121] = 1000000 + 4;
	a[115] = 1000000 + 5;
	a[2335] = 1000000 + 6;
	a[9999] = 1000000 + 7;
	a[76] = 1000000 + 8;
	a[423] = 1000000 + 9;
	a[3144] = 1000000 + 10;

	/*int a[] = { 4,1,5,3,6,8,9,7,0,2 };
	int n = sizeof(a) / sizeof(a[0]);*/
	PrintTopK(a, n, 10);
}

int main()
{
	TestTopk();
	return 0;
}

代码运行结果：
在这里插入图片描述

🚀数据量很大

对于数据量非常大时，内存存放不下，数据存放在本地文件中；这时就需要我们从文件中依次读取数据，然后再比较并且保留前 K 个最大(最小)的元素。
同样的：

  • 前k个最大的元素，则建小堆
  • 前k个最小的元素，则建大堆
void PrintTopK(const char* filename, int k)
{
	assert(filename);

	//filename存放数据的文件名
	FILE* fout = fopen(filename, "r");
	if (fout == NULL)
	{
		perror("fopen fail");
		exit(-1);
	}

	int* minHeap = (int*)malloc(sizeof(int)*k);
	if (minHeap == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	// 读取前K个数据
	for (int i = 0; i < k; ++i)
	{
		fscanf(fout, "%d", &minHeap[i]);
	}

	//向下调整建堆
	for (int i = (k - 2) / 2; i >= 0; --i)
	{
		AdjustDown(minHeap,k,i);
	}

	//选前TOP-K个
	int val = 0;
	while (fscanf(fout,"%d",&val) != EOF)
	{
		if (minHeap[0] < val)
		{
			minHeap[0] = val;
			AdjustDown(minHeap,k,0);
		}
	}

	for (int i = 0; i < k; ++i)
	{
		printf("%d ", minHeap[i]);
	}

	free(minHeap);
	fclose(fout);
}

四、堆完整代码

4.1 heap.h

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>


typedef int HPDataType;

typedef struct Heap
{
	HPDataType* data;
	int size;
	int capacity;
}HP;


//初始化堆
void HeapInit(HP* php);

//堆销毁
void HeapDestroy(HP* php);

//堆插入
void HeapPush(HP* php, HPDataType x);

//堆删除
void HeapPop(HP* php);

//打印
void HeapPrint(HP* php);

//取堆顶元素
HPDataType HeapTop(HP* php);

//堆的数据个数
int HeapSize(HP* php);

//判空
bool HeapEmpty(HP* php);

4.2 heap.c

#include "heap.h"


//初始化堆
void HeapInit(HP* php)
{
	assert(php);

	php->data = NULL;
	php->size = php->capacity = 0;
}

//堆销毁
void HeapDestroy(HP* php)
{
	assert(php);

	free(php->data);

	php->data = NULL;
	php->size = php->capacity = 0;
}

void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//向上调整
void AdjustUp(HPDataType* a, int child)
{
	assert(a);

	int parent = (child - 1) / 2;

	while (child > 0)
	{
		if (a[parent] > a[child])
		{
			Swap(&a[parent], &a[child]);

			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}


//堆插入
void HeapPush(HP* php, HPDataType x)
{
	assert(php);

	//检查是否需要扩容
	if (php->size == php->capacity)
	{
		int newCapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
		HPDataType* tmp = (HPDataType*)realloc(php->data,sizeof(HPDataType) * newCapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}

		php->data = tmp;
		php->capacity = newCapacity;
	}

	php->data[php->size] = x;
	++php->size;

	//向上调整
	AdjustUp(php->data,php->size - 1);
}

//打印
void HeapPrint(HP* php)
{
	int i = 0;

	while (i < php->size)
	{
		printf("%d ", php->data[i]);
		i++;
	}
	printf("\n");
}

//向下调整
void AdjustDown(HPDataType* a, int size, int parent)
{
	assert(a);

	int minchild = parent * 2 + 1;


	while (minchild < size)
	{
		if (minchild + 1 < size && a[minchild] > a[minchild + 1])
		{
			minchild++;
		}

		if (a[minchild] < a[parent])
		{
			Swap(&a[parent], &a[minchild]);

			parent = minchild;
			minchild = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

//堆删除
void HeapPop(HP* php)
{
	assert(php);
	assert(!HeapEmpty(php));

	Swap(&php->data[0], &php->data[php->size - 1]);
	--php->size;

	//向下调整
	AdjustDown(php->data, php->size,0);
}

//取堆顶元素
HPDataType HeapTop(HP* php)
{
	assert(php);

	return php->data[0];
}

//堆的数据个数
int HeapSize(HP* php)
{
	assert(php);

	return php->size;
}

//判空
bool HeapEmpty(HP* php)
{
	assert(php);

	return php->size == 0;
}
华丞臧.
关注
  • 20
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 15
    评论
专栏目录
完全二叉树，堆操作c语言实现
04-10
内容概要：堆的常用操作，包括创建、销毁、添加、插入、删除、空堆、满堆、堆顶 阅读建议：推荐有一定的数据结构基础，对于c语言敏感性高，对指针学习感兴趣
数据结构二叉树实验头文件
12-10
二叉树常被用于实现二叉查找树和二叉堆。 一棵深度为k，且有2^k-1个结点的二叉树，称为满二叉树。这种树的特点是每一层上的结点数都是最大结点数。而在一棵二叉树中，除最后一层外，若其余层都是满的，并且或者...
【数据结构】二叉树之堆
阿琪
02-27 3416
本篇章主要对堆的创建、插入、删除、排序进行详细图解，以例题方式进行绘制。
C语言【数据结构】二叉树实现
冰果滴的博客
06-16 1183
目录一.二叉树逐步实现1.创建结构体2.创建二叉树3.二叉树前序遍历4.二叉树中序遍历5.二叉树后序遍历6.二叉树层序遍历7.二叉树节点个数8.二叉树叶子节点个数9.二叉树第k层节点个数10.二叉树最大深度11.二叉树查找值为x的节点12.判断二叉树是否为完全二叉树13.二叉树销毁二.代码1.BinaryTree.h2.BinaryTree.c3.Test.c4.Queue.h5.Queue.c三.测试结果前言：二叉树的最后一篇，实现二叉树（才发现前面竟然忘记写了😢） 发现了就赶紧补上.
数据结构——二叉树（堆的实现）
weixin_49449676的博客
08-08 725
树和二叉树介绍，堆的实现
【数据结构】二叉树（C语言实现）
在平淡的日子里寻找存在的价值
08-15 6153
树和二叉树的基本介绍，以及基于C语言的链式二叉树的实现。
【数据结构】二叉树 & 堆 & 堆的实现
weixin_47132900的博客
09-05 1399
一，树概念及结构 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 特点： ·有一个特殊的结点，称为根结点，根节点没有前驱结点。 ·除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i<= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继，因此，树是递归定义的。 二，二叉树概
C语言【数据结构】二叉树实现堆及堆排序
冰果滴的博客
04-15 1887
前言：这一篇先用完全二叉树来实现堆及堆排序，下一篇将会把整个初阶的二叉树完结。 一.二叉树的顺序结构及堆的概念 1.二叉树的顺序结构 普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。 2.堆的概念及结构 （1）堆的概念 如果有一个集合K = { k0，k1 ，k2.
数据结构算法之二叉树遍历
weixin_43665612的博客
04-15 1689
二叉树 二叉树是每个结点最多有两个子树的树形结构 通常称为 左子树(left subtree)和右子树(right subtree) 二叉树 通常被称为二叉查找树或二叉堆 一、二叉树遍历是什么？ 二叉树的遍历是指从根结点出发，按照某种次序依次访问二叉树中所有结点，使得每个结点被访问一次且仅被访问一次。 二、为什么研究二叉树的遍历？ 因为计算机只会处理线性序列，而我们研究遍历，就是把树中的结点变成某种意义的线性序列，这给程序的实现带来了好处。 三、二叉树的创建 遍历二叉树之前，首先我们要有一个二叉树。要创建
数据结构之二叉树
cls的博客
03-22 2668
顺序存储： 顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。而现实中使用中只有堆才会使用数组来存储，关于堆之前已经讲解过。二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。 链式存储 二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表 中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结 点的存储地址 。链式结构又分为二叉链和三叉链，当前我..
＜ 数据结构 ＞ 堆的实现
bit_zyx的博客
04-13 2028
目录 1、前言 堆的概念 堆的结构 2、堆的实现 2.1、准备工作 创建堆结构 初始化堆 堆的打印 堆的销毁 建堆时间复杂度 2.2、堆调整 堆的交换 堆向上调整算法 堆向下调整算法 2.3、核心功能 堆的插入 堆的删除 ...
【数据结构与算法】二叉树——堆
weixin_63726869的博客
08-11 840
介绍了树，二叉树，堆的概念和结构，重点讲述了堆结构是如何实现的，以及在实现过程中的注意事项。
基于C语言实现二叉树-堆-图（数据结构实验）【100012026】
04-25
1.二叉树的应用：二叉排序树BST和平衡二叉树AVL的构造 2.堆的应用：统计海量数据中最大的K个数（Top-K问题） 3.图的应用：单源最短路径Dijkestra算法
数据结构与算法Java实现.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和队列等抽象数据类型。 存储结构（物理结构）：描述数据在计算机中如何...
数据结构基本算法实现.zip
01-14
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和队列等抽象数据类型。 存储结构（物理结构）：描述数据在计算机中如何...
浙江大学数据结构MOOC-课后习题-第十讲-排序4 统计工龄
最新发布
chan1ee的博客
05-28 223
题目汇总。
二叉树顺序结构实现【堆的实现】【详细图解】
LiU11e的博客
05-28 678
二叉树（堆）顺序结构的实现，并带有堆排序拓展
二叉树的链式结构（二叉树）与顺序结构（堆）---数据结构
Zjxbxv11的博客
05-28 458
下面是树的示意图：注意：在树形结构中，子树之间不能有交集，否则就不是树形结构！！！例如下面的这几棵树就不是树形结构：1->结点的度：一个结点所含的子树的个数称为该结点的度； 如上图：A的有6颗子树，故A的度为6。2->叶结点或终端结点：度为0的结点称为叶结点； 如上图：B、C、H、I、P、Q、....等结点都为叶结点。3->非终端结点或分支结点：度不为0的结点； 如上图：A、D、E、F、G...等结点为分支结点。4->双亲结点或父结点：若一个结点含有子结点，则这个结点称为其子结点的父结点； 如上图：A是B的
希尔排序法
qq_24946843的博客
05-28 228
gap=2，从a[2]开始，a[2]和a[0]进行插入排序，a[3]和a[1]插入排序，a[4]和a[2]、a[0]插入排序......上面gap=2，即5，14，18，27，68为一组；13，20，36，39，51为一组。可以发现左边都是较小的数据，右边都是较大的数据，更方便把分成的每一个组进行插入排序。为什么 要采取上面分组的方法呢（gap），换一种方法也可以吗？
数据结构教程二叉树的创建
05-12
二叉树是一种非常常见的数据结构，它的每个节点最多只有两个子节点，分别称为左子节点和右子节点。二叉树有很多应用场景，例如搜索树、堆、表达式树等。在这里，我将简单介绍二叉树的创建方法。 二叉树的创建可以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

华丞臧.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值