树与二叉树（数与二叉树概念结构分析，顺序、链式结构二叉树结构及代码实现，堆结构与代码实现，递归、非递归遍历二叉树代码实现）

最新推荐文章于 2021-11-15 17:56:39 发布

根号二点五

最新推荐文章于 2021-11-15 17:56:39 发布

阅读量326

点赞数 2

分类专栏：数据结构学习总结类

本文链接：https://blog.csdn.net/qq_44759710/article/details/104493926

版权

学习总结类同时被 2 个专栏收录

74 篇文章 0 订阅

订阅专栏

数据结构

19 篇文章 0 订阅

订阅专栏

树概念及结构

定义

树是一种非线性的数据结构，它是由 n（n>=0）个有限结点组成一个具有层次关系的集合。它具有以下的特点：每个结点有零个或多个子结点；没有父结点的结点称为根结点；每一个非根结点有且只有一个父结点；除了根结点外，每个子结点可以分为多个不相交的子树

其他概念

节点的度：一个节点含有的子树的个数称为该节点的度；如图：A的为6
叶节点或终端节点：度为0的节点称为叶节点；如图：B、C、H、I…等节点为叶节点
非终端节点或分支节点：度不为0的节点；如图：D、E、F、G…等节点为分支节点
双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；如图：A是B的父节点
孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；如图：B是A的孩子节点
兄弟节点：具有相同父节点的节点互称为兄弟节点；如图：B、C是兄弟节点
树的度：一棵树中，最大的节点的度称为树的度；如图：树的度为6
节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
树的高度或深度：树中节点的最大层次；如图：树的高度为4
堂兄弟节点：双亲在同一层的节点互为堂兄弟；如图：H、I互为兄弟节点
节点的祖先：从根到该节点所经分支上的所有节点；如图：A是所有节点的祖先
子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如图：所有节点都是A的子孙
森林：由m（m>=0）棵互不相交的树的集合称为森林；
在这里插入图片描述

区分树

子树不相交
除了根节点，每个节点有且仅有一个父节点
一棵有 N 个节点的树有 n - 1 条边

树的表示

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

举例如下：
在这里插入图片描述

二叉树概念及结构

定义

一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成

特点

每个结点最多有两棵子树，即二叉树不存在度大于 2 的结点
二叉树的子树有左右之分，其子树的次序不能颠倒

特殊的二叉树

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

二叉树的存储结构

二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构

顺序结构

顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。只有堆才会使用数组来存储，二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树在这里插入图片描述

链式存储

链式存储结构是，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结
点的存储地址。链式结构又分为二叉链和三叉链，高阶数据结构如红黑树等会用到三叉链在这里插入图片描述

链式结构代码表示

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

二叉树的顺序结构实现

我们通常把堆(一种二叉树)使用顺序结构的数组来存储

堆的概念及结构

定义

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

性质

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

堆的实现

堆向下调整算法

从根节点开始的向下调整算法可以把它调整成一个小堆。向下调整算法有一个前提：左右子树必须是一个堆，才能调整
在这里插入图片描述

堆的创建

从倒数的第一个非叶子节点的子树开始调整，一直调整到根节点的树，就可以调整成堆

初始化堆
从叶子节点向上，将更大的子节点与父亲节点比较后，若子节点更大，则与父亲节点交换，一直向上，直到根节点，这样根节点的数为最大的数
再依次处理根节点的子节点，以此类推，最终完成大堆的构造

堆的插入

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

堆的删除

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

堆排序

将大顶堆调整为小顶堆

将最后一个节点与根结点交换位置，换下来的根节点不进行排序操作，位置固定，从堆顶往下调整为大顶堆
继续将最后一个节点与根结点交换位置，新换下来的根节点依然不进行排序操作，位置固定，并从堆顶往下调整为大顶堆
重复以上步骤，直至只剩根节点即获得小根堆

堆的代码

在进行代码编写前，我们需要明确以下几个问题：

堆：
逻辑结构：完全二叉树
物理结构：顺序表

父子节点：
子节点：2*父节点+1，2*父节点+2
父节点：（子节点-1）/2

堆中最后一个非叶子节点：（n-2）/2

向下调整：建堆，Pop
向上调整：Push

Pop：Swap（0，size-1）--->尾删size-1--->向下调整
Push：尾插（size）--->向上调整

建栈：for：最后一个非叶子节点~0      向下调整
应用场景：排序，Top K
堆排序：Swap（0，size-1）--->向下调整      N * logN + N ~ N 
    升序：大堆--->向下调整
    降序：小堆

头文件

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include<malloc.h>
#include<assert.h>
typedef int HPDataType;
typedef struct Heap
{
	HPDataType* _a;
	int _size;
	int _capacity;
}Heap;
void HeapInit(Heap* hp, HPDataType* a, int n);
void HeapInit(Heap* hp);
void ShiftDown(HPDataType* a, int n, int root);
void HeapDestory(Heap* hp);
void HeapPush(Heap* hp, HPDataType x);
void HeapPop(Heap* hp);
HPDataType HeapTop(Heap* hp);
int HeapSize(Heap* hp);
int HeapEmpty(Heap* hp);
// 堆排序
void HeapSort(int* a, int n);
void TestHeap();

源文件

#include "Heap.h"
//大堆
void HeapInit(Heap* hp, HPDataType* a, int n)
{
	assert(hp && a);
	int i;
	hp->_a = (HPDataType*)malloc(sizeof(HPDataType)* n);
	for (i = 0; i < n; ++i)
	{
		hp->_a[i] = a[i];
	}
	for (i = (n - 2) / 2; i >= 0; --i)
	{
		ShiftDown(hp->_a, n, i);
	}
	hp->_size = hp->_capacity = n;
}

void HeapEmptyInit(Heap* hp)
{
	assert(hp);
	hp->_a = NULL;
	hp->_capacity = hp->_size = 0;
}

void Swap(HPDataType* a, HPDataType* b)
{
	HPDataType tmp = *a;
	*a = *b;
	*b = tmp;
}

//向上调整
void ShiftUp(HPDataType* a, int n, int child)
{
	assert(a);
	int parent = (child - 1) / 2;
	while (parent >= 0)
	{
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
			break;
	}
}

//向下调整
void ShiftDown(HPDataType* a, int n, int root)
//最后一个非叶子结点索引：(n-2)/2
{
	assert(a);
	int parent = root;
	int child = 2 * parent + 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 = 2 * parent + 1;
		}
		else
		{
			//以父亲为根的子树已经是一个大堆，结束调整
			break;
		}
	}
}

void HeapDestory(Heap* hp)
{
	assert(hp);
	if (hp->_a)
	{
		free(hp->_a);
		hp->_a = NULL;
		hp->_capacity = hp->_size = 0;
	}
}

void HeapPush(Heap* hp, HPDataType x)
{
	assert(hp);
	if (hp->_size == hp->_capacity)
	{
		int newC = hp->_capacity == 0 ? 10 : 2 * hp->_capacity;
		hp->_a = (HPDataType*)realloc(hp->_a, newC * sizeof(HPDataType));
		hp->_capacity = newC;
	}
	hp->_a[hp->_size] = x;
	++hp->_size;
	ShiftUp(hp->_a, hp->_size, hp->_size - 1);
}

int HeapEmpty(Heap* hp)
{
	assert(hp);
	if (hp->_size == 0)
		return 1;
	else
		return 0;
}

void HeapPop(Heap* hp)
{
	assert(hp);
	if (HeapEmpty(hp) == 0)
	{
		Swap(&hp->_a[0], &hp->_a[hp->_size - 1]);
		--hp->_size;
		ShiftDown(hp->_a, hp->_size, 0);
	}
}

HPDataType HeapTop(Heap* hp)
{
	assert(hp && hp->_size);
	return hp->_a[0];
}

int HeapSize(Heap* hp)
{
	assert(hp);
	return hp->_size;
}

// 堆排序
void HeapSort(int* a, int n)
{
	//改成小堆
	assert(a);
	int i;
	for (i = (n - 2) / 2; i >= 0 ; i--)
	{
		ShiftDown(a, n , i);
	}
	while (n > 1)
	{
		Swap(&a[0], &a[n - 1]);
		ShiftDown(a, n - 1, 0);
		n--;
	}
}

void HeapPrint(Heap* hp)
{
	assert(hp);
	for (int i = 0; i < hp->_size; ++i)
	{
		printf("%d ", hp->_a[i]);
	}
	printf("\n");
}

void TestHeap()
{
	Heap hp;
	HeapEmptyInit(&hp);
	HeapPush(&hp, 1);
	HeapPush(&hp, 8);
	HeapPush(&hp, 5);
	HeapPush(&hp, 7);
	HeapPush(&hp, 6);
	HeapPush(&hp, 3);
	HeapPush(&hp, 9);
	HeapPush(&hp, 5);
	HeapPrint(&hp);
	HeapPop(&hp);
	HeapPrint(&hp);
	HeapPop(&hp);
	HeapPrint(&hp);
	HeapPop(&hp);
	HeapPrint(&hp);
	HeapPop(&hp);
	HeapPrint(&hp);
}

void TestHeapSort()
{
	int a[] = { 1, 5, 3, 8, 7, 6 };
	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");
}

int main()
{
	//TestHeap();
	TestHeapSort();
	return 0;
}

二叉树链式结构实现

二叉树链式结构的遍历

沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问题。遍历是二叉树上最重要的运算之一，是二叉树上进行其它运算之基础

遍历方式

前序/中序/后序的递归结构遍历

NLR：前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前
LNR：中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）
LRN：后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后

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

二叉树结构及遍历代码的实现

非递归遍历与递归遍历的实现

非递归遍历需要借助队列和栈的结构特点实现
这里我们不再提供栈和队列的接口，想用参考这两篇博客：
队列的实现与运用
 栈的实现与运用
另外：
头文件：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef char BTDataType;
typedef struct BinaryTreeNode
{
	BTDataType _data;
	struct BinaryTreeNode* _left;
	struct BinaryTreeNode* _right;
}BTNode;
// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi);
void BinaryTreeDestory(BTNode** root);
int BinaryTreeSize(BTNode* root);
int BinaryTreeLeafSize(BTNode* root);
int BinaryTreeLevelKSize(BTNode* root, int k);
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
// 遍历
void BinaryTreePrevOrder(BTNode* root);
void BinaryTreeInOrder(BTNode* root);
void BinaryTreePostOrder(BTNode* root);

// 非递归遍历
// 层序遍历
void BinaryTreeLevelOrder(BTNode* root);

void BinaryTreePrevOrderNonR(BTNode* root);
void BinaryTreeInOrderNonR(BTNode* root);
void BinaryTreePostOrderNonR(BTNode* root);

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

源文件

#include "BinaryTree.h"

BTNode* BinaryTreeCreate(BTDataType* a, int* pi)
{
	if (a[*pi] != '#')
	{
		BTNode* root = (BTNode*)malloc(sizeof(BTNode));
		root->_data = a[*pi];
		++(*pi);
		root->_left = BinaryTreeCreate(a, pi);
		++(*pi);
		root->_right = BinaryTreeCreate(a, pi);
	}
	else
		return NULL;
}

void BinaryTreeDestory(BTNode** root)
{
	BTNode* curRoot = *root;
	if (curRoot)
	{
		BinaryTreeDestory(&curRoot->_left);
		BinaryTreeDestory(&curRoot->_right);
		free(curRoot);
		* root = NULL;
	}
}

int BinaryTreeSize(BTNode* root)
{
	if (root == NULL)
		return 0;
	return BinaryTreeLeafSize(root->_left) + BinaryTreeLeafSize(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->_left);
}

//第K层的节点数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
	if (root == NULL)
		return 0;
	if (root->_left == NULL && root->_right == NULL)
		return 1;
	return BinaryTreeLevelKSize(root->_left, k - 1) + BinaryTreeLevelKSize(root->_right, k - 1);
}

BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	BTNode* ret;
	if (root->_data == x)
		return root;
	ret = BinaryTreeFind(root->_left, x);
	if (ret)
		return ret;
	ret = BinaryTreeFind(root->_right, x);
	if (ret)
		return ret;
	return NULL;
}

// 先序遍历递归
void BinaryTreePrevOrder(BTNode* root)
{
	if (root)
	{
		printf("%c ", root->_data);
		BinaryTreePrevOrder(root->_left);
		BinaryTreePrevOrder(root->_right);
	}
	else
		printf("# ");
}

// 中序遍历递归
void BinaryTreeInOrder(BTNode* root)
{
	if (root)
	{
		BinaryTreeInOrder(root->_left);
		printf("%c ", root->_data);
		BinaryTreeInOrder(root->_right);
	}
	else
		printf("# ");
}

// 后序遍历递归
void BinaryTreePostOrder(BTNode* root)
{
	if (root)
	{
		BinaryTreePostOrder(root->_left);
		BinaryTreePostOrder(root->_right);
		printf("%c ", root->_data);
	}
	else
		printf("# ");
}

// 非递归遍历
// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
		QueuePush(&q, root);
	while (QueueEmpty(&q) == 0)
	{
		BTNode* front = QueueFront(&q); 
		QueuePop(&q);
		printf("%d ", front->_data);
		if (front->_left)
			QueuePush(&q, front->_left);
		if (front->_right)
			QueuePush(&q, front->_right);
	}
	printf("\n");
}

// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
		QueuePush(&q, root);
	while (QueueEmpty(&q) == 0)
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		if (front)
		{
			QueuePush(&q, front->_left);
			QueuePush(&q, front->_right);
		}
		else
			break;
	}
	while (QueueEmpty(&q) == 0)
	{
		BTNode* front = QueueFront(&q);
		if (front)
		{
			QueueDestroy(&q);
			return 0;
		}
		QueuePop(&q);
	}
	return 1;
}

// 先序遍历非递归
void BinaryTreePrevOrderNonR(BTNode* root)
{
	BTNode* cur = root;
	BTNode* top;
	Stack st;
	StackInit(&st);
	while (cur || StackEmpty(&st) == 0)
	{
		while (cur)
		{
			printf("%c ", cur->_data);
			StackPush(&st, cur);
			cur = cur->_left;
		}
		top = StackTop(&st);
		StackPop(&st);
		cur = top->_right;
	}
	printf("\n");
}

// 中序遍历非递归
void BinaryTreeInOrderNonR(BTNode* root)
{
	BTNode* cur = root;
	BTNode* top,* prev;
	Stack st;
	StackInit(&st);
	while (cur || StackEmpty(&st) == 0)
	{
		while (cur)
		{
			StackPush(&st, cur);
			cur = cur->_left;
		}
		top = StackTop(&st);
		printf("%c ", top->_data);
		StackPop(&st);
		cur = top->_right;
	}
	printf("\n");
}

// 后序遍历非递归
void BinaryTreePostOrderNonR(BTNode* root)
{
	BTNode* cur = root;
	BTNode* top,* prev;
	Stack st;
	StackInit(&st);
	while (cur || StackEmpty(&st) == 0)
	{
		if (cur)
		{
			StackPush(&st, cur);
			cur = cur->_left;
		}
		top = StackTop(&st);
		if (top->_right == NULL || top->_right == prev)
		{
			printf("%c ", top->_data);
			StackPop(&st);
			prev = top;
		}
		else
			cur = top->_right;
	}
	printf("\n");
}

void TestBinaryTree()
{
	int i = 0;
	char a[] = { 'A', 'B', 'D', '#', '#', 'E', '#', 'H', '#', '#', 'C', 'F', '#', '#', 'G', '#', '#' };
	BTNode* root = BinaryTreeCreate(a, &i);
	BinaryTreePrevOrder(root);
	printf("\n");
	BinaryTreePrevOrder(root);
	printf("\n");
	BinaryTreePrevOrder(root);
	printf("\n");
	BinaryTreeDestory(&root);
	i = BinaryTreeLeafSize(root);
	i = BinaryTreeLevelKSize(root, 1);
}

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