C语言数据结构-二叉树的入门

文章目录

0 碎碎念
1 二叉树的概念和结构
- 1.1 概念和特点
- 1.2 结构
- 1.3 特殊的二叉树
- 1.4 二叉树的存储与性质
- 1.5 前序、中序和后序
2 简单二叉树的实现
- 2.1 定义数据结构类型
- 2.2 前序、中序和后序接口的实现
- 2.3 二叉树中节点的个数
- 2.4 叶子节点的个数
3 完整代码块
- 3.1 BinaryTree.h
- 3.2 BinaryTree.c
- 3.3 test.c

0 碎碎念

这是初学二叉树的第一节，难度不大。
本不想再记录的，毕竟刚刚学二叉树概念还是简单的。
但是想到后续难度起来了。
读者碰到难题不理解了，是不是正好可以看看笔者前面写的简单入门？？
嘿嘿嘿！！！

1 二叉树的概念和结构

1.1 概念和特点

概念：一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。
特点1：每个结点最多有两棵子树，即二叉树不存在度大于2的结点。
特点2：二叉树的子树有左右之分，其子树的次序不能颠倒。

1.2 结构

现实中的二叉树

数据结构中的二叉树

1.3 特殊的二叉树

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

完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对
于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号
从1至n的结点一一对应时称之为完全二叉树。要注意的是满二叉树是一种特殊的完全二叉
树。

1.4 二叉树的存储与性质

二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构。
顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。而现实中使用中只有堆才会使用数组来存储，二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。
二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址。链式结构又分为二叉链和三叉链，当前我们学习中一般都是二叉链，红黑树等会用到三叉链。

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

性质

若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有2^(i-1) 个结点.
若规定根节点的层数为1，则深度为h的二叉树的最大结点数是2^h- 1.
对任何一棵二叉树, 如果度为0其叶结点个数为 n0, 度为2的分支结点个数为 n2,则有n0＝n2＋1
若规定根节点的层数为1，具有n个结点的满二叉树的深度，h=LogN

1.5 前序、中序和后序

二叉树

前序（先根）：单个节点按这样的顺序:根左子树右子树
从根节点开始，一直向左遍历，知道为空再找该节点的兄弟右节点，然后父节点的兄弟右节点。
A B D NULL NULL E NULL NULL C NULL NULL
中序（中根）：单个节点按这样的顺序:左子树根右子树
左子树最左边最底层的左节点开始，其父节点，其兄弟右节点，其父节点的父节点……
NULL D NULL B NULL E NULL A NULL C NULL
后序（后根）：单个节点按这样的顺序:左子树右子树根
左子树最左边最底层的左节点开始，其兄弟右节点，其父节点，其父节点的兄弟右节点……
NULL NULL D NULL NULL E B NULL NULLL C A

在这里插入图片描述

2 简单二叉树的实现

二叉树

2.1 定义数据结构类型

//定义数据结构类型
typedef char BTDataType;
typedef struct BinaryTreeNode
{
	BTDataType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;

2.2 前序、中序和后序接口的实现

//前序
void PrevOrder(BTNode* root)
{
	if (root == NULL) {
		printf("NULL ");
		//printf("");
		return;
	}

	printf("%c ", root->data);
	PrevOrder(root->left);
	PrevOrder(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);
}

在这里插入图片描述

2.3 二叉树中节点的个数

注意函数的返回类型！
注意函数的返回类型！
注意函数的返回类型！
1 三目表示式：root是空的话，节点数0，否则展开左子树+右子树+root(1)

//二叉树中节点的个数
int TreeSize(BTNode* root)
{
	return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
}

2 递归思想

//这里采用全局变量size，否则TreeSize2函数多次使size归零
int size = 0;
int TreeSize2(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}
	else
	{
		size++;
	}
	TreeSize2(root->left);
	TreeSize2(root->right);
	return size;
}

3 size放函数里面，指针形式，这样封装健壮性就有了

void TreeSize3(BTNode* root, int* psize)
{
	if (root == NULL)
	{
		return;
	}
	else
	{
		++(*psize);
	}
	TreeSize3(root->left, psize);
	TreeSize3(root->right, psize);
}

2.4 叶子节点的个数

首先想想出现叶子节点的情况，左右子节点为空

//叶子节点的个数
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);
}

3 完整代码块

3.1 BinaryTree.h

#pragma once
#include<stddef.h>
#include<stdio.h>
#include<stdlib.h>
//定义数据结构类型
typedef char BTDataType;
typedef struct BinaryTreeNode
{
	BTDataType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;

//前序
void PrevOrder(BTNode* root);

//中序
void InOrder(BTNode* root);

//后序
void PostOrder(BTNode* root);

//二叉树中节点的个数
int TreeSize(BTNode* root);
int TreeSize2(BTNode* root);
void TreeSize3(BTNode* root, int* psize);

//叶子节点的个数
int TreeLeafSize(BTNode* root);

3.2 BinaryTree.c

#include"BinaryTree.h"
//前序
void PrevOrder(BTNode* root)
{
	if (root == NULL) {
		printf("NULL ");
		//printf("");
		return;
	}

	printf("%c ", root->data);
	PrevOrder(root->left);
	PrevOrder(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);
}

//二叉树中节点的个数
int TreeSize(BTNode* root)
{
	return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
}

//这里采用全局变量size，否则TreeSize2函数多次使size归零
int size = 0;
int TreeSize2(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}
	else
	{
		size++;
	}
	TreeSize2(root->left);
	TreeSize2(root->right);
	return size;
}

void TreeSize3(BTNode* root, int* psize)
{
	if (root == NULL)
	{
		return;
	}
	else
	{
		++(*psize);
	}
	TreeSize3(root->left, psize);
	TreeSize3(root->right, psize);
}

//叶子节点的个数
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);
}

3.3 test.c

#include"BinaryTree.h"
int main()
{
	//定义二叉树的结构
	BTNode* A = (BTNode*)malloc(sizeof(BTNode));
	A->data = 'A';
	A->left = NULL;
	A->right = NULL;

	BTNode* B = (BTNode*)malloc(sizeof(BTNode));
	B->data = 'B';
	B->left = NULL;
	B->right = NULL;

	BTNode* C = (BTNode*)malloc(sizeof(BTNode));
	C->data = 'C';
	C->left = NULL;
	C->right = NULL;

	BTNode* D = (BTNode*)malloc(sizeof(BTNode));
	D->data = 'D';
	D->left = NULL;
	D->right = NULL;

	BTNode* E = (BTNode*)malloc(sizeof(BTNode));
	E->data = 'E';
	E->left = NULL;
	E->right = NULL;

	A->left = B;
	A->right = C;
	B->left = D;
	B->right = E;

	PrevOrder(A);
	printf("\n");
	InOrder(A);
	printf("\n");
	PostOrder(A);
	printf("\n");
	
	printf("TreeSize = %d \n", TreeSize(A));
	printf("TreeSize = %d \n", TreeSize(B));
	printf("TreeSize2=%d ", TreeSize2(A));
	
	int  Size3 = 0;
	TreeSize3(A, &Size3);
	printf("TreeSize3=%d ", Size3);

	printf("TreeLeafSize=%d\n", TreeLeafSize(A));
	printf("TreeLeafSize=%d\n", TreeLeafSize(B));

	return 0;
}