文章目录
二叉树结构
二叉树的基本操作
// 通过前序遍历的数组"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);
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k);
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
// 二叉树前序遍历
void BinaryTreePrevOrder(BTNode* root);
// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root);
// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root);
// 层序遍历
void BinaryTreeLevelOrder(BTNode* root);
// 判断二叉树是否是完全二叉树
bool BinaryTreeComplete(BTNode* root);
//获取新节点
BTNode* BuyNode(BTDataType x);
//树的深度
int BinaryTreeDeep(BTNode* root);
二叉树的遍历
所谓遍历(Traversal)是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问 题。 遍历是二叉树上最重要的运算之一，是二叉树上进行其它运算之基础。
前序遍历
NLR：前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
详解：
由上面的解释可知前序遍历是先访问根再访问左子树最后访问右子树
访问左子树时先访问左子树根，再访问根的左右子树
左子树全部访问完后再去访问右子树
访问右子树时先访问右子树根，再访问根的左右子树
一层一层递归下去
最后就访问完毕
void BinaryTreePrevOrder(BTNode* root)
{
if (root == NULL)
{
printf("NULL ");
return;
}
printf("%c ", root->data);
BinaryTreePrevOrder(root->left);
BinaryTreePrevOrder(root->right);
}
A->B->D->NULL->NULL->NULL->C->E->NULL->NULL->F->NULL
中序遍历
LNR：中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
详解：
由上面的解释可知前序遍历是先访问左子树再访问根最后访问右子树
访问左子树时先访问左子树的左子树，再访问左子树的根，最后访问左子树的右子树
左子树全部访问完后再去访问右子树
访问右子树时先访问右子树的左子树，再访问右子树的根，最后访问右子树的右子树
一层一层递归下去
最后就访问完毕
void BinaryTreeInOrder(BTNode* root)
{
if (root == NULL)
{
printf("NULL ");
return;
}
BinaryTreeInOrder(root->left);
printf("%c ", root->data);
BinaryTreeInOrder(root->right);
}
NULL->D->NULL->B->NULL->A->NULL->E->NULL->C->NULL->F->NULL
后序遍历
LRN：后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。
详解：
由上面的解释可知前序遍历是先访问左子树再访问右子树最后访问根
访问左子树时先访问左子树的左子树，再访问左子树的右子树，最后访问左子树的根
左子树全部访问完后再去访问右子树
访问右子树时先访问右子树的左子树，再访问右子树的右子树，最后访问右子树的根
一层一层递归下去
最后就访问完毕
void BinaryTreePostOrder(BTNode* root)
{
if (root == NULL)
{
printf("NULL ");
return;
}
BinaryTreePostOrder(root->left);
BinaryTreePostOrder(root->right);
printf("%c ", root->data);
}
NULL->NULL->D->NULL->B->NULL->NULL->E->NULL->NULL->F->C->A
层序遍历
除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。设二叉树的根节点所在
层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。
用队列配合实现
先再队列中插入根节点
队列每出一个节点，如果它的左右孩子不为空就带入它的左右孩子
就这样循环下去直到队列为空，那么二叉树的所有节点一定都出列了
void BinaryTreeLevelOrder(BTNode* root)
{
if (root == NULL)
{
return;
}
Queue q;
QueueInit(&q);
QueuePush(&q, root);
while (!QueueEmpty(&q))
{
printf("%c ", QueueFront(&q)->data);
if (QueueFront(&q)->left)
QueuePush(&q, QueueFront(&q)->left);
if (QueueFront(&q)->right)
QueuePush(&q, QueueFront(&q)->right);
QueuePop(&q);
}
printf("\n");
QueueDestroy(&q);
}
A->B->C->D->NULL->E->F->NULL->NULL->NULL->NULL->NULL->NULL
节点的个数
二叉树节点个数
int BinaryTreeSize(BTNode* root)
{
return root == NULL ? 0 : BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1;
}
用递归从根开始遍历整个数的每个节点，不是空则返回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);
}
用递归从根开始遍历整个树的每个节点，判断每个节点是否有左右孩子，有则返回1
第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
if (root == NULL)
{
return 0;
}
if (k < 1)
{
return 0;
}
if (k == 1)
{
return 1;
}
return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);
}
用k控制递归遍历第k层节点，等于1且不等于空则返回1
树的深度和查找值为x的节点
树的深度
int BinaryTreeDeep(BTNode* root)
{
if (root == NULL)
{
return 0;
}
int leftret = BinaryTreeDeep(root->left);
int rightret = BinaryTreeDeep(root->right);
return leftret > rightret ? leftret + 1 : rightret + 1;
}
用递归分别计算左右子树的深度，最后返回左右子树的深度+1（根）
查找值为x的节点
用递归遍历所有节点，找到相同的就返回该节点的下标
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
if (root == NULL)
{
return NULL;
}
if (root->data == x)
{
return root;
}
BTNode* left = BinaryTreeFind(root->left, x);
if (left != NULL)
{
return left;
}
BTNode* right = BinaryTreeFind(root->right, x);
if (left != NULL)
{
return right;
}
return NULL;
}
遍历数组构建二叉树和判断是否是完全二叉树
遍历数组构建二叉树
先构建根节点
再构建根节点的左右节点
这样一层一层递归下去
BTNode* _BinaryTreeCreate(BTDataType* a,int* pi)
{
if (a[*pi] == '#')
{
(*pi)++;
return NULL;
}
BTNode* root = (BTNode*)malloc(sizeof(BTNode));
if (root == NULL)
{
printf("malloc fail");
exit(-1);
}
root->data = a[(*pi)++];
root->left = _BinaryTreeCreate(a, pi);
root->right = _BinaryTreeCreate(a, pi);
return root;
}
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi)
{
BTDataType* p = (BTDataType*)malloc(sizeof(BTDataType) * n);
if (a == NULL)
{
printf("malloc fail");
exit(-1);
}
p = a;
BTNode* root = _BinaryTreeCreate(p,pi);
return root;
}
判断是否是完全二叉树
先把根节点放入队列中
队列每出一个数，就带入它的左右孩子
等到遇到空的时候跳出去判断
如果是二叉树队列后全为空
如果不是二叉树队列后不全为空
bool BinaryTreeComplete(BTNode* root)
{
if (root == NULL)
{
return false;
}
Queue q;
QueueInit(&q);
QueuePush(&q, root);
while (!QueueEmpty(&q))
{
if (!QueueFront(&q))
{
break;
}
QueuePush(&q, QueueFront(&q)->left);
QueuePush(&q, QueueFront(&q)->right);
QueuePop(&q);
}
while (!QueueEmpty(&q))
{
if (QueueFront(&q))
{
QueueDestroy(&q);
return false;
}
QueuePop(&q);
}
QueueDestroy(&q);
return true;
}
二叉树销毁
void BinaryTreeDestory(BTNode* root)
{
if (root == NULL)
{
return;
}
BinaryTreeDestory(root->left);
BinaryTreeDestory(root->right);
free(root);
}
完整代码
BTree.h
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.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);
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k);
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
// 二叉树前序遍历
void BinaryTreePrevOrder(BTNode* root);
// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root);
// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root);
// 层序遍历
void BinaryTreeLevelOrder(BTNode* root);
// 判断二叉树是否是完全二叉树
bool BinaryTreeComplete(BTNode* root);
//获取新节点
BTNode* BuyNode(BTDataType x);
//树的深度
int BinaryTreeDeep(BTNode* root);
BTree.c
#include "BTree.h"
#include "Queue.h"
BTNode* BuyNode(BTDataType x)
{
BTNode* node = (BTNode*)malloc(sizeof(BTNode));
if (node == NULL)
{
printf("malloc fail");
exit(-1);
}
node->data = x;
node->left = node->right = NULL;
return node;
}
void BinaryTreePrevOrder(BTNode* root)
{
if (root == NULL)
{
printf("NULL ");
return;
}
printf("%c ", root->data);
BinaryTreePrevOrder(root->left);
BinaryTreePrevOrder(root->right);
}
void BinaryTreeInOrder(BTNode* root)
{
if (root == NULL)
{
printf("NULL ");
return;
}
BinaryTreeInOrder(root->left);
printf("%c ", root->data);
BinaryTreeInOrder(root->right);
}
void BinaryTreePostOrder(BTNode* root)
{
if (root == NULL)
{
printf("NULL ");
return;
}
BinaryTreePostOrder(root->left);
BinaryTreePostOrder(root->right);
printf("%c ", root->data);
}
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 (root == NULL)
{
return 0;
}
if (k < 1)
{
return 0;
}
if (k == 1)
{
return 1;
}
return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);
}
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
if (root == NULL)
{
return NULL;
}
if (root->data == x)
{
return root;
}
BTNode* left = BinaryTreeFind(root->left, x);
if (left != NULL)
{
return left;
}
BTNode* right = BinaryTreeFind(root->right, x);
if (left != NULL)
{
return right;
}
return NULL;
}
int BinaryTreeDeep(BTNode* root)
{
if (root == NULL)
{
return 0;
}
int leftret = BinaryTreeDeep(root->left);
int rightret = BinaryTreeDeep(root->right);
return leftret > rightret ? leftret + 1 : rightret + 1;
}
void BinaryTreeLevelOrder(BTNode* root)
{
if (root == NULL)
{
return;
}
Queue q;
QueueInit(&q);
QueuePush(&q, root);
while (!QueueEmpty(&q))
{
printf("%c ", QueueFront(&q)->data);
if (QueueFront(&q)->left)
QueuePush(&q, QueueFront(&q)->left);
if (QueueFront(&q)->right)
QueuePush(&q, QueueFront(&q)->right);
QueuePop(&q);
}
printf("\n");
QueueDestroy(&q);
}
bool BinaryTreeComplete(BTNode* root)
{
if (root == NULL)
{
return false;
}
Queue q;
QueueInit(&q);
QueuePush(&q, root);
while (!QueueEmpty(&q))
{
if (!QueueFront(&q))
{
break;
}
QueuePush(&q, QueueFront(&q)->left);
QueuePush(&q, QueueFront(&q)->right);
QueuePop(&q);
}
while (!QueueEmpty(&q))
{
if (QueueFront(&q))
{
QueueDestroy(&q);
return false;
}
QueuePop(&q);
}
QueueDestroy(&q);
return true;
}
void BinaryTreeDestory(BTNode* root)
{
if (root == NULL)
{
return;
}
BinaryTreeDestory(root->left);
BinaryTreeDestory(root->right);
free(root);
}
BTNode* _BinaryTreeCreate(BTDataType* a,int* pi)
{
if (a[*pi] == '#')
{
(*pi)++;
return NULL;
}
BTNode* root = (BTNode*)malloc(sizeof(BTNode));
if (root == NULL)
{
printf("malloc fail");
exit(-1);
}
root->data = a[(*pi)++];
root->left = _BinaryTreeCreate(a, pi);
root->right = _BinaryTreeCreate(a, pi);
return root;
}
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi)
{
BTDataType* p = (BTDataType*)malloc(sizeof(BTDataType) * n);
if (a == NULL)
{
printf("malloc fail");
exit(-1);
}
p = a;
BTNode* root = _BinaryTreeCreate(p,pi);
return root;
}
Queue.h
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
struct BinaryTreeNode;
typedef struct BinaryTreeNode* QDateType;
typedef struct QueueNode
{
struct QueueNode* next;
QDateType data;
}QueueNode;
typedef struct Queue
{
QueueNode* head;
QueueNode* tail;
}Queue;
void QueueInit(Queue* pq);
void QueueDestroy(Queue* pq);
void QueuePush(Queue* pq, QDateType x);
void QueuePop(Queue* pq);
QDateType QueueFront(Queue* pq);
QDateType QueueBack(Queue* pq);
int QueueSize(Queue* pq);
bool QueueEmpty(Queue* pq);
Queue.c
#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;
while (cur)
{
QueueNode* next = cur->next;
free(cur);
cur = next;
}
pq->head = NULL;
pq->tail = NULL;
}
void QueuePush(Queue* pq, QDateType x)
{
assert(pq);
QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
if (newnode == NULL)
{
printf("malloc fail");
exit(-1);
}
newnode->data = x;
newnode->next = NULL;
if (pq->head == NULL)
{
pq->head = pq->tail = newnode;
}
else
{
pq->tail->next = newnode;
pq->tail = newnode;
}
}
void QueuePop(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
QueueNode* cur = pq->head->next;
free(pq->head);
pq->head = cur;
if (pq->head == NULL)
{
pq->tail = NULL;
}
}
QDateType QueueFront(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->head->data;
}
QDateType QueueBack(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->tail->data;
}
int QueueSize(Queue* pq)
{
assert(pq);
//assert(!QueueEmpty(pq));
int count = 0;
QueueNode* cur = pq->head;
while (cur)
{
count++;
cur = cur->next;
}
return count;
}
bool QueueEmpty(Queue* pq)
{
assert(pq);
return pq->head == NULL;
}
Test.c
#include "Queue.h"
#include "BTree.h"
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->left = nodeG;
return nodeA;
}
void TestBinaryTree()
{
BTNode* root = CreatBinaryTree();
BinaryTreePrevOrder(root);
printf("\n");
BinaryTreeInOrder(root);
printf("\n");
BinaryTreePostOrder(root);
printf("\n");
printf("BinaryTreeSize:%d", BinaryTreeSize(root));
printf("\n");
printf("BinaryTreeLeafSize:%d", BinaryTreeLeafSize(root));
printf("\n");
printf("BinaryTreeLevelKSize:%d", BinaryTreeLevelKSize(root, 3));
printf("\n");
BTNode* ret = BinaryTreeFind(root, 'A');
printf("%c", ret->data);
printf("BinaryTreeDeep:%d", BinaryTreeDeep(root));
printf("\n");
BinaryTreeDestory(root);
root = NULL;
}
TestBinaryTree2()
{
BTNode* root = CreatBinaryTree();
BinaryTreeLevelOrder(root);
printf("BinaryTreeComplete:%d ", BinaryTreeComplete(root));
printf("\n");
char a[] = "ABD##E#H##CF##G##";
int i = 0;
int n = sizeof(a) / sizeof(a[0]);
BTNode* root2 = BinaryTreeCreate(a,n,&i);
BinaryTreeInOrder(root2);
printf("\n");
BinaryTreePrevOrder(root2);
printf("\n");
BinaryTreeDestory(root);
root = NULL;
}
int main()
{
TestBinaryTree();
printf("\n");
TestBinaryTree2();
return 0;
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
