顺序存储完全二叉树的基本操作

#include<stdio.h>
#include<malloc.h>
#define MAX_TREE_NODE_SIZE 100
typedef struct
{
int item[MAX_TREE_NODE_SIZE]; //根存储在下标为1的数组单元中,内容为结点的表示数字
int n; //当前完全二叉树的结点个数
}QBTree;
QBTree *BT;

void CreateBTree(QBTree *BT,int data[],int n) //构造一棵完全二叉树
{
if (n >= MAX_TREE_NODE_SIZE)
n = MAX_TREE_NODE_SIZE-1; //因为下标从1开始
for (int i = 1; i <= n;i++)
BT->item[i] = data[i];
BT->n=n;
}

int LeftChild_locate(QBTree BT,int node) //获取给定结点（位置）的左孩子的结点位置
{
if (node > BT.n)
{
printf("该结点不存在!/n");
return 0;
}
else if ((2 * node) > BT.n)
return -1;
else
return 2 * node;
}

int LeftChild_value(QBTree BT,int node) //获取给定结点（值）的左孩子的结点位置
{
int tmp = 0;
for (int i = 1;i <= BT.n;i++)
{
if (BT.item[i] == node)
{
tmp = i;
break;
}
}
if ((tmp != 0) && ((2 * tmp) <= BT.n))
{
return 2 * tmp;
}
else
return -1;
}

int RightChild_locate(QBTree BT,int node) //获取给定结点（位置）的右孩子的结点位置
{
if ((2 * node + 1) > BT.n)
return -1;
else
return 2 * node + 1;
}

int RightChild_value(QBTree BT,int node) //获取给定结点（值）的右孩子的结点位置
{
int tmp = 0;
for (int i = 1;i <= BT.n;i++)
{
if (BT.item[i] == node)
{
tmp = i;
break;
}
}
if ((tmp != 0) && ((2 * tmp + 1) <= BT.n))
{
return 2 * tmp + 1;
}
else
return -1;
}

int Parent(QBTree BT,int node) //获取给定结点(位置)的父亲
{
if ((1 < node) && (node <= BT.n)) //1结点没有父结点
return node/2;
else
return -1;
}

bool IsEmpty(QBTree BT) //判断二叉树是否为空
{
if (BT.n == 0)
return true;
else
return false;
}

void ClearBTree(QBTree *BT) //清空以BT为根的二叉树
{
BT->n = 0;
}

void layer_Traverse(QBTree BT) //遍历,由于是顺序存储，直接顺序遍历就是按层次遍历
{
for (int i = 1;i <= BT.n;i++)
{
printf("%d ",BT.item[i]);
if (i % 5 == 0)
printf("/n");
}
}

void forward_Traverse(QBTree BT,int i) //前序递归遍历,先把左的遍历完再回溯
{
if (!IsEmpty(BT))
{
printf("%d ",BT.item[i]); //对输入的结点操作
if ((LeftChild_locate(BT,i)) != -1) //如果左子结点存在，递归
forward_Traverse(BT,LeftChild_locate(BT,i));
if ((RightChild_locate(BT,i)) != -1) //如果右子结点存在，递归
forward_Traverse(BT,RightChild_locate(BT,i));
}
else
{
printf("该树为空!/n");
}
}

void middle_Traverse(QBTree BT,int i) // 中序递归遍历
{
if (!IsEmpty(BT))
{
if ((LeftChild_locate(BT,i)) != -1) //如果左子结点存在，递归
middle_Traverse(BT,LeftChild_locate(BT,i));
printf("%d ",BT.item[i]); //对输入的结点操作
if ((RightChild_locate(BT,i)) != -1) //如果右子结点存在，递归
middle_Traverse(BT,RightChild_locate(BT,i));
}
else
{
printf("该树为空!/n");
}
}

void back_Traverse(QBTree BT,int i) //后序递归遍历
{
if (!IsEmpty(BT))
{
if ((LeftChild_locate(BT,i)) != -1) //如果左子结点存在，递归
back_Traverse(BT,LeftChild_locate(BT,i));
if ((RightChild_locate(BT,i)) != -1) //如果右子结点存在，递归
back_Traverse(BT,RightChild_locate(BT,i));
printf("%d ",BT.item[i]); //对输入的结点操作
}
else
{
printf("该树为空!/n");
}
}

void main()
{
int data[6];
BT = (QBTree*)malloc(sizeof(QBTree));
for (int i = 1;i <= 5;i++)
{
scanf("%d",&data[i]);
}
CreateBTree(BT,data,5); //1 2 3 4 5
int lc = LeftChild_locate(*BT,2);
printf("%d/n",lc);
int rc = RightChild_locate(*BT,1);
printf("%d/n",rc);
layer_Traverse(*BT); //1 2 3 4 5
printf("/n");
forward_Traverse(*BT,1); //1 2 4 5 3
printf("/n");
back_Traverse(*BT,1); //4 5 2 3 1
printf("/n");
middle_Traverse(*BT,1); //4 2 5 1 3
}