树和二叉树

玉知朴

于 2024-08-04 15:37:59 发布

阅读量531

点赞数 17

文章标签：算法数据结构 c语言

本文链接：https://blog.csdn.net/m0_64752704/article/details/140904169

版权

树和二叉树的概念

树的定义

二叉树的定义

树和二叉树的概念

树的定义

树（Tree）是一个分层数据的抽象模型，包含一个根节点和可能的子树，每个节点可以有任意数量的子节点。

二叉树的定义

二叉树（Binary Tree）是一种特殊的树，其中每个节点最多只有两个字节点，称为左子节点和右子节点。

树的表示

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

二叉树的特殊性质

若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有 $2^{i-1}$ 个结点。
若规定根节点的层数为1，则深度为h的二叉树的最大结点数是 $2^{h}$ -1。
对任何一棵二叉树, 如果度为0其叶结点个数为 $n_{0}$ ，度为2的分支结点个数为 $n_{2}$ . 则有 $n_{0}$ = $n_{2}$ +1。
若规定根节点的层数为1，具有n个结点的满二叉树的深度，h= $log_{2} (n+1)$ 。
对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对于序号为i的结点有:
1. 若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点
2. 若2i+1<n,左孩子序号：2i+1，2i+1>=n否则无左孩子
3. 若2i+2<n,右孩子序号：2i+2，2i+2>=n否则无右孩子

二叉树的存储方式

顺序存储：就是用数组存储。（只适合表示完全二叉树）

链式存储：就是用链表存储。分为三个部分：数据（data）、左指针和右指针（left，right）。

二叉堆的结构以及概念

堆的性质：堆是一颗完全二叉树。堆中某个节点的值总是不大于或不小于其父节点的值。

大堆：任何一个父亲>=孩子

小堆：任何一个父亲<=孩子

堆的代码实现：

//初始化
void HpInit(Hp* php)
{
	assert(php);
	php->a = NULL;
	php->capcity = php->size = 0;
}

//销毁
void HpDestory(Hp* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->capcity = php->size = 0;
}

void Swap(HeapDataType* x, HeapDataType* y)
{
	HeapDataType p = *x;
	*x = *y;
	*y = p;
}
//调整
void Adjustup(HeapDataType* 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 HpPop(Hp* php)
{
	assert(php);
	assert(php->size > 0);
	Swap(&php->a[0], &php->a[php->size - 1]);
	php->size--;
	AdjustDown(php->a, php->size, 0);
}

bool HpEmpty(Hp* php)
{
	assert(php);
	return php->size == 0;
}

堆的TOP-K问题

用前十个数据建小堆
后续数据跟堆顶比较，如果比堆顶数据大，就替代谁。进堆。
时间复杂度：K+（N-K）* $\log k$ 。
求前K个最大的元素，建小堆；求前K个最小的元素建大堆。

代码实现：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<time.h>
交换
void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
向下调整
void AdjustDown(int* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child+1 < n && 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 Topk(int* a, int n, int k)
{
	int* min = (int*)malloc(sizeof(int*) * k);
	assert(min);
	for (int i = 0; i < k; ++i)
	{
		min[i] = a[i];
	}
	for (int i = (k - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDown(min, k, i);
	}
	for (int j = k; j < n; ++j)
	{
		if (a[j] > min[0])
		{
			min[0] = a[j];
			AdjustDown(min, k, 0);
		}
	}
	for (int i = 0; i < k; ++i)
	{
		printf("%d\n", min[i]);
	}
}

int main()
{
	int n = 1000;
	int* a = (int*)malloc(sizeof(int) * n);
	srand(time(0));    //生成随机数
	for (int i = 0; i < n; ++i)
	{
		a[i] = rand() % 1000000;
	}

	a[5] = 1000000 + 1;
	a[123] = 1000000 + 2;
	a[53] = 1000000 + 3;
	a[512] = 1000000 + 4;
	a[120] = 1000000 + 5;
	a[99] = 1000000 + 6;
	a[0] = 1000000 + 7;
	a[76] = 1000000 + 8;
	a[42] = 1000000 + 9;
	a[31] = 1000000 + 10;
	Topk(a, n, 10);
	return 0;
}

链式二叉树的前中后序

void Print(Node*node)
{
	if (node != NULL)
	{
		Print(node->left);
		printf("%d->", node->data);
		Print(node->right);
	}
}

//前序
void PrintQ(Node* node)
{
	if (node != NULL)
	{
		printf("%d->", node->data);
		PrintQ(node->left);
		PrintQ(node->right);
	}
}
//后序
void PrintH(Node* node)
{
	if (node != NULL)
	{
		PrintH(node->left);
		PrintH(node->right);
		printf("%d->", node->data);
	}
}