Lesson5--树,堆,二叉树的认识

已于 2023-02-10 21:03:36 修改
阅读量2.3k 收藏 7
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构
于 2023-01-23 22:50:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiguazkb123/article/details/128754413
版权

1.树概念及结构

1.1树的概念

 

 注意：树形结构中，子树之间不能有交集，否则就不是树形结构

 1.2 树的相关概念

 1.3 树的表示

树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，既然保存值域，也要保存结点和结点之间的关系，实际中树有很多种表示方式如：双亲表示法，孩子表示法、孩子双亲表示法以及孩子兄弟表示法等。

我们这里就简单的了解其中最常用的孩子兄弟表示法。

 

1.4 树在实际中的运用（表示文件系统的目录树结构）

2.二叉树概念及结构

2.1概念

一棵二叉树(度最大为2)是结点的一个有限集合，该集合:

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

从上图可以看出：

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

注意：对于任意的二叉树都是由以下几种情况复合而成的： 

 2.2现实中的二叉树：

 2.3 特殊的二叉树：

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

 

 2.4二叉树的性质

 

2.5 二叉树的存储结构 

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

  

2. 链式存储
二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址 。链式结构又分为二叉链和三叉链，当前我们学习中一般都是二叉链，后面课程学到高阶数据结构如红黑树等会用到三叉链。 

typedef int BTDataType;
// 二叉链
struct BinaryTreeNode
{
    struct BinTreeNode* _pLeft;   // 指向当前节点左孩子 
    struct BinTreeNode* _pRight; // 指向当前节点右孩子
    BTDataType _data; // 当前节点值域
}

// 三叉链
struct BinaryTreeNode
{
    struct BinTreeNode* _pParent; // 指向当前节点的双亲 
    struct BinTreeNode* _pLeft;   // 指向当前节点左孩子 
    struct BinTreeNode* _pRight; // 指向当前节点右孩子
    BTDataType _data; // 当前节点值域 
}；

3.二叉树的顺序结构及实现

3.1 二叉树的顺序结构 

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

 

3.2 堆的概念及结构 (完全二叉树)

大堆 :树中一个树及子树中，任何一个父亲都大于等于孩子
小堆 :树中一个树及子树中，任何一个父亲都小于等于孩子 

堆的性质：

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

 

  

3.3 堆的实现

3.3.1 堆向下调整

现在我们给出一个数组，逻辑上看做一颗完全二叉树。我们通过从根节点开始的向下调整算法可以把它调整成一个小堆。

向下调整算法有一个前提：左右子树必须是一个堆，才能调整。

//堆的向下调整（小堆）
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;
		}
	}
}

3.3.2 堆向上调整

//堆的向上调整（小堆）
void AdjustUp(int* a, int child)
{
	assert(a);
	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;
		}
	}
}

3.3.2堆的创建

下面我们给出一个数组，这个数组逻辑上可以看做一颗完全二叉树，但是还不是一个堆，现在我们通过算法，把它构建成一个堆。根节点左右子树不是堆，我们怎么调整呢？这里我们从倒数的第一个非叶子节点的子树开始调整，一直调整到根节点的树，就可以调整成堆。

3.3.3 建堆时间复杂度

3.3.4 堆的插入

先插入一个10到数组的尾上，再进行向上调整算法，直到满足堆。

void HeapPush(HP* hp, HPDataType x)
{
	assert(hp);
	HeapCheckCapacity(hp);

	hp->a[hp->size] = x;
	hp->size++;
	AdjustUp(hp->a, hp->size - 1);
}

 3.3.5 堆的删除

删除堆是删除堆顶的数据，将堆顶的数据根最后一个数据一换，然后删除数组最后一个数据，再进行向下调整算法。

 3.3.6 堆的代码实现

#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 HeapInit(HP* hp);
// 堆的销毁
void HeapDestroy(HP* hp);
// 堆的插入
void HeapPush(HP* hp, HPDataType x);
// 堆的删除
void HeapPop(HP* hp);
// 取堆顶的数据
HPDataType HeapTop(HP* hp);
// 堆的数据个数
int HeapSize(HP* hp);
// 堆的判空
bool HeapEmpty(HP* hp);
// 堆的打印
void HeapPrint(HP* hp);
// 堆的扩容
void HeapCheckCapacity(HP* hp);
// 堆的向下调整
void AdjustDown(int* a, int n, int parent);
// 堆的向上调整
void AdjustUp(int* a, int child);
#define _CRT_SECURE_NO_WARNINGS 1

#include"Heap.h"

void Swap(HPDataType* px, HPDataType* py)
{
	HPDataType tmp = *px;
	*px = *py;
	*py = tmp;
}

void HeapInit(HP* hp)
{
	assert(hp);
	hp->a = NULL;
	hp->size = hp->capacity = 0;
}

void HeapDestroy(HP* hp)
{
	assert(hp);
	free(hp->a);
	hp->capacity = hp->size = 0;
}

void HeapCheckCapacity(HP* hp)
{
	assert(hp);
	if (hp->size == hp->capacity)
	{
		size_t newCapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
		HPDataType* tmp = realloc(hp->a, sizeof(HPDataType) * newCapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		hp->a = tmp;
		hp->capacity = newCapacity;
	}
}


void HeapPush(HP* hp, HPDataType x)
{
	assert(hp);
	HeapCheckCapacity(hp);

	hp->a[hp->size] = x;
	hp->size++;
	AdjustUp(hp->a, hp->size - 1);
}

bool HeapEmpty(HP* hp)
{
	assert(hp);

	return hp->size == 0;
}

int HeapSize(HP* hp)
{
	assert(hp);

	return hp->size;
}

HPDataType HeapTop(HP* hp)
{
	assert(hp);
	assert(!HeapEmpty(hp));

	return hp->a[0];
}

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 HeapPop(HP* hp)
{
	assert(hp);
	assert(!HeapEmpty(hp));

	Swap(&hp->a[0], &hp->a[hp->size - 1]);
	hp->size--;

	AdjustDown(hp->a, hp->size, 0);
}
void HeapPrint(HP* hp)
{
	for (int i = 0; i < hp->size; ++i)
	{
		printf("%d ", hp->a[i]);
	}
	printf("\n");
}

void AdjustUp(int* a, int child)
{
	assert(a);
	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;
		}
	}
}

3.4 堆的应用

3.4.1 堆排序 

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

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 HeapInit(HP* hp);
// 堆的销毁
void HeapDestroy(HP* hp);
// 堆的插入
void HeapPush(HP* hp, HPDataType x);
// 堆的删除
void HeapPop(HP* hp);
// 取堆顶的数据
HPDataType HeapTop(HP* hp);
// 堆的数据个数
int HeapSize(HP* hp);
// 堆的判空
bool HeapEmpty(HP* hp);
// 堆的打印
void HeapPrint(HP* hp);
// 堆的扩容
void HeapCheckCapacity(HP* hp);



// 堆的向上调整
void AdjustUp(int* a, int child);
// 堆的向下调整
void AdjustDown(int* a, int n, int parent);
// 交换函数
void Swap(HPDataType* px, HPDataType* py);

Heap.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"Heap.h"

void Swap(HPDataType* px, HPDataType* py)
{
	HPDataType tmp = *px;
	*px = *py;
	*py = tmp;
}

void HeapInit(HP* hp)
{
	assert(hp);
	hp->a = NULL;
	hp->size = hp->capacity = 0;
}

void HeapDestroy(HP* hp)
{
	assert(hp);
	free(hp->a);
	hp->capacity = hp->size = 0;
}

void HeapCheckCapacity(HP* hp)
{
	assert(hp);
	if (hp->size == hp->capacity)
	{
		size_t newCapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
		HPDataType* tmp = realloc(hp->a, sizeof(HPDataType) * newCapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		hp->a = tmp;
		hp->capacity = newCapacity;
	}
}

void AdjustUp(int* a, int child)
{
	assert(a);
	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 HeapPush(HP* hp, HPDataType x)
{
	assert(hp);
	HeapCheckCapacity(hp);

	hp->a[hp->size] = x;
	hp->size++;
	AdjustUp(hp->a, hp->size - 1);
}

bool HeapEmpty(HP* hp)
{
	assert(hp);

	return hp->size == 0;
}

int HeapSize(HP* hp)
{
	assert(hp);

	return hp->size;
}

HPDataType HeapTop(HP* hp)
{
	assert(hp);
	assert(!HeapEmpty(hp));

	return hp->a[0];
}


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 HeapPop(HP* hp)
{
	assert(hp);
	assert(!HeapEmpty(hp));

	Swap(&hp->a[0], &hp->a[hp->size - 1]);
	hp->size--;

	AdjustDown(hp->a, hp->size, 0);
}
void HeapPrint(HP* hp)
{
	for (int i = 0; i < hp->size; ++i)
	{
		printf("%d ", hp->a[i]);
	}
	printf("\n");
}

test.c

#include "Heap.h"

// 升序  空间复杂度是多少? O(N) 要求优化到O(1) -> 不能用Heap
//void HeapSort(int* a, int n)
//{
//	HP hp;
//	HeapInit(&hp);
//	// 建议一个N个小堆
//	for (int i = 0; i < n; ++i)
//	{
//		HeapPush(&hp, a[i]);
//	}
//
//	// Pop N 次
//	for (int i = 0; i < n; ++i)
//	{
//		a[i] = HeapTop(&hp);
//		HeapPop(&hp);
//	}
//
//	HeapDestroy(&hp);
//}

// 升序
void HeapSort(int* a, int n)
{
	// 把a构建成小堆
	// 方法1：
	/*for (int i = 1; i < n; ++i)
	{
	AdjustUp(a, i);
	}*/

	// 方法2：
	// O(N)
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{//n-1是最后一个节点，(n-1-1)/2是最后一个节点的父节点
		AdjustDown(a, n, i);//小堆
	}
//
	// 依次选数，调堆
	// O(N*logN)
	for (int end = n - 1; end > 0; --end)
	{
		Swap(&a[end], &a[0]);

		// 再调堆，选出次小的数
		AdjustDown(a, end, 0);
	}
}

int main()
{
	//TestTopk();
	int a[] = { 70, 56, 30, 25, 15, 10, 75, 33, 50, 69 };
	for (int i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
	{
		printf("%d ", a[i]);
	}
	printf("\n");

	HeapSort(a, sizeof(a) / sizeof(a[0]));

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

	return 0;
}

 3.4.2 TOP-K问题

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

最佳的方式就是用堆来解决，基本思路如下：
1. 用数据集合中前K个元素来建堆

  • 前k个最大的元素，则建小堆
  • 前k个最小的元素，则建大堆 

2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素

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

首先思考下建立大堆还是小堆？

建小堆，因为如果建大堆，最大的数可能挡在头的位置，其他9个次大的数就进不来。

思路:

1、用前K个数建立一个K个数的小堆。
2、剩下的N-K个数，依次跟堆顶的数据进行比较,如果比堆顶数据大，就替换堆顶的数据，再向下调整
3、最后堆里面K个数就是最大的K个数

#include "Heap.h"

// 在N个数找出最大的前K个  or  在N个数找出最小的前K个
void PrintTopK(int* a, int n, int k)
{
// 1. 建堆--用a中前k个元素建堆
// 2. 将剩余n-k个元素依次与堆顶元素交换，不满则则替换
	HP hp;
	HeapInit(&hp);
	// 创建一个K个数的小堆
	for (int i = 0; i < k; ++i)
	{
		HeapPush(&hp, a[i]);
	}

	// 剩下的N-K个数跟堆顶的数据比较，比他大，就替换他进堆
	for (int i = k; i < n; ++i)
	{
		if (a[i] > HeapTop(&hp))
		{
			//HeapPop(&hp);
			//HeapPush(&hp, a[i]);
			hp.a[0] = a[i];
			AdjustDown(hp.a, hp.size, 0);
		}
	}

	HeapPrint(&hp);

	HeapDestroy(&hp);
}

void TestTopk()
{
	int n = 1000000;
	int* a = (int*)malloc(sizeof(int)*n);
	srand(time(0));
	for (size_t i = 0; i < n; ++i)
	{
		a[i] = rand() % 1000000;
	}
	// 再去设置10个比100w大的数
	a[5] = 1000000 + 1;
	a[1231] = 1000000 + 2;
	a[5355] = 1000000 + 3;
	a[51] = 1000000 + 4;
	a[15] = 1000000 + 5;
	a[2335] = 1000000 + 6;
	a[9999] = 1000000 + 7;
	a[76] = 1000000 + 8;
	a[423] = 1000000 + 9;
	a[3144] = 1000000 + 10;
	PrintTopK(a, n, 10);
}

void TestHeap()
{
	int a[] = { 70, 56, 30, 25, 15, 10, 75 };
	HP hp;
	HeapInit(&hp);
	for (int i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
	{
		HeapPush(&hp, a[i]);
	}
	HeapPrint(&hp);

	HeapPop(&hp);
	HeapPrint(&hp);

	HeapPop(&hp);
	HeapPrint(&hp);

	HeapPop(&hp);
	HeapPrint(&hp);

	HeapPop(&hp);
	HeapPrint(&hp);

	HeapDestroy(&hp);
}

// 升序  空间复杂度是多少? 要求优化到O(1) -> 不能用Heap
//void HeapSort(int* a, int n)
//{
//	HP hp;
//	HeapInit(&hp);
//	// 建议一个N个小堆
//	for (int i = 0; i < n; ++i)
//	{
//		HeapPush(&hp, a[i]);
//	}
//
//	// Pop N 次
//	for (int i = 0; i < n; ++i)
//	{
//		a[i] = HeapTop(&hp);
//		HeapPop(&hp);
//	}
//
//	HeapDestroy(&hp);
//}


int main()
{
	//TestTopk();
	int a[] = { 70, 56, 30, 25, 15, 10, 75 };
	for (int i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
	{
		printf("%d ", a[i]);
	}
	printf("\n");

	HeapSort(a, sizeof(a) / sizeof(a[0]));

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

	return 0;
}

4.二叉树链式结构及其实现

4.1 前置说明

在学习二叉树的基本操作前，需先要创建一棵二叉树，然后才能学习其相关的基本操作。

由于现在大家对二叉树结构掌握还不够深入，为了降低大家学习成本，此处手动快速创建一棵简单的二叉树，快速进入二叉树操作学习，等二叉树结构了解的差不多时，我们反过头再来研究二叉树真正的创建方式。

typedef char BTDataType;
typedef struct BinaryTreeNode
{
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
	BTDataType data;
}BTNode;

BTNode* CreatBinaryTree()
{
	BTNode* nodeA = BuyNode('A');
	BTNode* nodeB = BuyNode('B');
	BTNode* nodeC = BuyNode('C');
	BTNode* nodeD = BuyNode('D');
	BTNode* nodeE = BuyNode('E');
	BTNode* nodeF = BuyNode('F');

	nodeA->left = nodeB;
	nodeA->right = nodeC;
	nodeB->left = nodeD;
	nodeC->left = nodeE;
	nodeC->right = nodeF;

	return nodeA;
}

 注意：上述代码并不是创建二叉树的方式，真正创建二叉树方式后序详解重点讲解。

再看二叉树基本操作前，再回顾下二叉树的概念，二叉树是：

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

 从概念中可以看出，二叉树定义是递归式的，因此后序基本操作中基本都是按照该概念实现的。 

4.2二叉树的遍历

4.2.1 前序、中序以及后序遍历

学习二叉树结构，最简单的方式就是遍历。所谓二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉 树中的节点进行相应的操作，并且每个节点只操作一次。访问结点所做的操作依赖于具体的应用问题。 遍历是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。

按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历：

  • 1. 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
  • 2. 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
  • 3. 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。 

由于被访问的结点必是某子树的根，所以N(Node）、L(Left subtree）和R(Right subtree）又可解释为根、根的左子树和根的右子树。NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。

前序遍历:

中序遍历:

后序遍历: 

 

// 二叉树前序遍历
void PreOrder(BTNode* root);
// 二叉树中序遍历
void InOrder(BTNode* root);
// 二叉树后序遍历
void PostOrder(BTNode* root);


void PreOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL");
		return;
	}
	printf("%c ", root->data);
	PreOrder(root->left);
	PreOrder(root->right);
}

void InOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL");
		return;
	}
	InOrder(root->left);
	printf("%C ", root->data);
	InOrder(root->right);
}
void PostOrder(BTNode* root)
{
	if (root == NULL) 
	{
		printf("NULL ");
		return;
	}

	PostOrder(root->left);
	PostOrder(root->right);
	printf("%C ", root->data);
}

 前序遍历递归图解：

4.2.2 层序遍历

层序遍历：除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。

设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。

 ​​

 队列中的数据类型是树的节点。

#pragma once
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>
//前置声明
struct BinaryTreeNode;
typedef struct BinaryTreeNode* QDataType;

//链式结构：表示队列
typedef struct QueueNode
{
	struct QueueNode* next;//指针域
	QDataType data;//数据域
}QueueNode;

//队列链表的头指针与尾指针
typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;
}Queue;

1、先入根
2、当前节点出来，把孩子带进去，这样上一层节点出的时候，带入下一层。
3、队列为空，说明最后一层没有节点了，遍历结束 

void LevelOrder(BTNode* root)
{
	if (root == NULL)
		return;

	Queue q;
	QueueInit(&q);
	QueuePush(&q, root);
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q); 
		printf("%c ", front->data);
		//孩子带进队列
		if (front->left)
			QueuePush(&q, front->left);
		if (front->right)
			QueuePush(&q, front->right);
	}
	printf("\n");
	QueueDestroy(&q);
}

练习：请写出下面的前序/中序/后序/层序遍历

 4.5 二叉树的创建和销毁


// 二叉树销毁
void BinaryTreeDestory(BTNode** root);
// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root);




void BinaryTreeDestory(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}

	BinaryTreeDestory(root->left);
	BinaryTreeDestory(root->right);
	free(root);
	//为了保证接口一致，注意需要在外边置空(形参改变不会影响实参）
	//BinaryTreeDestory(root);
	//root = NULL;
}


bool BinaryTreeComplete(BTNode* root)
{
	//层序遍历
	Queue q;
	QueueInit(&q);
	QueuePush(&q, root);
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);

		if (front == NULL)
		{
			break;
		}
		else
		{
			//孩子带进队列，空的也要带
			QueuePush(&q, front->left);
			QueuePush(&q, front->right);
		}

	}

	// 遇到空了以后，检查队列中剩下的节点
	// 1、剩下全是空，则是完全二叉树
	// 2、剩下存在非空，则不是完全二叉树
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);

		if (front)
		{
			QueueDestroy(&q);
			return false;
		}
	}

	QueueDestroy(&q);
	return true;
}

5.全部代码 

BinaryTree.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"BinaryTree.h"
#include"Queue.h"


BTNode* BuyNode(BTDataType x)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	if (node == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}

	node->data = x;
	node->left = node->right = NULL;
	return node;
}

BTNode* CreatBinaryTree()
{
	BTNode* nodeA = BuyNode('A');
	BTNode* nodeB = BuyNode('B');
	BTNode* nodeC = BuyNode('C');
	BTNode* nodeD = BuyNode('D');
	BTNode* nodeE = BuyNode('E');
	BTNode* nodeF = BuyNode('F');
	BTNode* nodeG = BuyNode('G');


	nodeA->left = nodeB;
	nodeA->right = nodeC;
	nodeB->left = nodeD;
	nodeC->left = nodeE;
	nodeC->right = nodeF;
	nodeF->right = nodeG;

	return nodeA;
}

void PreOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL");
		return;
	}
	printf("%c ", root->data);
	PreOrder(root->left);
	PreOrder(root->right);
}

void InOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL");
		return;
	}
	InOrder(root->left);
	printf("%C ", root->data);
	InOrder(root->right);
}
void PostOrder(BTNode* root)
{
	if (root == NULL) 
	{
		printf("NULL ");
		return;
	}

	PostOrder(root->left);
	PostOrder(root->right);
	printf("%C ", root->data);
}

void LevelOrder(BTNode* root)
{
	if (root == NULL)
		return;

	Queue q;
	QueueInit(&q);
	QueuePush(&q, root);
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q); 
		printf("%c ", front->data);
		//孩子带进队列
		if (front->left)
			QueuePush(&q, front->left);
		if (front->right)
			QueuePush(&q, front->right);
	}
	printf("\n");
	QueueDestroy(&q);
}


// 判断二叉树是否是完全二叉树
bool BinaryTreeComplete(BTNode* root)
{
	//层序遍历
	Queue q;
	QueueInit(&q);
	QueuePush(&q, root);
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);

		if (front == NULL)
		{
			break;
		}
		else
		{
			//孩子带进队列，空的也要带
			QueuePush(&q, front->left);
			QueuePush(&q, front->right);
		}

	}

	// 遇到空了以后，检查队列中剩下的节点
	// 1、剩下全是空，则是完全二叉树
	// 2、剩下存在非空，则不是完全二叉树
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);

		if (front)
		{
			QueueDestroy(&q);
			return false;
		}
	}

	QueueDestroy(&q);
	return true;
}
int BinaryTreeSize(BTNode* root)
{
	//结点个数 = 左子树的结点个数 + 右子树的结点个数 + 根结点
	return root == NULL ? 0 :
		BinaryTreeSize(root->left)
		+ BinaryTreeSize(root->right)
		+ 1;
}

int BinaryTreeLeafSize(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}

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

	return BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);
}


int BinaryTreeLevelKSize(BTNode* root, int k)
{
	/*if (k < 1)
	{
	return 0;
	}*/
	assert(k >= 1);

	if (root == NULL)
	{
		return 0;
	}

	if (k == 1)
	{
		return 1;
	}

	// root不等空，k也不等于1，说明root这颗树的第k节点在子树里面
	// 转换成求左右子树的第k-1等的节点数量
	return BinaryTreeLevelKSize(root->left, k - 1)
		+ BinaryTreeLevelKSize(root->right, k - 1);
}


int BinaryTreeDepth(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}

	//return BinaryTreeDepth(root->left) > BinaryTreeDepth(root->right) ? BinaryTreeDepth(root->left) + 1 : BinaryTreeDepth(root->right) + 1;
	//会有大量的计算
	int leftDepth = BinaryTreeDepth(root->left);
	int rightDepth = BinaryTreeDepth(root->right);

	return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
}

BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)
		return NULL;

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

	BTNode* leftRet = BinaryTreeFind(root->left, x);
	if (leftRet)
		return leftRet;

	BTNode* rightRet = BinaryTreeFind(root->right, x);
	if (rightRet)
		return rightRet;

	return NULL;//根结点,左子树,右子树中没有找到

}

void BinaryTreeDestory(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}

	BinaryTreeDestory(root->left);
	BinaryTreeDestory(root->right);
	free(root);
	//为了保证接口一致，注意需要在外边置空(形参改变不会影响实参）
	//BinaryTreeDestory(root);
	//root = NULL;
}

BinaryTree.h 

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


typedef char BTDataType;
typedef struct BinaryTreeNode
{
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
	BTDataType data;
}BTNode;

//二叉树的构建
BTNode* CreatBinaryTree();
//二叉树的扩容
BTNode* BuyNode(BTDataType x);
//二叉树前序遍历 
void PreOrder(BTNode* root);
// 二叉树中序遍历
void InOrder(BTNode* root);
// 二叉树后序遍历
void PostOrder(BTNode* root);
//层序遍历
void LevelOrder(BTNode* root);
//二叉树结点个数
int BinaryTreeSize(BTNode* root);
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root);
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k);
// 二叉树深度/高度
int BinaryTreeDepth(BTNode* root);
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
// 判断二叉树是否是完全二叉树
bool BinaryTreeComplete(BTNode* root);
// 二叉树销毁
void BinaryTreeDestory(BTNode* root);

Queue.c 

#define _CRT_SECURE_NO_WARNINGS 1

#include"Queue.h"

void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = NULL;
	pq->tail = NULL;
}

void QueueDestroy(Queue* pq)
{
	assert(pq);
	QueueNode* cur = pq->head;// QueueNode* cur =NULL
	while (cur != NULL)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}

	pq->head = pq->tail = NULL;
}
QueueNode* BuyQueueNode(QDataType x)
{
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QueueNode* newnode = BuyQueueNode(x);
	if (pq->head == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}
void QueuePrint(Queue* pq)
{
	QueueNode* cur = pq->head;
	while (cur)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");

}

void QueuePop(Queue* pq)
{
	assert(pq);
	//if (pq->head == NULL)
	//	return;
	assert(!QueueEmpty(pq));

	QueueNode* next = pq->head->next;
	free(pq->head);
	pq->head = next;
	if (pq->head == NULL)
	{
		pq->tail = NULL;
	}
}

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;
}

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}

int QueueSize(Queue* pq)
{
	assert(pq);

	int n = 0;
	QueueNode* cur = pq->head;
	while (cur)
	{
		++n;
		cur = cur->next;
	}

	return n;
}

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL;
}

Queue.h

#pragma once
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>
//前置声明
struct BinaryTreeNode;
typedef struct BinaryTreeNode* QDataType;

//链式结构：表示队列
typedef struct QueueNode
{
	struct QueueNode* next;//指针域
	QDataType data;//数据域
}QueueNode;

//队列链表的头指针与尾指针
typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;
}Queue;

//初始化队列
void QueueInit(Queue* pq);
//队尾入队列
void QueuePush(Queue* pq, QDataType x);
//队头出队列
void QueuePop(Queue* pq);
//获取队列头部元素
QDataType QueueFront(Queue* pq);
//获取队列队尾元素
QDataType QueueBack(Queue* pq);
//获取队列中有效元素个数
int QueueSize(Queue* pq);
//队列打印
void QueuePrint(Queue* pq);
//队列判空
bool QueueEmpty(Queue* pq);
//销毁队列
void QueueDestroy(Queue* pq);

Test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"BinaryTree.h"
#include"Queue.h"

int main()
{
	BTNode* root = CreatBinaryTree();
	//PreOrder(root);
	//printf("\n");
	//InOrder(root);
	//printf("\n");

	/*int n1 = 0;
	BinaryTreeSize(root, &n1);
	printf("TreeSize:%d\n", n1);

	int n2 = 0;
	BinaryTreeSize(root, &n2);
	printf("TreeSize:%d\n", n2);*/

	//printf("TreeSize:%d\n", BinaryTreeSize(root));
	//printf("TreeLeafSize:%d\n", BinaryTreeLeafSize(root));
	//printf("TreeLevelKSize:%d\n", BinaryTreeLevelKSize(root, 3));
	//printf("BinaryTreeDepth:%d\n", BinaryTreeDepth(root));
	printf("BinaryTreeComplete:%d\n", BinaryTreeComplete(root));

	//BinaryTreeLevelOrder(root);

	//BinaryTreeDestory(root);
	root = NULL;

	return 0;
}

xiguazkb123
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Lesson5--二叉树1
08-03
在数据结构中，树是一种非常重要的非线性数据结构，它由n（n>=0）个有限结点组成...在后续的课程中，还会深入探讨二叉树的遍历、查找、插入和删除等操作，以及特殊的二叉树结构如堆、平衡二叉树（如AVL树和红黑树）等。
比特数据结构课件-Lesson5-二叉树.pdf
07-07
在实际应用中，二叉树常用于实现二分查找、表达式树、堆排序等算法，它们提供了高效的数据访问和操作方式。例如，文件系统的目录结构通常采用类似二叉树的结构来组织，方便快速定位和访问文件。 总的来说，二叉树是...
说人话的01Trie（内有CF842D - Vitya and Strange Lesson题解）
weixin_39923085的博客
02-17 487
引言：    学习完trie树之后，我们知道可以快速处理一堆字符串，一堆数字呢？认识01Trie    既然trie树比较与字符串亲近，我们就想方设法地把数字转成字符串    没错！就是二进制！    看图，是不是瞬间秒懂了呢？               01Trie的应用    给出一个集合，多次询问，每次给出一个数，求这个数和集合中的数的异或的最大值。    根据位运算的性质，高位越大越好。...
Java考试题
热门推荐
06-12 5万+
一：单选题 1.下列哪一种叙述是正确的（D）A．abstract修饰符可修饰字段、方法和类B． 抽象方法的body部分必须用一对大括号{ }包住C． 声明抽象方法，大括号可有可无D．声明抽象方法不可写出大括号 2.如下代码public class Test {public int aMethod() {static int i = 0;i++;return i;}pu...
java基础002
u014163736的博客
04-29 4万+
试卷一2013年年底的时候，我看到了网上流传的一个叫做《Java面试题大全》的东西，认真的阅读了以后发现里面的很多题目是重复且没有价值的题目，还有不少的参考答案也是错误的，于是我花了半个月时间对这个所谓的《Java面试大全》进行了全面的修订并重新发布在我的CSDN博客。在修订的过程中，参照了当时JDK最新版本（Java 7）给出了题目的答案和相关代码，去掉了EJB 2.x、JSF等无用内容或过时内...
j2EE经典面试题
JAVA之迷
04-09 1万+
1. hibernate中离线查询去除重复项怎么加条件？ dc.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);   2. http协议及端口,smtp协议及端口 http：超文本传输协议 端口 80   smtp：简单邮件传输协议 端口25   3. 编写程序，完成文件复制功能       4. Servlet创建过程及
Chapter5-Src_KMP_树_二叉树_
10-03
二叉树常用于构建搜索树、堆、哈夫曼编码等。二叉树的遍历方法有前序遍历、中序遍历和后序遍历，这些都是程序员需要掌握的基本技能。在这个章节，你可能将学习到如何用代码实现这些操作，并理解它们的时间复杂性。 ...
数据结构第五章-树与二叉树 二叉树的C语言实现代码
05-22
该资源中为【数据结构】专栏——C语言实现二叉树篇章中涉及到的代码 代码中包含以下内容： 1. 二叉树相关头文件： - 二叉链表的数据类型声明 - 链队列结点类型声明 - 链队列类型声明 - 二叉树基本功能（二叉树的...
二叉树-基于Objective-C的完全二叉树实现的优先队列.zip
04-26
在本案例中，使用完全二叉树实现优先队列，通常会采用二叉堆的形式，即二叉树的父节点的优先级总是大于或等于其子节点。这样可以保证在任何时候，根节点都是优先级最高的元素，从而实现优先队列的基本操作，如插入...
数据结构 Java DS——链表部分经典题目 (1)
cjejwe的博客
07-09 671
笔者计划在暑假啃完JavaDS,Mysql的内容当然也会继续更这次给读者们分享的是链表的几个比较典型的题目,关于如何手搓一个链表,笔者还在筹划中,毕竟链表的种类也有那么多,但是在下面的题目中,只有单向链表。
数据结构和算法（0-1）----递归
yanminghe66666的博客
07-09 573
递归算法，爬楼梯等解法
数据结构--单链表实现
LH__1314的博客
07-05 1643
链表和顺序表都是线性表的一种，但是顺序表在物理结构和逻辑结构上都是连续的，但链表在逻辑结构上是连续的，而在物理结构上不一定连续；来看以下图片来认识链表与顺序表的差别这里以动态顺序表为例，和链表中的单链表对比一下动态顺序表单链表这里就可以很清晰的看到顺序表的底层其实就是一个数组，数据的是连续存储的（顺序表物理结构连续）；而链表它每一个数据都不是连续的（链表物理结构上不一定连续）。链表节点通过观察上图，我们会发现链表每一个节点都存放在数据和下一个节点的地址。
二分查找和斐波那契查找
weixin_50960004的博客
07-13 148
表面上看，后一调整存在风险，此时只能确定切分点arr[mid]＞target ，“贸然”地将arr[mi]排除在进一步的查找范围之外，似乎可能因遗漏这些元素，而导致本应成功的查找以失败告终。也就是说，无论朝哪个方向深入，都只需做1次元素的大小比较，其二，统一沿两个方向深入所需要执行的比较次数，比如都统一为一次。在有序向量中的查找，遇到重复的元素时会返回秩最大的那个，上述查找无法实现这个功能，因此加以改进。所以这样的话，想进入左半区间，进行一次比较，想进入右半区间，会进行两次比较，右侧比较会多。
5Python的Pandas：数据结构
最新发布
XiaoCai
07-13 229
Pandas是基于强大的NumPy库开发的，它继承了NumPy中的一些数据结构，也继承了NumPy的高效计算特性。
Redis 底层数据结构
xsgnzb的专栏
07-09 375
是列表和哈希表底层的实现之一，当只包含数字和短的字符串时，使用这个结构。由压缩列表和节点构成。压缩链表包含字节大小、尾指针偏移量、节点个数、节点列表、结束标识。编码类型包括int16、int32、int64，元素数组里的类型和编码类型相同。是有序集合的底层实现之一，由跳跃表和跳跃表节点组成。当新元素比元素数组里存放的类型比大时，会进行类型升级，重新分配空间和排序。跳跃表和平衡数的区别是，跳跃表查询复杂度平均跟平衡树一样是logn，最差是n²，但是它的实现很简单。上个节点的长度是动态的，分为1字节和5字节。
数据结构之链表详解及示例（C，C#，C++）
qq_35320456的博客
07-13 693
链表是一种灵活且强大的数据结构，适用于需要频繁插入和删除操作的场景。本文通过C、C#、C++三种语言展示了链表的基本操作，帮助读者理解链表的工作原理。在实际应用中，应根据具体需求选择合适的链表变种，如单向链表、双向链表或循环链表。掌握链表是成为优秀程序员的必经之路。
PHP数据结构之队列
likeshopgood的博客
07-09 444
队列是数据结构中的重要组成部分，尤其在多线程处理、任务调度和消息队列系统中发挥着关键作用。关于我们本文由ChatMoney团队出品，ChatMoney专注于AI应用落地与变现，我们提供全套、持续更新的AI源码系统与可执行的变现方案，致力于帮助更多人利用AI来变现，欢迎进入ChatMoney获取更多AI变现方案！
数据结构 —— 最小生成树
qq_67693066的博客
07-05 1160
数据结构 —— 最小生成树
树和二叉树的转换代码python_Python - 将n-ary树转换为二叉树
05-18
以下是将n-ary树转换为二叉树的Python代码： ```python class TreeNode: def __init__(self, val): self.val = val self.left = None self.right = None class Node: def __init__(self, val, children): self.val = val self.children = children def nary_to_binary(root): if not root: return None node = TreeNode(root.val) if len(root.children) > 0: node.left = nary_to_binary(root.children[0]) curr = node.left for i in range(1, len(root.children)): curr.right = nary_to_binary(root.children[i]) curr = curr.right return node ``` 其中，`TreeNode`表示二叉树节点，`Node`表示n-ary树节点。 我们先根据n-ary树的根节点创建二叉树的根节点，并将其值设为根节点的值。然后，我们判断根节点是否有子节点。如果有，我们将第一个子节点转换为二叉树节点，并将其设置为二叉树节点的左子树。接下来，我们遍历所有的子节点，将它们转换为二叉树节点，并将它们作为当前节点的右子树。最后，我们返回根节点的二叉树表示。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值