数据机构--二叉树-堆

最新推荐文章于 2024-07-10 15:47:04 发布

coffee_lake_

最新推荐文章于 2024-07-10 15:47:04 发布

阅读量581

点赞数 15

文章标签：数据结构算法

本文链接：https://blog.csdn.net/2302_80245587/article/details/139023667

版权

树的结构

我们先来看一张树的图片
在这里插入图片描述
，**树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。**把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。

有一个特殊的结点，称为根结点，根结点没有前驱结点除根结点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i <= m)又是一棵结构与树类似的子树。

每棵子树的根结点有且只有一个前驱，可以有0个或多个后继因此，树是递归定义的。树的结构就像这样
在这里插入图片描述
注意：树形结构中，子树之间不能有交集，否则就不是树形结构，如果像下面这种非线性的数据结构，就不能被称作树形结构

树的概念

在这里插入图片描述
结点的度：一个结点含有的子树的个数称为该结点的度；如上图：A的为6，可以理解为一个节点下面有多少分支就有多少度。

叶结点或终端结点：度为0的结点称为叶结点；如上图：B、C、H、I…等结点为叶结点

非终端结点或分支结点：度不为0的结点；如上图：D、E、F、G…等结点为分支结点

孩子结点或子结点：一个结点含有的子树的根结点称为该结点的子结点；如上图：B是A的孩子结点

兄弟结点：具有相同父结点的结点互称为兄弟结点；如上图：B、C是兄弟结点

树的度：一棵树中，最大的结点的度称为树的度；如上图：树的度为6

结点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推；

树的高度或深度：树中结点的最大层次；如上图：树的高度为4

堂兄弟结点：双亲在同一层的结点互为堂兄弟；如上图：H、I互为兄弟结点

结点的祖先：从根到该结点所经分支上的所有结点；如上图：A是所有结点的祖先

子孙：以某结点为根的子树中任一结点都称为该结点的子孙。如上图：所有结点都是A的子孙

森林：由m（m>0）棵互不相交的树的集合称为森林；

树的表示

树相比于，其他线性结构，比如顺序表，链表等，他的表示更加复杂，一般的线性结构，只要知道下一个节点在哪，把各个节点之间连接起来就行了，而树形结构的表示可不能这样，树形结构，他既要有自己存放数据的值域，又要有保存节点和节点之间的关系，于是就有了这样一种表示方法，左孩子右兄弟 这也是最常用的表示方法。
在这里插入图片描述

这种表示方法的好处在于

typedef int DataType;
struct Node
{
 struct Node* Child; // 第一个孩子结点
 struct Node* Brother; // 指向其下一个兄弟结点
 DataType data; // 结点中的数据域
 }

那么这样的表示方法有什么好处呢？一是方便二叉树的遍历，我们很容易访问一个节点的所有兄弟节点，二是方便插入数据，排序等。

有了以上关于树的认识，接下来就要讲本节的重点，二叉树了

二叉树的概念和结构

二叉树是结点的一个有限集合，该集合:

或者为空
由一个根结点加上两棵别称为左子树和右子树的二叉树组成

就像下面这张图
在这里插入图片描述

注意
1. 二叉树不存在度大于2的结点
2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

特殊的二叉树

1.满二叉树
一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是，则它就是满二叉树。
2.完全二叉树
完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K
的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对
应时称之为完全二叉树。要注意的是满二叉树是一种特殊的完全二叉树。

二叉树的性质

若规定根结点的层数为1，则一棵非空二叉树的第i层上最多有2*^（i-1)个节点；
若规定根结点的层数为1，则深度为h的二叉树的最大结点数是 2*^h -1，这个-1就是减去根节点。

对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有结点从0开始编号，则对于序号为i的结点有：

若i>0，i位置结点的双亲序号：(i-1)/2；i=0，i为根结点编号，无双亲结点
若2i+1<n，左孩子序号：2i+1，2i+1>=n否则无左孩子
若2i+2<n，右孩子序号：2i+2，2i+2>=n否则无右孩子

二叉树的存储结构

1. 顺序存储
顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空
间的浪费。而现实中使用中只有堆才会使用数组来存储，关于堆我们后面的章节会专门讲解。二叉树顺
序存储在物理上是一个数组，在逻辑上是一颗二叉树。

2. 链式存储
二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。通常的方法是
链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所
在的链结点的存储地址。链式结构又分为二叉链和三叉链。

堆的概念及结构

如果有一个关键码的集合K = { ，，，…， }，把它的所有元素按完全二叉树的顺序存储方式存储
在一个一维数组中，并满足： <= 且 <= ( >= 且 >= ) i = 0，1，2…，则称为小堆(或大堆)。将根结点最大的堆叫做最大堆或大根堆，根结点最小的堆叫做最小堆或小根堆。
堆的性质：
堆中某个结点的值总是不大于或不小于其父结点的值；
堆总是一棵完全二叉树。

二叉树顺序结构的代码实现

我们在写二叉树之前，我们需要确定我们是使用顺序结构来实现的，顺序结构也就是数组。

typedef int HPdatatype;

struct heap
{
	HPdatatype* data_arr;
	int size;
	int capacity;
};

typedef struct heap heap;

先定义好我们的结构体，里面存放我们的数组指针，还有数组大小，和实际使用的大小。

二叉树的创建与销毁

void init_heap(heap* hp)//初始化
{
	hp->capacity = 0;
	hp->data_arr = NULL;
	hp->size = 0;
}
void del_heap(heap* hp)//销毁
{
	free(hp->data_arr);
	hp->data_arr = NULL;
	hp->size = hp->capacity = 0;
}

这里的销毁和初始化就不多讲了，就和链表顺序表一样。

二叉树的插入数据

void heap_push(heap* hp, HPdatatype data)//插入数据
{
	assert(hp);
	if (hp->size == hp->capacity)
	{
		int newcapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
		HPdatatype* temp = (HPdatatype*)realloc(hp->data_arr, sizeof(HPdatatype) * newcapacity);
		if (temp == NULL)
		{
			perror("heap_realloc_fail");
			exit(1);
		}
		hp->data_arr = temp;
		hp->capacity = newcapacity;
	}
	hp->data_arr[hp->size] = data;
	hp->size++;
	adjustup(hp->data_arr, hp->size - 1);
}

这里的插入数据，我们要使用realloc函数来申请内存空间，因为这是用数组创建的，需要考虑扩容的情况，这里的核心内容是**adjustup(hp->data_arr, hp->size - 1);**这个函数，其他的就和顺序表，链表创建空间差不多的。

向上调整

这里是我们的重点

//向上调整,操作数组下标
void adjustup(HPdatatype* data_arr, int child)
{
	HPdatatype farther = (child - 1) / 2;
	while (child > 0)
	{
		if (data_arr[child] < data_arr[farther])
		{
			swap(&data_arr[child], &data_arr[farther]);
			child = farther;
			farther = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}

}

这里我们要明白的一点是，我们向上调整操作的是数组下标，这里我们创建的是二叉树中的小堆，小堆可以这样理解，谁小谁就当父亲，就像下面这张图。

在这里插入图片描述
如果把这个二叉树小堆看作一个数组，他应该是这样的

还有代码中的这个公式，其实是一个规律用来找孩子的父亲节点的，我们可以验证一下

	HPdatatype farther = (child - 1) / 2;

在这里插入图片描述
我们插入的数据都是在数组最后面插入的，放在二叉树里面就是从左至右插入新的叶子节点，所以插入之后要向上调整，找到父亲节点，父亲与儿子比较谁小谁就往上面调整，谁大谁就往下面调整。然后在把父亲节点赋值给孩子节点，在用当前的孩子节点去找上面的父亲节点，在来比较，如此往复，直到比到根节点为止。

向下调整

void adjustdown(HPdatatype* data_arr, int num, int farther)
{
	int child = farther * 2 + 1;//左孩子
	while (child < num)
	{      // child+1<num防止数组越界（跳到叶子的情况就不需要调了）
		if (child+1<num && data_arr[child + 1] < data_arr[child])//右孩子
		{
			child++;
		}
		if (data_arr[child] < data_arr[farther])
		{
			swap(&data_arr[child], &data_arr[farther]);
			farther = child;
			child = farther * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

向下调整就是从根节点开始，向下调整，让父亲节点去找孩子节点，这里我们用了假设法，假设左孩子是较小的那个，那就继续，如果是右孩子是较小的那个，就让child++，因为同父亲底下的孩子是挨着的，左孩子+1就可以找到右孩子，然后在进行比较，孩子和父亲比较，如果还需要调换就继续调换，如果不需要就结束，当child>num(数组大小时）就代表已经比较到叶子了，没有孩子了，就不能在比较了就跳出循环
在这里插入图片描述

二叉树堆判空

bool HPempty(heap* hp)
{
	assert(hp);
	if (hp->size > 0)
	{
		return false;
	}
	else
	{
		return true;
	}
}

这里就比较简单，直接判断size是不是为0就好了

取出根节点

HPdatatype HPtop(heap* hp)
{
	assert(hp);
	assert(hp->size > 0);

	return hp->data_arr[0];
}

直接返回数组0下标的元素。

调整，把第二小的给pop上来

//调整，把第二小的调上来
void HPpop(heap* hp)
{
	assert(hp);
	assert(hp->size > 0);
	swap(&hp->data_arr[hp->size - 1], &hp->data_arr[0]);
	hp->size--;
	adjustdown(hp->data_arr, hp->size, 0);
}

这里，我们首先把数组第一个和最后一个交换位置，（size-1就是最后一个位置）数组下标从0开始，然后在调整堆，这样就会把第二小的调整到根节点上来，调整原理和上面类似。

堆排序

这是我们的主函数

int main()
{
	int a[] = { 1888,111,222,4,5,612,19,1,11787 };
	int sz = sizeof(a) / sizeof(a[0]);
	test(a,sz);
	build_heap_up(a, sz);
	return 0;
}

下面是排序代码

void test(HPdatatype* data_arr,int size)
{
	heap hp;
	init_heap(&hp);
	for (int i = 0; i < size; i++)
	{
		heap_push(&hp, data_arr[i]);
	}
	while (!HPempty(&hp))
	{
		printf("%d ", HPtop(&hp));
		HPpop(&hp);
	}

这里我们要结合上面的函数一起看，我们先给了一个无序数组，然后通过heap_push插入到数组里面，heap_push里面就包含了向上调整函数，也就是说我们在插入数据的时候就在进行父亲与孩子的比较，最后插入完成之后，这个数组已经变成一个小堆存放的二叉树了，然后就调用hptop函数，打印排序出来，然后在调用hppop函数，交换数组首尾，把第二小的树给推到根节点的位置，依次类推，就完成我们的排序。
在这里插入图片描述
这个是第一种方法，还有第二种方法我们可以直接把数组看作一个完全二叉树，就不需要去建堆
这样排序下来

void build_heap_up(HPdatatype* data_arr, int size)
{
	//排降序
	for (int i = 0; i < size; i++)
	{
		adjustup(data_arr, i);
	}
	int end = size - 1;
	while (end > 0)
	{
		swap(&data_arr[end], &data_arr[0]);
		adjustdown(data_arr, end, 0);
		end--;
	}
}

在这里插入图片描述
源码

# include"heap.h"

void init_heap(heap* hp)//初始化
{
	hp->capacity = 0;
	hp->data_arr = NULL;
	hp->size = 0;
}
void del_heap(heap* hp)//销毁
{
	free(hp->data_arr);
	hp->data_arr = NULL;
	hp->size = hp->capacity = 0;
}
void swap(int* child, int* farther)
{
	int temp = *farther;
	*farther = *child;
	*child = temp;
}
//向上调整,操作数组下标
void adjustup(HPdatatype* data_arr, int child)
{
	HPdatatype farther = (child - 1) / 2;
	while (child > 0)
	{
		if (data_arr[child] < data_arr[farther])
		{
			swap(&data_arr[child], &data_arr[farther]);
			child = farther;
			farther = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}

}
//向下调整，操作数组下标
void adjustdown(HPdatatype* data_arr, int num, int farther)
{
	int child = farther * 2 + 1;//左孩子
	while (child < num)
	{      // 
		if (child+1<num && data_arr[child + 1] < data_arr[child])//右孩子
		{
			child++;
		}
		if (data_arr[child] < data_arr[farther])
		{
			swap(&data_arr[child], &data_arr[farther]);
			farther = child;
			child = farther * 2 + 1;
		}
		else
		{
			break;
		}
	}

}
void heap_push(heap* hp, HPdatatype data)//插入数据
{
	assert(hp);
	if (hp->size == hp->capacity)
	{
		int newcapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
		HPdatatype* temp = (HPdatatype*)realloc(hp->data_arr, sizeof(HPdatatype) * newcapacity);
		if (temp == NULL)
		{
			perror("heap_realloc_fail");
			exit(1);
		}
		hp->data_arr = temp;
		hp->capacity = newcapacity;
	}
	hp->data_arr[hp->size] = data;
	hp->size++;
	adjustup(hp->data_arr, hp->size - 1);
}
void print(heap* hp)
{
	for (int i = 0; i < hp->size; i++)
	{
		printf("%d ", hp->data_arr[i]);
	}
}
//调整，把第二小的调上来
void HPpop(heap* hp)
{
	assert(hp);
	assert(hp->size > 0);
	swap(&hp->data_arr[hp->size - 1], &hp->data_arr[0]);
	hp->size--;
	adjustdown(hp->data_arr, hp->size, 0);
}
HPdatatype HPtop(heap* hp)
{
	assert(hp);
	assert(hp->size > 0);

	return hp->data_arr[0];
}

bool HPempty(heap* hp)
{
	assert(hp);
	if (hp->size > 0)
	{
		return false;
	}
	else
	{
		return true;
	}
}

test.c

# include"heap.h"
void test(HPdatatype* data_arr,int size)
{
	heap hp;
	init_heap(&hp);
	for (int i = 0; i < size; i++)
	{
		heap_push(&hp, data_arr[i]);
	}
	while (!HPempty(&hp))
	{
		printf("%d ", HPtop(&hp));
		HPpop(&hp);
	}
}
void build_heap_up(HPdatatype* data_arr, int size)
{
	//排升序
	for (int i = 0; i < size; i++)
	{
		adjustup(data_arr, i);
	}
	int end = size - 1;
	while (end > 0)
	{
		swap(&data_arr[end], &data_arr[0]);
		adjustdown(data_arr, end, 0);
		end--;
	}
}
int main()
{
	int a[] = { 1888,111,222,4,5,612,19,1,11787 };
	int sz = sizeof(a) / sizeof(a[0]);
	//test(a,sz);
	build_heap_up(a, sz);
	return 0;
}

heap.h

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

typedef int HPdatatype;

struct heap
{
	HPdatatype* data_arr;
	int size;
	int capacity;
};

typedef struct heap heap;

void init_heap(heap* hp);

void adjustup(HPdatatype* data_arr, int child);

void heap_push(heap* hp, HPdatatype data);

void swap(HPdatatype* child, HPdatatype* farther);

void del_heap(heap* hp);//销毁

void print(heap* hp);

void HPpop(heap* hp);

HPdatatype HPtop(heap* hp);

bool HPempty(heap* hp);

void adjustdown(HPdatatype* data_arr, int num, int farther);

coffee_lake_

关注

15
点赞
踩
16

收藏

觉得还不错? 一键收藏
1
评论
数据机构--二叉树-堆

我们先来看一张树的图片，**树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。**把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继因此，树是递归定义的。树的结构就像这样，如果像下面这种非线性的数据结构，就不能被称作树形结构。
复制链接

扫一扫