二叉树进阶版（C）

已于 2023-10-25 22:41:50 修改
阅读量604 收藏
点赞数
分类专栏： 深度学习数据结构 文章标签： c语言 数据结构 开发语言
于 2023-08-02 10:49:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LHRan_ran_/article/details/132055197
版权

文章目录

1.树

1.1概念

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

  • 有一个特殊的结点，称为根结点，根节点没有前驱结点
  • 除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i
    <= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继
  • 树是递归定义的。
  • 树形结构中，子树之间不能有交集，否则就不是树形结构

1.2相关定义

在这里插入图片描述

  • 节点的度：一个节点含有的子树的个数称为该节点的度； 如上图：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）棵互不相交的树的集合称为森林；

1.3 表示（左孩子右兄弟）

在这里插入图片描述

在这里插入图片描述

2.二叉树

在这里插入图片描述
在这里插入图片描述

2.1概念

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

  1. 可以为空
  2. 由一个根节点加上两棵称为左子树和右子树的二叉树组成
  3. 二叉树不存在度大于2的结点
  4. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树
  5. 一棵有n个结点的二叉树 有n-1个分支 每一个分支是一个指针 n个结点共2*n个指针 即有n-1个有效指针 有n+1个无效指针
  6. [下述会证明]高度为h的完全二叉树的结点个数区间：【2^(h-1) ，2^h-1】 即2^(h-1) <= n <= 2^h-1 可推出h = 下取整[logn]+1;

2.2特殊的二叉树

在这里插入图片描述

1. 满二叉树：

每一个层的结点数都达到了最大值的二叉树。
如果一个二叉树的层数为K，且结点总数是 2^k-1 ，则它就是满二叉树。

2. 完全二叉树：

完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树引出来的。
对于深度为K结点为n的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。
前k-1层是满二叉树 ； 第k层不满且从左到右连续 ； 若第k层也满 则为满二叉树
满二叉树是一种特殊的完全二叉树。

2.3二叉树的性质

若规定根节点的层数为1

  1. 一棵非空二叉树的第i层上最多有 2^（i - 1） 个结点
  2. 深度为k的二叉树的最大结点数（即满二叉树）是 2^k - 1
  3. 对任何一棵二叉树, 度为0的叶结点个数为x0 , 度为2的分支结点个数为 x2,则x0 ＝ x2＋1（度为0的永远比度为2的多1个）
  4. 具有n个结点的满二叉树的深度，h=log2（n+1）
  5. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对
    于序号为i的结点有：

i=0，i为根节点编号，无双亲节点
i>0，i的父节点：(i-1)/2

2i+1<n，左孩子序号：2i+1（2i+1>=n无左孩子）
2i+2<n，右孩子序号：2i+2（2i+2>=n无右孩子）

  1. 高度为h的完全二叉树的结点个数区间：【2^(h-1) ，2^h-1】
    在这里插入图片描述

2.4练习

1. 某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（ 200 ）
A 不存在这样的二叉树
B 200
C 198
D 199
x0 ＝ x2＋1
2.下列数据结构中，不适合采用顺序存储结构的是（ A ）
A 非完全二叉树
B 堆
C 队列
D 栈
3.在具有 2n 个结点的完全二叉树中，叶子结点个数(即x0)为（ A ）
A n
B n+1
C n-1
D n/2
完全二叉树：前k-1层是满二叉树 ; 第k层不满且从左到右连续 

2n = x0 + x1 + x2
2n = x0 + x1 + x0 - 1 
2n = 2x0 + x1 - 1
x1为0/1   2n为整数 x1只能为1 ==》x0 = n
4.一棵完全二叉树的节点数为531个，那么这棵树的高度为（ B ）
A 11
B 10
C 8
D 12
法一：如果是满二叉树 h = 256 512 1024
                  2^  8   9   10
法二：利用结论【2^(h-1) ，2^h-1】
5.一个具有767个节点的完全二叉树，其叶子节点个数为（ B ）
A 383
B 384
C 385
D 386
完全二叉树：前k-1层是满二叉树 ; 第k层不满且从左到右连续 
767 = x0 + x1 + x2
767 = x0 + x1 + x0 - 1 
767 = 2x0 + x1 - 1
x1为0/1   767为奇数 x1只能为0 ==》x0 = 384

3.二叉树的存储结构

1. 顺序存储

顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，不是完全二叉树会有空
间浪费。二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。通常把堆(一种二叉树)用顺序结构的数组来存储，这里的堆是数据结构，操作系统虚拟进程地址空间中的堆是管理内存的一块区域分段。
在这里插入图片描述

2. 链式存储

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

4.完全二叉树的代码实现

4.1堆的介绍

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

1.堆的性质：

  1. 堆中某个节点的值总是>= 或 <=其父节点的值；
  2. 小根堆：子节点值>=父亲
  3. 大根堆：子节点值<=父亲
  4. 堆总是一棵完全二叉树。

2.堆的应用

1.堆排序： – O（N * logN）
2.topk问题
在这里插入图片描述

4.2堆的实现

1.Heap.h

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

typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}HP;

//交换
void Swap(HPDataType* p1, HPDataType* p2);

//打印
void HeapPrint(HP* php);

//上调
void AdjustUp(HPDataType* a, int child);

//下调
void AdjustDwon(HPDataType* a, int size, int parent);

//初始化
void HeapInit(HP* php);

//销毁
void HeapDestroy(HP* php);

//入堆
void HeapPush(HP* php, HPDataType x);

//出堆
void HeapPop(HP* php);

//判空
bool HeapEmpty(HP* php);

//取堆头
HPDataType HeapTop(HP* php);

//堆大小
int HeapSize(HP* php);

2.Heap.c



#include "Heap.h"

//交换
void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

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

//上调logN
void AdjustUp(HPDataType* a, int child)
{
	//定位父节点下标
	int parent = (child - 1) / 2;
	while (child > 0)
	{
	//	if (a[child] > a[parent])  //大堆
		if (a[child] < a[parent])  //小堆
		{
			//交换数据
			Swap(&a[child], &a[parent]);
			//交换后更新
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

//下调logN
void AdjustDwon(HPDataType* a, int size, int parent)
{
	//设左孩子较小
	int child = parent * 2 + 1;
	//当未达到堆末 进入循环
	while (child < size)
	{
		//确定real大孩子
	//	if (child + 1 < size && a[child + 1] > a[child])  //大堆
	
		//确定real小孩子
		if (child + 1 < size && a[child + 1] < a[child])  //小堆
		{
			++child;
		}
	//	if (a[parent] < a[child])  //大堆
		if (a[parent] > a[child])  //小堆
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

//初始化
void HeapInit(HP* php)
{
	assert(php);

	php->a = NULL;
	php->size = php->capacity = 0;
}

//销毁
void HeapDestroy(HP* php)
{
	assert(php); 

	free(php->a);
	php->a = NULL;
	php->size = php->capacity = 0;
}

//入堆
void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	if (php->size == php->capacity)
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newcapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}

		php->a = tmp;
		php->capacity = newcapacity;
	}

	php->a[php->size] = x;
	php->size++;
	//上调         插入的新数据的下标
	AdjustUp(php->a, php->size - 1);
}

//出堆
void HeapPop(HP* php)
{
	assert(php);
	assert(php->size > 0);

	//想要删除堆头 把堆头与堆末交换
	Swap(&(php->a[0]), &(php->a[php->size - 1]));
	//删除堆末 -- 原目标值(堆头)已被删除
	php->size--;
	//将原堆末(现堆头下调置适当位置)
	AdjustDwon(php->a, php->size, 0);
}

//取堆头
HPDataType HeapTop(HP* php)
{
	assert(php);
	assert(php->size > 0);

	return php->a[0];
}

//判空
bool HeapEmpty(HP* php)
{
	assert(php);

	return php->size == 0;
}

//堆大小
int HeapSize(HP* php)
{
	assert(php);

	return php->size;
}

3.test.c

#define _CRT_SECURE_NO_WARNINGS
#include"Heap.h"

//测试函数
void TestHeap()
{
	//创建
	HP hp;
	//初始化
	HeapInit(&hp);
	//入堆
	int a[] = { 27, 15, 19, 18, 28, 34, 65, 49, 25, 37 };
	for (int i = 0; i < sizeof(a) / sizeof(int); ++i)
	{
		HeapPush(&hp, a[i]);
	}
	///打印
	HeapPrint(&hp);
	//入堆 -- 打印
	HeapPush(&hp, 10);
	HeapPrint(&hp);
	//出堆 -- 打印
	HeapPop(&hp);
	HeapPrint(&hp); 
	HeapPop(&hp);
	HeapPrint(&hp);
}

4.3堆的应用

1.堆排序

1.1建堆时间复杂度（最优为下调N）
1.1.1下调O(N)

在这里插入图片描述

1.1.2 上调O(NlogN)

在这里插入图片描述

1.2代码实现

//堆排序1.0 升序<-->用<-->小堆 降序<-->用<-->大堆
//问题：
//1、需要有一个堆数据结构存在 才能创建堆对象
//2、在堆对象空间再创建一个数组 调整后回写 空间复杂度为 O(N)
void Low_HeapSort(int* a, int n)
{
	HP hp;
	HeapInit(&hp);
	for (int i = 0; i < n; ++i)
	{
		HeapPush(&hp, a[i]);
	}

	int i = 0;
	while (!HeapEmpty(&hp))
	{
		a[i++] = HeapTop(&hp);
		HeapPop(&hp);
	}
	HeapDestroy(&hp);
}
//堆排序2.0 升序<-->建<-->大堆 降序<-->建<-->大堆
void Plus_HeapSort(int* a, int n)
{
//一、建堆
上调或者下调一个结点的时间复杂度都是O(logN)
// 	1.0 上调建堆法 O(N*logN)
// 	将数组a传参后 假设原数组就是一颗树 只不过这棵树待调整
// 	上调法：遍历数组 从1到n-1 上调至合适位置
//  定位父节点下标 int parent = (child - 1) / 2 -->  i从1开始而非0
	
    /*
	for (int i = 1; i < n; ++i)
	{
		AdjustUp(a, i);
	}
    */
//  2.0 下调建堆法 O(N)
// 	将数组a传参后 假设原数组就是一颗树 只不过这棵树待调整
// 	下调法：遍历数组 叶子节点无孩子不用下调 
//          从倒数第一个非叶子节点开始遍历至根节点
// 	        倒数第一个非叶子节点：末节点的父亲
// 	        公式计算父节点下标 int parent = (child - 1) / 2
// 	        末节点下标：n - 1 - 1
//  设左孩子较小 int child = parent * 2 + 1;
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDwon(a, n, i);
	}
//二、排序(升序法：将大值一次排到尾部 建大堆-->根最大) O(N*logN)
	//定位末节点
	int end = n - 1;
	//排序 遍历已经调好位置的大堆
	while (end > 0)
	{
		//头尾交换(最大的值(根结点)与末节点的值交换)
		//下调
		Swap(&a[0], &a[end]);
		AdjustDwon(a, end, 0);
		//下标前移
		--end;
	}
}

//测试堆排序
void TestHeapSort()
{
	int a[] = { 27, 15, 19, 18, 28, 34, 65, 49, 25, 37 };
	Plus_HeapSort(a, sizeof(a) / sizeof(int));
	for (int i = 0; i < sizeof(a) / sizeof(int); i++)
	{
		printf("%d ", a[i]);
	}
}

int main()
{
	TestHeapSort();

	return 0;
}
1.3堆排序时间复杂度

堆排序时间复杂度 = 建堆 + 排序
= O(N) + O(N*longN)
= O(NlogN)

2.topk问题

2.1介绍及解决方式

介绍：
求数据结合中前K个最大的元素或者最小的元素
解决方式：
用堆来解决 基本思路：

  1. 思路一：O(N * logN)
    将N个数据进行排序 目前接触到的排序算法最优为堆排序
  2. 思路二：O(N + k * logN) 【N个数据建堆空间浪费巨大】
    将N个数据建成大堆 然后Top/Pop k次 时间复杂度 = 下调建大堆 + Top/Pop
  3. 思路三：O[K + (N-K) * logK] 【最优 时间上可能比二差点 但空间上效率提高】
    将N个数据前K个元素建堆：取前k个最大的元素–建小堆；取前k个最小的元素，建大堆
    用剩余的N-K个元素依次与堆顶元素比较，不满足则替换堆顶元素
    将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。
2.2代码举例
//打印Topk函数
void PrintTopK(int* a, int n, int k)
{
	// 1.下调建堆 -- 用前k个元素建堆
	
	//申请空间
	int* kHeap = (int*)malloc(sizeof(int) * k);
	assert(kHeap);
	//拷贝前k个
	for (int i = 0; i < k; ++i)
	{
		kHeap[i] = a[i];
	}
	//显示kHeap
	printf("kHeap的数据显示\n");
	for (int i = 0; i < k; ++i)
	{
		printf("%d ", kHeap[i]);
	}
	printf("\n");
	//下调建堆
	for (int i = (k - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDwon(kHeap, k, i); //此时AdjustDwon实现的是建小堆
	} 
	//显示kHeap
	printf("kHeap的数据显示\n");
	for (int i = 0; i < k; ++i)
	{
		printf("%d ", kHeap[i]);
	}
	printf("\n");

	// 2.访问数组a中n-k个元素 -- 依次与堆顶元素比较 -- 不满足则替换
	for (int j = k; j < n; ++j)
	{
		if (a[j] > kHeap[0])
		{
			kHeap[0] = a[j];
			AdjustDwon(kHeap, k, 0);
			printf("kHeap的数据显示\n");
			for (int i = 0; i < k; ++i)
			{
				printf("%d ", kHeap[i]);
			}
			printf("\n");
		}
	}
	//打印
	printf("kHeap的数据显示\n");
	for (int i = 0; i < k; ++i)
	{
		printf("%d ", kHeap[i]);
	}
	printf("\n");
}

//Topk测试函数
void TestTopk()
{
	//一、生成10个<=100的数
	int* a = (int*)malloc(sizeof(int) * 10);
	srand(time(0));
	for (int i = 0; i < 10; ++i)
	{
		a[i] = rand() % 100;
	}
	//将其中5个数修改成大于100的数
	a[6] = 100 + 6;
	a[4] = 100 + 9;
	a[8] = 100 + 2;
	a[2] = 100 + 1;
	a[0] = 100 + 4;
	//打印查看
	printf("a的数据显示\n");
	for (int i = 0; i < 10; ++i)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
	//检验
	PrintTopK(a, 10, 5);
}

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

5.普通二叉树的结构

5.1术语翻译

在这里插入图片描述

5.2层序遍历图解

在这里插入图片描述

5.3层序遍历底层

在这里插入图片描述

5.4判断是否为完全二叉树

在这里插入图片描述

5.5代码实现

在这里插入图片描述

1.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;
}QNode;

typedef struct Queue
{
	//int size;
	QNode* head;
	QNode* tail;
}Queue;

//初始化
void QueueInit(Queue* pq);

//销毁
void QueueDestroy(Queue* pq);

//入队
void QueuePush(Queue* pq, QDataType x);

//出队
void QueuePop(Queue* pq);

//取首
QDataType QueueFront(Queue* pq);

//取尾
QDataType QueueBack(Queue* pq);

//判空
bool QueueEmpty(Queue* pq);

//队列大小
int QueueSize(Queue* pq);

2.Queue.c

#include "Queue.h"

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

//销毁
void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}

	pq->head = pq->tail = NULL;
}

//入队
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;

	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}

//出队
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	// 1һڵ
	// 2ڵ
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
}

//取首
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;
}

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

//队列大小
int QueueSize(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	int size = 0;
	while (cur)
	{
		++size;
		cur = cur->next;
	}

	return size;
}

3.BinaryTree.c

#define _CRT_SECURE_NO_WARNINGS

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
#include"Queue.h"

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

//创建新结点
BTNode* CreatNode(BTDataType x)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	assert(node);

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

	return node;
}

//二叉树的销毁
void TreeDestroy(BTNode* root)
{
	if (root == NULL)
		return;
	TreeDestroy(root->left);
	TreeDestroy(root->right);
	free(root);
}

//自创二叉树
BTNode* CreatBinaryTree()
{
	BTNode* node1 = CreatNode(1);
	BTNode* node2 = CreatNode(2);
	BTNode* node3 = CreatNode(3);
	BTNode* node4 = CreatNode(4);
	BTNode* node5 = CreatNode(5);
	BTNode* node6 = CreatNode(6);

	node1->left = node2;
	node1->right = node4;
	node2->left = node3;
	node4->left = node5;
	node4->right = node6;

	return node1;
}

//前序遍历NLR
void PreOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("# ");
		return;
	}

	printf("%d ", root->data);
	PreOrder(root->left);
	PreOrder(root->right);
}

//中序遍历LNR
void InOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("# ");
		return;
	}

	InOrder(root->left);
	printf("%d ", root->data);
	InOrder(root->right);
}

//后序遍历LRN
void PostOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("# ");
		return;
	}

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

//层序遍历
void Level0rder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
	{
		QueuePush(&q, root);
	}

	while (!QueueEmpty(&q))
	{
		//front指向队头的数据  队头的数据是一个二叉树结点
		BTNode* front = QueueFront(&q);
		printf("%d ", front->data);
		//出队 队头的数据被pop 但是二叉树结点仍然存在
		QueuePop(&q);

		if (front->left)
		{
			QueuePush(&q, front->left);
		}
		if (front->right)
		{
			QueuePush(&q, front->right);
		}
	}
	printf("\n");
	QueueDestroy(&q);
}

//结点个数1.0--NLR
int count = 0;
void TreeSize1(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}

	++count;
	TreeSize1(root->left);
	TreeSize1(root->right);
}

//结点个数2.0--LRN
int TreeSize2(BTNode* root)
{
	return root == NULL ? 0 : TreeSize2(root->left) + TreeSize2(root->right) + 1;
}

//叶子结点数--LRN
int TreeLeafSize(BTNode* root)
{
	if (root == NULL)
		return 0;

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

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

//第k层结点个数--LRN
int TreeKLevel(BTNode* root, int k)
{
	assert(k >= 1);

	if (root == NULL)
		return 0;

	if (k == 1)
		return 1;

	return TreeKLevel(root->left, k - 1) + TreeKLevel(root->right, k - 1);
}

// 求二叉树深度--LRN
int TreeDepth(BTNode* root)
{
	if (root == NULL)
		return 0;

	int leftDepth = TreeDepth(root->left);
	int rightDepth = TreeDepth(root->right);

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

//查找目标结点--NLR
BTNode* TreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)
		return NULL;

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

	BTNode* ret1 = TreeFind(root->left, x);  if (ret1) return ret1;
	BTNode* ret2 = TreeFind(root->right, x); if (ret2) return ret2;

	return NULL;
}

//判断是否为完全二叉树
//性质：前k - 1层是满二叉树  第k层不满且从左到右连续
int TreeComplete(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
	{
		QueuePush(&q, root);
	}
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		if (front)
		{
			QueuePush(&q, front->left);
			QueuePush(&q, front->right);
		}
		else
		{
			break;
		}
	}
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		if (front)
		{
			QueueDestroy(&q);
			return false;
		}
	}
	QueueDestroy(&q);
	return true;
}

int main()
{
	//创建二叉树 
	BTNode* root = CreatBinaryTree();
	//NLR
	PreOrder(root);
	printf("\n");
	//LNR
	InOrder(root);
	printf("\n");
	//LRN
	PostOrder(root);
	printf("\n");

	//层序遍历
	printf("层序遍历的结果为：");
	Level0rder(root);

	//结点个数1.0
	count = 0;
	TreeSize1(root);
	printf("TreeSize:%d\n", count);

	//结点个数2.0
	printf("TreeSize:%d\n", TreeSize2(root));
	printf("TreeSize:%d\n", TreeSize2(root));

	//叶子结点数
	printf("LeafSize:%d\n", TreeLeafSize(root));

	//第k层结点个数
	printf("KLevelSize:%d\n", TreeKLevel(root, 1));
	printf("KLevelSize:%d\n", TreeKLevel(root, 2));
	printf("KLevelSize:%d\n", TreeKLevel(root, 3));
	printf("KLevelSize:%d\n", TreeKLevel(root, 4));
	
	// 求二叉树深度--LRN
	printf("此树深度为%d\n", TreeDepth(root));

	//查找值为x的结点
	int x = 1;
	BTNode* node = TreeFind(root, x);
	if (node)
	{
		printf("已找到--所在子树为：");
		PreOrder(node);
		printf("\n");
	}
	else
		printf("不存在值为%d的结点\n",x);

	//判断是否为完全二叉树
	 if(TreeComplete(root))
		 printf("此树为完全二叉树\n");
	 else
		 printf("此树非完全二叉树\n");

	//二叉树的销毁
	TreeDestroy(root);
	root = NULL;
	return 0;
}

5.6算法图解(递归)

阿猿收手吧！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
LeetCode 1379. 找出克隆二叉树中的相同节点（二叉树遍历）
12-21
请找出在树 cloned 中，与 target 相同 的节点，并返回对该节点的引用（在 C/C++ 等有指针的语言中返回 节点指针，其他语言返回节点本身）。 注意： 你 不能 对两棵二叉树，以及 target 节点进行更改。 只能 返回对...
高级进阶c语言教程..doc
05-10
高级进阶c语言教程 目录 1. C 语言中的指针和内存泄漏 5 2. C语言难点分析整理 10 3. C语言难点 18 4. C/C++实现冒泡排序算法 32 5. C++中指针和引用的区别 35 6. const char*, char const*, char*const的区别 36 7....
数据结构--二叉树进阶
平生的小铺子
08-20 399
因为我们之前在学习数据结构的时候使用的是C语言，但是并不是所有的数据结构都适合使用C语言学习，如今我们了解了C++的基础语法，具备了学习这些稍微难一点的数据结构的前提，所以我们再次回顾数据结构，使用C++这一更加先进的武器，来解决更加复杂的问题 二叉搜索树 二叉搜索树概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也
二叉树进阶
cefler的博客
10-24 217
二叉树进阶
二叉树进阶问题
weixin_51970219的博客
01-02 975
二叉树进阶问题 1. package bin_tree.leetcode; import java.util.LinkedList; import java.util.Queue; public class IsCompleteTree { public boolean isCompleteTree(TreeNode root) { if (root == null) { return true; } // 层序遍历判断二叉
C++进阶：二叉树进阶
qq_71925940的博客
04-28 333
二叉树在前面C数据结构阶段已经讲过，本节取名二叉树进阶是因为：1.先铺垫二叉搜索树，而二叉搜索树也是一种树形结构2.3.因此本节借二叉树搜索树，对二叉树部分进行收尾总结。，或者是具有以下性质的二叉树。
二叉树进阶面试题
shu__shu的博客
03-31 167
二叉树进阶题目记录实现二叉树的非递归 先序, 中序, 后序遍历二叉树的构建和遍历二叉树的分层遍历最近公共祖先二叉搜索树与双向链表 实现二叉树的非递归 先序, 中序, 后序遍历 非递归实现 二叉树的构建和遍历 在线OJ 题目描述:  编一个程序，读入用户输入的一串先序遍历字符串，根据此字符串建立一个二叉树（以指针方式存储）。 例如如下的先序遍历字符串： ABC##DE#G##F### 其中“#”表示的是空格，空格字符代表空树。建立起此二叉树以后，再对二叉树进行中序遍历，输出遍历结果。 import ja
【C++进阶】二叉树进阶
m0_60338933的博客
11-08 587
C++进阶二叉树详解，包含十道经典题目练习
【二叉树进阶】搜索二叉树（递归+非递归两种版本详解）
m0_70980326的博客
07-30 968
搜索二叉树详解：递归+非递归两种版本实现，画图讲解+完整代码
二叉树进阶题目(超详解)
庖丁解牛，恢恢乎游刃有余
12-24 1723
二叉树进阶的题目不一定更复杂，但一定更适合用C++去写。这里的题目用C语言去做会非常恶心。
数据结构 二叉树进阶面试题
weixin_48271092的博客
03-16 937
1、二叉树的构建及遍历：OJ链接 描述： 编一个程序，读入用户输入的一串先序遍历字符串，根据此字符串建立一个二叉树（以指针方式存储）。 例如如下的先序遍历字符串： ABC##DE#G##F### 其中“#”表示的是空格，空格字符代表空树。建立起此二叉树以后，再对二叉树进行中序遍历，输出遍历结果。 输入描述： 输入包括1行字符串，长度不超过100。 输出描述： 可能有多组测试数据，对于每组数据， 输出将输入字符串建立二叉树后中序遍历的序列，每个字符后面都有一个空格。 每个输出结果占一行。
基于左右旋平衡二叉树以及相关树的算法c源码+使用说明.zip
11-06
基于左右旋平衡二叉树以及相关树的算法c源码+使用说明.zip 二叉(平衡)查找树 一个可以自动生成图像的二叉查找树 ## Getting Started *bst* requires: * gcc * make * graphviz you can build *bst* from ...
c语言c++项目源代码_C语言10个数据结构课程设计实例二叉树建立遍历冒泡排序快速排序等.rar
03-27
这些项目源码不仅适合作为课程设计的参考，也适合有一定C语言基础的学习者进行进阶练习。通过实践这些实例，学习者可以更加深入地掌握数据结构的原理和应用技巧，为未来的学习和职业发展打下坚实的基础。
基于C语言实现的链表、栈、队列、排序算法以及二叉树源码(课程作业).zip
01-16
1.项目代码功能经验证ok，确保稳定可靠运行。欢迎下载使用！在使用过程中，如有问题或建议，请及时私信沟通，帮助解答。 ...基于C语言实现的链表、栈、队列、排序算法以及二叉树源码(课程作业).zip
标准C库打开创建文件
最新发布
qq_61391875的博客
05-22 232
fopen`是C标准函数，因此拥有良好的移植性；而`open`是UNIX系统调用，移植性有限。但如果你需要更底层的文件操作或与系统级别的 API 交互，那么使用。总的来说，如果你只需要简单地打开文件并进行读写操作，使用。
C语言从头学06——变量
m0_72128260的博客
05-15 368
变量可以理解为是一块内存的名字。通过名字可以获取、改变里面存储的值。由于值是变化的，所以称为变量。
【C语言】动态内存管理
2302_79846942的博客
05-15 971
包含头文件。开辟使用 malloc() 函数分配内存空间，并将返回的指针存储在一个指针变量中。开辟验证内存是否成功分配，即检查返回的指针是否为 NULL。如果是 NULL，则表示内存分配失败，可能是由于内存不足。使用分配的内存进行必要的操作。最后，在不再需要使用内存时，使用free() 函数释放内存并将其返回给系统。然后还要置为NULL最好一些要注意的malloc函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。
P2【练习力扣933】【数据结构】【队列queue】C++版
qq_50891451的博客
05-18 457
，范围是 [-2900,100]，返回 2。]，范围是 [-2999,1]，返回 1。]，范围是 [1,3001]，返回 3。]，范围是 [2,3002]，返回 3。类来计算特定时间范围内最近的请求。的调用都使用比之前更大的。
二叉树实现代码c语言
11-25
二叉树是一种非常常用的数据结构，它的实现代码在C语言中也是比较简单的。下面我用300字中文回答怎样在C语言中实现二叉树的代码。 首先，我们需要定义二叉树的结构体。一个二叉树的结点包含一个数据域和两个指针域...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿猿收手吧！

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值