#pragma once
#include "Stack.h"
#include "Queue.h"
#include <stdio.h>
#include <malloc.h>
#include <assert.h>
#include <stdlib.h>
typedef char BTDataType;
//孩子兄弟表示法:表示出每一个结点的第一个孩子结点,也表示出孩子结点的兄弟结点
typedef struct BinaryTreeNode
{
BTDataType _data;
struct BinaryTreeNode* _left;
struct BinaryTreeNode* _right;
}BTNode;
// a是一个前序遍历的数组
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi);
void BinaryTreeDestory(BTNode* root);
BTNode* BuyBTNode(BTDataType x);
int BinaryTreeSize(BTNode* root); //结点的个数
int BinaryTreeLeafSize(BTNode* root); //叶子结点的个数
int BinaryTreeLevelKSize(BTNode* root, int k); //第k层的结点数
// 遍历 递归&非递归
void BinaryTreePrevOrder(BTNode* root); //前序
void BinaryTreeInOrder(BTNode* root); //中序
void BinaryTreePostOrder(BTNode* root); //后序
BTNode* BinaryTreeFind(BTNode* root, BTDataType x); //查找元素
int BinaryTreeHeight(BTNode* root); //高度
void BinaryTreeLevelOrder(BTNode* root);
int BinaryTreeComplete(BTNode* root); //是否为完全二叉树
void BinaryTreePrevOrderNonR(BTNode* root);
void BinaryTreeInOrderNonR(BTNode* root);
void BinaryTreePostOrderNonR(BTNode* root);
void TestBinaryTree();
tree.c
#include"tree.h"
#include"Queue.h"
#include"Stack.h"
BTNode* BuyBTNode(BTDataType x)
{
BTNode * node = (BTNode *)malloc(sizeof(BTNode));
node->_left = NULL;
node->_right = NULL;
node->_data = x;
return node;
}
// a是一个前序遍历的数组
BTNode* BinaryTreeCreate(BTDataType* a, int n, int pi)
{
if (a[pi] != '#')
{
BTNode* root = BuyBTNode(a[pi]);
++(pi);
root->_left = BinaryTreeCreate(a, n, pi);
++(pi);
root->_right = BinaryTreeCreate(a, n, pi);
return root;
}
else
{
return 0;
}
}
void BinaryTreeDestory(BTNode** pptree)
{
BTNode* root = *pptree;
if (root == NULL)
return;
BinaryTreeDestory(root->_left);
BinaryTreeDestory(root->_right);
free(root);
*pptree = NULL;
}
int size = 0;
int BinaryTreeSize(BTNode* root)
{
if (root == NULL)
return 0;
return BinaryTreeSize(root->_left) + BinaryTreeSize(root->_right) + 1;
}
int BinaryTreeLeafSize(BTNode* root)
{
if (root == NULL)
return NULL;
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 1;
return BinaryTreeLevelKSize(root->_left, k - 1)+BinaryTreeLevelKSize(root ->_right, k - 1);
}
// 遍历 递归&非递归
void BinaryTreePrevOrder(BTNode* root)//前序
{
if (root == NULL)
{
return;
}
printf("%c", root->_data);
BinaryTreePrevOrder(root->_left);
BinaryTreePrevOrder(root->_right);
}
void BinaryTreeInOrder(BTNode* root)//中序
{
if (root == NULL)
return ;
BinaryTreePrevOrder(root->_left);
printf("%c", root->_data);
BinaryTreePrevOrder(root->_right);
}
void BinaryTreePostOrder(BTNode* root)//后序
{
if (root == NULL)
return NULL;
BinaryTreePrevOrder(root->_left);
BinaryTreePrevOrder(root->_right);
printf("%c", root->_data);
}
void BinaryTreeLevelOrder(BTNode* root)//层序
{
Queue q;
QueueInit(&q);
if (root)
{
QueuePush(&q, root);
while (QueueEmpty(&q != 0))
{
BTNode* front = QueueFront(&q);
printf("%c", front->_data);
if (front->_left)
{
QueuePush(&q, front->_left);
}
if (front->_left)
{
QueuePush(&q, front->_left);
}
}
QueuePop(&q);
}
}
int BinaryTreeHeight(BTNode * root)
{
if (root == NULL)
{
return 0;
}
int leftHeight = BinaryTreeHeight(root->_left);
int rightHeight = BinaryTreeHeight(root->_right);
return leftHeight > rightHeight ? leftHeight+1 : rightHeight+1;
}
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
BTNode* ret;
if (root == NULL || root->_data == x)
{
return root;
}
ret = BinaryTreeFind(root->_left, x);
if (ret)
{
return ret;
}
ret = BinaryTreeFind(root->_right, x);
if (ret)
{
return ret;
}
}
int BinaryTreeComplete(BTNode*root)
{
Queue q;
QueueInit(&q);
if (root)
QueuePush(&q, root);
while (QueueEmpty(&q) != NULL)
{
BTNode* front = QueueFront(&q);
if (front)
{
QueuePush(&q, front->_left);
QueuePush(&q, front->_right);
}
else
{
break;
}
}
while (QueueEmpty(&q) != NULL)
{
BTNode* front = QueueFront(&q);
if (front)
{
QueueDestory(&q);
return -1;
}
else
{
QueuePop(&q);
}
return 0;
}
}
int BinaryTreeComplete1(BTNode* root)
{
Queue q;
if (root == root)
printf("空树\n");
return 1;
QueuePush(&q, root);
//这里给一个flag是标记是否出现过满结点
int flag=0;
int count = 0;
while (QueueEmpty(&q) != NULL)
{
BTNode* front = QueueFront(&q);
QueuePop(&q); //如果队首元素的左子树为空将标记置为false如果层序遍历后面的节点还有子树说明不是
if (front != NULL && (front->_left&&front->_right))
{
QueuePush(&q, front->_left);
QueuePush(&q, front->_right);
}
if (front == NULL)
{
flag = NULL;
count++;
}
else
{
if (count == 1)
{
flag = 0;
return 0;
}
else
{
flag = 0;
}
}
}
if (flag = 0)
{
return 0;
}
else
{
return 1;
}
}
void BinaryTreePrevOrderNonR(BTNode* root)
{
BTNode* cur = root;
BTNode * top;
Stack s;
StackInit(&s);
while (cur || StackEmpty(&s)!=NULL)
{
while (cur)
{
printf("%c ", cur->_data);
StackPush(&s, cur);
cur = cur->_left;
}
}
top = StackTop(&s);
StackPop(&s);
cur = top->_right;
}
void BinaryTreeInOrderNonR(BTNode* root)
{
BTNode* cur = root;
BTNode * top;
Stack s;
StackInit(&s);
while (cur || StackEmpty(&s)!=NULL)
{
while (cur)
{
StackPush(&s, cur);
cur = cur->_left;
}
}
top = StackTop(&s);
StackPop(&s);
printf("%c ", cur->_data);
cur = top->_right;
}
void BinaryTreePostOrderNonR(BTNode* root)
{
BTNode* cur = root;
BTNode* top; BTNode* prev;
Stack s;
StackInit(&s);
while (cur || StackEmpty(&s) != 0)
{
while (cur)
{
StackPush(&s, cur);
cur = cur->_left; //访问左树
top = StackTop(&s);
prev = top;
if (top->_right == NULL || top->_right == prev)
{
printf("%c ", top->_data); //根节点
prev = top;
StackPop(&s);
}
else
{
cur = top->_right; //访问右树
}
}
}
}
关于栈和队列的相关接口请戳https://blog.csdn.net/qq_41268108/article/details/81668000
test.c
#include"tree.h"
#include"Queue.h"
#include"Stack.h"
void TestBinaryTree()
{
BTNode* root;
char array[] = { 'A', 'B', 'D', '#', '#', '#', 'C', 'E', '#', '#', 'F', '#', '#' };
size_t i = 0;
BTNode* tree = BinaryTreeCreate(array, (sizeof(array) / sizeof(BTDataType(*))), i);
//BinaryTreePrevOrder(&root);
printf("\n");
//BinaryTreeInOrder(&root);
printf("\n");
//BinaryTreePostOrder(&root);
printf("\n");
//BinaryTreeLevelOrder(&root);
printf("\n");
//int ret = BinaryTreeFind(&ret, 'A');
//printf("%c\n", ret);
//BinaryTreeHeight(&root);
printf("\n");
//BinaryTreeComplete(&root);
printf("\n");
//BinaryTreeComplete1(&root);
printf("\n");
//int size = BinaryTreeSize(&root);
printf("\n");
//BinaryTreePrevOrderNonR(&root);
printf("\n");
//BinaryTreeInOrderNonR(&root);
printf("\n");
//BinaryTreePostOrderNonR(&root);
printf("\n");
}
int main()
{
TestBinaryTree();
system("pause");
return 0;
}