二叉树-堆

树的几个重要定义

1.树=根+子树=根+亲缘关系

2.节点的度:有几个子树或根有几个孩子

3.叶子节点:没有孩子的终端节点 度为0

4.分支节点:度不为0的节点

5.树=叶子+分支节点

6.父亲节点/双亲节点

7.子节点

8.树的度:最大节点的度就是树的度

9.树的层:一般从第一层开始数,也有从0层开始数的,但是多数情况下从第一层开始

10.树的高/深度:一共多少层

11.空树的度:0
为什么会有0层这个少数概念?

数组我们是从下标为0开始的

为什么呢--->为了方便计算

我们都是知道 数组名=首元素地址

a[i]=*(a+i);

数组从零开始就是为了方便计算

12.森林:多颗互不相交的树----->并查集

树是由递归定义的:任何一棵树=[根+N颗子树(N>=0)]

注意:树的子树之间是不相交的

若子树相交则为--->图

一颗有N个节点的数有N-1条边

树给如何代码定义呢?

这里循序渐进的介绍三种方法,其中最后一种是最绝妙最常用的方法

(1).

//1.明确度 N=4
#define N 4
struct TreeNode
{
	int val;
	struct TreeNode* sub[N];//指针数组
};

(2).

//2.未明确度
SeqList subs;//顺序表内部存struct TreeNode* 在C语言就有些麻烦
//C++中有 vector<struct TreeNode*>suns;

(3).

//3.左孩子右兄弟法
struct TreeNdoe
{
	int val;
	struct TreeNode* leftchild;
	struct TreeNode* rightbrother;
};
/*
不管我有几个孩子
我都只想左边第一个孩子 
child 指向左孩子
brother指向兄弟
*/

这是树的定义

在树的结构中我们最常用的是二叉树

二叉树的定义就只有左孩子和右孩子,他至多两个孩子,不存在多个兄弟

二叉树:满二叉树 和 完全二叉树

满二叉树:高度为H ,一共有2^H-1个节点

完全二叉树 :前H-1层都是满的,最后一层不满,但从左到右必须连续存在
节点个数范围:2^H~2 ^H-1

所以满二叉树是特殊的完全二叉树

二叉树是能存非常多的节点的

假设有N个节点

2^H-1=N

H=log(N)+1

H=20 能存100W+个节点

H=30 能存10亿+个节点

二叉树的存储---数组

假设父亲在数组的下标是i

左孩子=2i+1
右孩子=2i+2

假设孩子在数组的下标是j

需要判断孩子是左孩子还是有孩子吗---->不用判断

除法运算直接取整

父亲=(j-1)/2

关于数组的存储方式是只适用于完全二叉树的

非完全二叉树倒是也能用就是不适合

非完全二叉树通常用链式结构存储

堆

1.堆是一个完全二叉树----->数组存储

2.大堆:任何一个父亲都大于等于孩子

小堆:任何一个父亲都小于等于孩子

注意:大堆小堆都不是严格的升序降序,因为孩子之间并无大小关系

但是小堆的根是最小的,大堆的根是最大的

堆在逻辑上:是一棵树

物理上:是一个数组

定义堆的代码

Heap.h

#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>
typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}HP;
//本质上是数组,一个指针 一个数组大小 一个有效空间大小

//接口
void HPInit(HP* php);
void HPDestroy(HP* php);
void HPPush(HP* php,HPDataType x);
void HPPop(HP* php);

Heap.c

#include"Heap.h"
void HPInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->size = php->capacity = 0;
}

void HPDestroy(HP*php)
{
	assert(php);
	free(php->a);
	php->a = 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)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;//还要继续往后计算父亲节点进行比较
			parent = (child - 1) / 2;
		}
		else
			break;//孩子大就不用交换位置了,跳出去
	}
}

//插入
void HPPush(HP* php,HPDataType x)
{
	//利用向上调整法 插到堆尾
	//根据是大堆小堆 与父亲比较调整位置
	assert(php);
	//先看看有没有空间插入
	if (php->size == php->capacity)
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		//原来空间就为0先给4个,原来有空间现在没地方插直接扩2倍
		HPDataType* tmp = (HPDataType*)realloc(php->a,newcapacity * sizeof(HPDataType));
	
	//判断扩容成功与否
	if (tmp = NULL)
	{
		perror("realloc fail");
		return;
	}
	php->a = tmp;
	php->capacity = newcapacity;
	}
	//x插到堆尾
	php->a[php->size] = x;
	php->size++;
	Adjustup(php->a, php->size - 1);//把堆尾元素当做孩子与父亲比较进行位置调整
}

以上就只有插入及插入所需要的向上调整算法

通过一个数组实现堆:

#include"Heap.h"
void TestHeap01()
{
	int a[] = { 4,2,8,1,5,6,7,9 };
	HP hp;
	HPInit(&hp);
	for (int i = 0; i < sizeof(a) / sizeof(int); i++)
	{
		HPPush(&hp, a[i]);//插入并及时调整位置
	}
}

向下调整算法

//向下调整算法
void Adjustdown(HPDataType* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		//n就是数组大小
	//向上调整找父亲,向下调整找孩子
	//找那个孩子呢? 假设法假设左孩子小,找左孩子
		
		//判断下到底是哪个孩子小
		if (child + 1 < n && a[child + 1] < a[child])
			//if (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 HPPop(HP* php)
{
	/*
	将堆顶与堆尾互换,删除堆尾,再利用向下调整算法调整位置
	*/
	assert(php);
	assert(php->size > 0);
	Sawp(&php->a[0], &php->a[php->size - 1]);//顶尾交换
	//删除尾部就很简单直接--
	php->size--;
	Adjustdown(php->a, php->size, 0);//从堆顶一个一个向下比较调整
}

注意:在这里我们得到的都是小堆

实现堆:是由数组一个一个的插入(插入中包含向上调整算法)

我们要控制得到的是大堆还是小堆:

可以通过控制两个调整算法的判断比较条件来实现

以上示例只能怪都是<号

若想得到大堆就改成>号

注意:若想使用向下调整,左右子树必须是小堆

返回堆顶元素

HPDataType HPTop(HP* php)
{
	assert(php);
	assert(php->size > 0);
	return php->a[0];
}

判空

bool HPEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}

Push尾插 利用向上调整法
Pop尾删 利用向下调整法

实现一个打印有序(并不是严格的排序)

1.实现一个堆

2.因为通过调整算法后一定是有序的

所以打印顶,再删除顶,在继续打印出来就一定是有序的

但这并不是堆排序

int main()
{
	int a[] = { 4,2,8,1,5,6,9,7 };
	HP hp;
	HPInit(&hp);
	for (int i = 0; i < sizeof(a) / sizeof(int); i++)
	{
		HPPush(&hp, a[i]);//插入并及时调整位置
	}
	while (!HPEmpty)
	{
		printf("%d", HPTop(&hp));
		HPPop(&hp);
	}
	return 0;
}

注意:这只是打印出来是有序的,同样到底想升序还是降序去改变两种调整算法的判断条件

Top K----->相同的逻辑

寻找最大的前K个

int main()
{
	int a[] = { 4,2,8,1,5,6,9,7 };
		HP hp;
		HPInit(&hp);
		for (int i = 0; i < sizeof(a) / sizeof(int); i++)
		{
			HPPush(&hp, a[i]);//插入并及时调整位置
		}
	int k;
	scanf("%d", &k);
	while (k--)
	{
		printf("%d", HPTop(&hp));
		HPPop(&hp);
	}
	return 0;
}

这个算法的时间复杂度:log(N)

算是很快的算法

10亿个数据 只需要调30次

前面我们只是实现了打印有序,并未让数组变为有序

接下来的代码我们将让数组a变为有序数组

int main()
{
	int a[] = { 4,2,8,1,5,6,9,7 };
	HP hp;
			HPInit(&hp);
	for (int i = 0; i < sizeof(a) / sizeof(int); i++)
	{
		HPPush(&hp, a[i]);//插入并及时调整位置
	}
	int i = 0;
	while (!HPEmpty)
	{
		a[i++] = HPTop(&hp);//直接把顶放进数组中
		HPPop(&hp);
		
	}

	//出循环就整个数组都是有序的了
	return 0;
}

如何建堆

向上调整法建堆

时间复杂度:O(N*logN)

void HeapSort(int *a,int n)
{
	for (int i = 1; i < n; i++)
	{
		Adjustup(a, i);
	}
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		Adjustdown(a, end, 0);
		--end;
	}
}

向下调整法建堆

时间复杂度:O(N)

从最后一个分支节点开始调

也就是最后一个叶子的父亲

一个子树一个子树的调

4 2 8 1 5 6 9 7 2 7 9

最后一个分支节点是5

从5的位置开始--,像前面依次调整位置

void HeapSort(int* a, int n)
{
	for (int i = (n-1-1)/2; i >=0; i--)
	{
		Adjustdown(a,n,i);
	}
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		Adjustdown(a, end, 0);
		--end;
	}
}