在这里插入代码片
```BTNode* BinaryTreeCreate(BTDataType* a, int* pi)
{
if (a[*pi] != '#')
{
BTNode* root = (BTNode*)malloc(sizeof(BTNode));
root->_data = a[*pi];
++(*pi);
root->_left = BinaryTreeCreate(a, pi);
++(*pi);
root->_right = BinaryTreeCreate(a, pi);
return root;
}
else
return NULL;
}
void BinaryTreeDestory(BTNode** root)
{
BTNode* cur = *root;
if (cur)
{
BinaryTreeDestory(&cur->_left);
BinaryTreeDestory(&cur->_right);
free(cur);
*root = NULL;
}
}
/*
// 二叉树节点个数: 左右子树的节点 + 1
// 遍历, 累加计数器
// int BinaryTreeSize(BTNode* root);
*/
void BianryTreeSize2(BTNode* root, int* num)
{
if (root)
{
++(*num);
BianryTreeSize2(root->_left, num);
BianryTreeSize2(root->_right, num);
}
}
// 二叉树叶子节点个数
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);
}
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
//空树: 0
if (root == NULL)
return 0;
if (k == 1)
return 1;
return BinaryTreeLevelKSize(root->_left, k - 1)
+ BinaryTreeLevelKSize(root->_right, k - 1);
}
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
BTNode* ret;
//空树找不到
if (root == NULL)
return NULL;
if (root->_data == x)
return root;
//查找左右子树
ret = BinaryTreeFind(root->_left, x);
if (ret)
return ret;
return BinaryTreeFind(root->_right, x);
}
//前序遍历的递归
void BinaryTreePrevOrder(BTNode* root)
{
if (root)
{
printf("%c ", root->_data);
BinaryTreePrevOrder(root->_left);
BinaryTreePrevOrder(root->_right);
}
}
//前序遍历的非递归
void BinaryTreePrevOrderNoR(BTNode* root)
{
//借助栈模拟递归过程
Stack st;
stackInit(&st, 10);
BTNode* cur = root;
BTNode* top;
while (cur || stackEmpty(&st) != 1)
{
while (cur)
{
//前序遍历,访问当前节点
printf("%c ", cur->_data);
//当前节点入栈
stackPush(&st, cur);
cur = cur->_left;
}
//获取栈顶元素
top = stackTop(&st);
stackPop(&st);
//访问右子树
cur = top->_right;
}
printf("\n");
}
//中序遍历的递归
void BinaryTreeInOrder(BTNode* root)
{
if (root)
{
BinaryTreeInOrder(root->_left);
printf("%c ", root->_data);
BinaryTreeInOrder(root->_right);
}
}
//中序遍历的非递归
void BinaryTreeInOrderNoR(BTNode* root)
{
//借助栈模拟递归过程
Stack st;
stackInit(&st, 10);
BTNode* cur = root;
BTNode* top;
while (cur || stackEmpty(&st) != 1)
{
while (cur)
{
//当前节点入栈
stackPush(&st, cur);
cur = cur->_left;
}
//获取栈顶元素
top = stackTop(&st);
stackPop(&st);
//中序遍历,访问当前节点
printf("%c ", top->_data);
//访问右子树
cur = top->_right;
}
printf("\n");
}
//后序遍历的递归
void BinaryTreePostOrder(BTNode* root)
{
if (root)
{
BinaryTreePostOrder(root->_left);
BinaryTreePostOrder(root->_right);
printf("%c ", root->_data);
}
}
//后序遍历的非递归
void BinaryTreePostOrderNoR(BTNode* root)
{
//借助栈模拟递归过程
Stack st;
stackInit(&st, 10);
BTNode* cur = root;
BTNode* top;
//prev: 最后一次访问的位置
BTNode* prev = NULL;
while (cur || stackEmpty(&st) != 1)
{
while (cur)
{
//当前节点入栈
stackPush(&st, cur);
cur = cur->_left;
}
//获取栈顶元素
top = stackTop(&st);
//判断右子树是否访问完成
//没有右子树或者右子树已经访问完成
if (top->_right == NULL || top->_right == prev)
{
//访问当前节点
printf("%c ", top->_data);
stackPop(&st);
//更新最后一次访问的位置
prev = top;
}
else
cur = top->_right; //右子树还没有访问,需要先访问右子树
}
printf("\n");
}
//层序遍历
void BinaryTreeLevelOrder(BTNode* root)
{
//队列从左向后,从上到下,保存每一层的节点
Queue q;
queueInit(&q);
//根元素入队
if (root)
queuePush(&q, root);
//队列不为空,继续遍历
while (queueEmpty(&q) != 1)
{
//获取队头元素
BTNode* front = queueFront(&q);
queuePop(&q);
//访问队头元素
printf("%c ", front->_data);
//孩子入队, 先左后右
if (front->_left)
queuePush(&q, front->_left);
if (front->_right)
queuePush(&q, front->_right);
}
printf("\n");
}
//判读是否是完全二叉树
int BinaryTreeComplete(BTNode* root)
{
Queue q;
queueInit(&q);
if (root)
queuePush(&q, root);
while (queueEmpty(&q) != 1)
{
//队头出队
BTNode* front = queueFront(&q);
queuePop(&q);
//如果队头不为空,孩子直入队
if (front)
{
queuePush(&q, front->_left);
queuePush(&q, front->_right);
}
else
break; //停止入队
}
//判断队列中剩余元素是否都为空节点
while (queueEmpty(&q) != 1)
{
BTNode* front = queueFront(&q);
queuePop(&q);
if (front)
{
//剩余元素中有非空节点,说明不是一棵完全二叉树
return 0;
}
}
//剩余元素都为空节点,是一棵完全二叉树
return 1;
}
二叉树的绽放
最新推荐文章于 2024-08-18 21:41:56 发布