devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

二叉树的实现（C语言数据结构）_建立二叉树的代码c语言

作者：我家小花儿 | 2024-03-14 10:10:35

赞

踩

建立二叉树的代码c语言

目录

一、以下是我们需要实现的功能

二、以下是我们具体功能的实现

1.创建新的结点

2.通过数组生成二叉树

 3.先序遍历

4.中序遍历

5.后序遍历 

 6.层序遍历

7.计算二叉树的结点个数

8.查找指定值为x的结点

9.查找第K层的结点个数

10.统计二叉树叶子结点的个数

11.判断是否为完全二叉树

12.二叉树的销毁

13.求二叉树的高度

14.汇总

三、测试代码

一、以下是我们需要实现的功能

  1. #pragma once
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <assert.h>
  5. #include <stdbool.h>
  6. typedef char BTDataType;
  7.  
  8. typedef struct BinaryTreeNode
  9. {
  10.     BTDataType _data;
  11.     struct BinaryTreeNode* _left;
  12.     struct BinaryTreeNode* _right;
  13. }BTNode;
  14.  
  15. BTNode* BuyNode(BTDataType x);
  16.  
  17. // 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
  18. BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi);
  19. // 二叉树销毁
  20. void BinaryTreeDestroy(BTNode** root);
  21. // 二叉树节点个数
  22. int BinaryTreeSize(BTNode* root);
  23. // 二叉树叶子节点个数
  24. int BinaryTreeLeafSize(BTNode* root);
  25. // 二叉树第k层节点个数
  26. int BinaryTreeLevelKSize(BTNode* root, int k);
  27. // 二叉树查找值为x的节点
  28. BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
  29. // 二叉树前序遍历
  30. void BinaryTreePrevOrder(BTNode* root);
  31. // 二叉树中序遍历
  32. void BinaryTreeInOrder(BTNode* root);
  33. // 二叉树后序遍历
  34. void BinaryTreePostOrder(BTNode* root);
  35. // 层序遍历
  36. void BinaryTreeLevelOrder(BTNode* root);
  37. // 判断二叉树是否是完全二叉树
  38. int BinaryTreeComplete(BTNode* root);

二、以下是我们具体功能的实现

1.创建新的结点

在下面的代码中，我们将调用我们的创建新的结点来快速创建结点。

  1. TNode* BuyNode(BTDataType x)
  2. {
  3.     BTNode* node = (BTNode*)malloc(sizeof(BTNode));
  4.     assert(node);
  5.  
  6.     node->_data = x;
  7.     node->_left = NULL;
  8.     node->_right = NULL;
  9.  
  10.     return node;
  11. }

2.通过数组生成二叉树

  1. BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi)
  2. {
  3. //这里我们的a为我们的数组
  4. //n为我们数组的最大长度
  5. //pi为我们遍历数组的指针。
  6. //这里我们使用'#'来表示NULL
  7. //当我们所指向的位置的元素为#或者我们的指针已经超出了数组的范围的时候，我们就需要返回NULL
  8. //并且将我们的指针后移。
  9.     if(a[*pi] == '#' || *pi >= n)
  10.     {
  11.         printf("NULL ");
  12.         (*pi)++;
  13.         return NULL;
  14.     }
  15. //创建一个新的二叉树的结点
  16.     BTNode *dst= BuyNode(a[*pi]);
  17.     printf("%c ",dst->_data);
  18.     (*pi)++;
  19. //将我们之前开创的结点的左右指针指向数组中所对应的结点
  20. //如果我们的对应数组中的数据不为空的话，我们的左右指针都会指向新的对应的结点
  21. //如果我们的结点为空的话，我们会得到的返回值为NULL，
  22.     dst->_left = BinaryTreeCreate(a,n,pi);
  23.     dst->_right = BinaryTreeCreate(a,n,pi);
  24.  
  25.     return dst;
  26. }

 就如我们在下面的代码中的数组，我们按照上面先序遍历的代码的描述，我们所创建出来的就是这样一棵二叉树

 3.先序遍历

先序遍历就是先遍历我们的根节点，然后遍历我们左子树，然后遍历我们的右子树。

  1. //先序遍历
  2. void BinaryTreePrevOrder(BTNode* root)
  3. {
  4. //如果我们根节点的等于NULL，我们就直接返回上一层递归
  5.     if(root == NULL)
  6.     {
  7.         return;
  8.     }
  9. //将我们当前结点中的数据打印出来
  10.     printf("%c ",root->_data);
  11. //遍历我们的左树
  12.     BinaryTreePrevOrder(root->_left);
  13. //遍历我们的右树
  14.     BinaryTreePrevOrder(root->_right);
  15. }

我们上面代码进行先序遍历所生成的序列是这样的

 

4.中序遍历

中序遍历就是先读取我们左子树中的元素，再读取我们根节点的元素，最后再读取右子树中的元素。

  1. // 二叉树中序遍历
  2. void BinaryTreeInOrder(BTNode* root)
  3. {
  4.     if(root == NULL)
  5.     {
  6.         return;
  7.     }
  8.     BinaryTreeInOrder(root->_left);
  9.     printf("%c ",root->_data);
  10.     BinaryTreeInOrder(root->_right);
  11. }

 

5.后序遍历 

后序遍历就是先遍历我们的左子树，再遍历我们右子树，最后遍历我们的根节点

  1. void BinaryTreePostOrder(BTNode* root)
  2. {
  3.     if(root == NULL)
  4.     {
  5.         return;
  6.     }
  7.     BinaryTreePostOrder(root->_left);
  8.     BinaryTreePostOrder(root->_right);
  9.     printf("%c ",root->_data);
  10. }

从下面的顺序中，我们发现我们最后才遍历了根节点 

 

 6.层序遍历

层序遍历就是先将我们二叉树的根节点入队，然后再将我们根节点的左右指针所指向的结点入队，然后将我们队首的元素出队。

这里我们需要用到一个队列，具体的队列的代码我们在下面的汇总代码中将会给出。

  1. // 层序遍历
  2. void BinaryTreeLevelOrder(BTNode* root)
  3. {
  4. //创建我们的队列
  5.     Queue q;
  6. //初始化队列
  7.     QueueInit(&q);
  8.     assert(root);
  9. //将我们的根节点入队列
  10.     QueuePush(&q, root);
  11. //如果我们的栈空间不为空的话就继续我们的循环
  12.     while(!QueueEmpty(&q))
  13.     {
  14. //创建一个临时变量结点获得我们队列头的结点
  15.         BTNode *temp= QueueFront(&q);
  16. //将我们队列头的数据打印
  17.         printf("%c ",temp->_data);
  18. //将我们队列头的左右指针所对应的结点入队列
  19.         if(temp->_left)
  20.         {
  21.             QueuePush(&q,temp->_left);
  22.         }
  23.         if(temp->_right)
  24.         {
  25.             QueuePush(&q,temp->_right);
  26.         }
  27. //将我们队头的结点出队
  28.         QueuePop(&q);
  29.     }
  30. //销毁我们的队伍
  31.     QueueDestory(&q);
  32. }

7.计算二叉树的结点个数

  1. // 二叉树节点个数
  2. int BinaryTreeSize(BTNode* root)
  3. {
  4. //如果我们当前的结点为空，也就是说我们已经到了叶子结点的左右结点，也就是没有结点
  5. //所以我们需要返回0
  6.     if(root==NULL)
  7.     {
  8.         return 0;
  9.     }
  10. //如果我们当前的结点的左指针和右指针都是空的话，也就是说这是我们的叶子结点
  11. //就返回1，也就是只有一个结点。
  12.     if(root->_left==NULL&&root->_right==NULL)
  13.     {
  14.         return 1;
  15.     }
  16. //使用递归遍历我们的二叉树，即分别统计我们左子树中的结点个数再加上右子树中的结点个数再加上1
  17. //因为我们需要将我们当前所指的结点算上。
  18.     return BinaryTreeSize(root->_left)+BinaryTreeSize(root->_right)+1;
  19. }

8.查找指定值为x的结点

这里我们的目的是找到第一个指定值为x的结点，也就是说采用先序遍历是最佳的方法。因为先序遍历会首先找到所对应的结点然后将其返回，但是我们如果采用其他的遍历方式，由于先找到的不是根节点的元素，而是分别以左中右，和左右中的顺序来遍历，就会当根结点为我们的1目标结点时错过我们的根节点。

  1. // 二叉树查找值为x的节点
  2. BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
  3. {
  4.     if(root==NULL)
  5.     {
  6.         return NULL;
  7.     }
  8.     if(root->_data==x)
  9.     {
  10.         return root;
  11.     }
  12.     BinaryTreeFind(root->_left, x);
  13.     BinaryTreeFind(root->_right,x);
  14. }

9.查找第K层的结点个数

查找第k层，我们将我们的问题化为小问题，也就是我们第一层的结点需要往下找k-1层，第二层的结点需要往下找k-2层，以此类推，只有当我们的k为1的时候返回的就是我们需要找的k层的结点的个数的总和。

  1. // 二叉树第k层节点个数
  2. int BinaryTreeLevelKSize(BTNode* root, int k)
  3. {
  4.     if(root==NULL)
  5.     {
  6.         return 0;
  7.     }
  8.     if(k==1)
  9.     {
  10.         return 1;
  11.     }
  12. //分别遍历我们的左右子树，并且将我们的k的参数--,当我们的k为1时，就到达了我们所想要查找对应的层。
  13.     return BinaryTreeLevelKSize(root->_left, k-1)+BinaryTreeLevelKSize(root->_right, k-1);
  14. }

10.统计二叉树叶子结点的个数

  1. // 二叉树叶子节点个数
  2. int BinaryTreeLeafSize(BTNode* root)
  3. {
  4.     if(root==NULL)
  5.     {
  6.         return 0;
  7.     }
  8. //如果我们的结点的左右指针全部都为空，那就是我们的叶子结点
  9.     if(root->_left==NULL&&root->_right==NULL)
  10.     {
  11.         return 1;
  12.     }
  13. //返回我们左子树中的叶子结点和右子树中的叶子结点之和
  14.     return BinaryTreeLeafSize(root->_left)+BinaryTreeLeafSize(root->_right);
  15. }

11.判断是否为完全二叉树

这里我们的主要思路就是通过采取类似层序遍历的方法，找到我们叶子结点的下一层结点。

如果我们的二叉树为一颗完全二叉树，我们叶子结点的下一层结点中的全部结点应该都是null，如果不是的话，就不是完全二叉树。

  1. // 判断二叉树是否是完全二叉树
  2. int BinaryTreeComplete(BTNode* root)
  3. {
  4. //如果我们的根节点是NULL就返回1表示是一棵完全二叉树
  5.     if(root==NULL)
  6.     {
  7.         return 1;
  8.     }
  9. //创建并且初始化我们的队列
  10.     Queue q;
  11.     QueueInit(&q);
  12. //将我们的根节点入队
  13.     QueuePush(&q,root);
  14. //这里与我们层序遍历的思路相同，但是我们需要找到我们层序遍历中的最后一层
  15. //也就是我们叶子结点的下一层
  16. //如果我们的二叉树是一棵完全二叉树，我们的叶子结点的下一层应该全部都是NULL
  17. //在下面的第一个will中我们先找到我们叶子结点的下一层的第一个NULL结点，然后跳出循环
  18.     while(!QueueEmpty(&q))
  19.     {
  20.         BTNode *temp= QueueFront(&q);
  21.         QueuePop(&q);
  22.         if(temp==NULL)
  23.         {
  24.             break;
  25.         }
  26.         QueuePush(&q,temp->_left);
  27.         QueuePush(&q,temp->_right);
  28.  
  29.     }
  30. //在我们的第二个节点中，我们将继续遍历我们的栈，如果我们当前栈中的全部全部结点都是NULL，
  31. //那我们的二叉树就是完全二叉树，不然就不是
  32. //如果是完全二叉树的话，我们就返回1，不是的话我们就返回0
  33.     while(!QueueEmpty(&q))
  34.     {
  35.         BTNode *temp= QueueFront(&q);
  36.         QueuePop(&q);
  37.         if(temp!=NULL)
  38.         {
  39.             printf("不是完全二叉树\n");
  40.             return 0;
  41.         }
  42.     }
  43.     printf("是完全二叉树\n");
  44.     return 1;
  45. }

对于我们上面所创建的二叉树，我们可以从下面的图中看出，我们经过层次遍历之后，我们找到了叶子结点的下一层结点，当我们读取到null的时候，我们跳出了第一个循环，进入第二个循环，在这第二个循环中，如果我们此时队列中剩余的数据全部都是NULL，我们就能判断这是一棵完全二叉树，但是在下面的图中，我们发现我们在读取到了三个null之后，我们读取到了H这个不为null的值，所以我们可以判断我们当前的这棵二叉树不是完全二叉树。 

 

 

12.二叉树的销毁

对于二叉树的销毁，采取后续遍历的形式，先找到我们二叉树中的左子树和右子树中的底层的结点，（这里的底层指的是叶子结点那一层），然后将我们的叶子结点分别释放空间，再一层层返回调用，自下而逐渐销毁。

  1. // 二叉树销毁
  2. void BinaryTreeDestroy(BTNode** root)
  3. {
  4.     if(*root==NULL)
  5.     {
  6.         return;
  7.     }
  8.     BinaryTreeDestroy(&((*root)->_left));
  9.     BinaryTreeDestroy(&((*root)->_right));
  10.     free(*root);
  11.     *root=NULL;
  12.     return;
  13. }

13.求二叉树的高度

  1. int BinaryTreeHeight(BTNode*root)
  2. {
  3. //如果我们的根节点为空的话，我们就直接返回
  4.     if(root==NULL)
  5.     {
  6.         return 0;
  7.     }
  8. //如果我们找到了我们的叶子结点，我们就返回1
  9.     if(root->_right==NULL&&root->_left==NULL)
  10.     {
  11.         return 1;
  12.     }
  13. //递归调用，如果我们的左子树的高度大于右子树的高度，我们返回的数据就是左子树的高度再加1
  14. //这里的+1就是我们当前层的结点
  15. //如果我们的右子树的高度大于我们左子树的高度，我们返回的数据就是右子树的高度再加1
  16.     return (BinaryTreeHeight(root->_left)>=BinaryTreeHeight(root->_right) ? BinaryTreeHeight(root->_left)+1 :BinaryTreeHeight(root->_right)+1);
  17. }

14.汇总

以下是我们写在Btree.c中的全部代码（含有二叉树加上队列的代码）

  1. #include "Btree.h"
  2.  
  3. BTNode* BuyNode(BTDataType x)
  4. {
  5.     BTNode* node = (BTNode*)malloc(sizeof(BTNode));
  6.     assert(node);
  7.  
  8.     node->_data = x;
  9.     node->_left = NULL;
  10.     node->_right = NULL;
  11.  
  12.     return node;
  13. }
  14.  
  15.  
  16. BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi)
  17. {
  18.     if(a[*pi] == '#' || *pi >= n)
  19.     {
  20.         printf("NULL ");
  21.         (*pi)++;
  22.         return NULL;
  23.     }
  24.     BTNode *dst= BuyNode(a[*pi]);
  25.     printf("%c ",dst->_data);
  26.     (*pi)++;
  27.  
  28.     dst->_left = BinaryTreeCreate(a,n,pi);
  29.     dst->_right = BinaryTreeCreate(a,n,pi);
  30.  
  31.     return dst;
  32. }
  33.  
  34.  
  35. //先序遍历
  36. void BinaryTreePrevOrder(BTNode* root)
  37. {
  38.     if(root == NULL)
  39.     {
  40.         return;
  41.     }
  42.  
  43.     printf("%c ",root->_data);
  44.     BinaryTreePrevOrder(root->_left);
  45.     BinaryTreePrevOrder(root->_right);
  46. }
  47.  
  48. // 二叉树中序遍历
  49. void BinaryTreeInOrder(BTNode* root)
  50. {
  51.     BinaryTreePrevOrder(root->_left);
  52.     if(root == NULL)
  53.     {
  54.         return;
  55.     }
  56.  
  57.     printf("%c ",root->_data);
  58.     BinaryTreePrevOrder(root->_right);
  59. }
  60.  
  61. // 二叉树后序遍历
  62. void BinaryTreePostOrder(BTNode* root)
  63. {
  64.     BinaryTreePrevOrder(root->_left);
  65.     BinaryTreePrevOrder(root->_right);
  66.     if(root == NULL)
  67.     {
  68.         return;
  69.     }
  70.  
  71.     printf("%c ",root->_data);
  72. }
  73.  
  74. // 层序遍历
  75. void BinaryTreeLevelOrder(BTNode* root)
  76. {
  77.     Queue q;
  78.     QueueInit(&q);
  79.     assert(root);
  80.     QueuePush(&q, root);
  81.     while(!QueueEmpty(&q))
  82.     {
  83.         BTNode *temp= QueueFront(&q);
  84.         printf("%c ",temp->_data);
  85.         if(temp->_left)
  86.         {
  87.             QueuePush(&q,temp->_left);
  88.         }
  89.         if(temp->_right)
  90.         {
  91.             QueuePush(&q,temp->_right);
  92.         }
  93.  
  94.         QueuePop(&q);
  95.     }
  96.     QueueDestory(&q);
  97. }
  98.  
  99. // 二叉树节点个数
  100. int BinaryTreeSize(BTNode* root)
  101. {
  102.     if(root==NULL)
  103.     {
  104.         return 0;
  105.     }
  106.     if(root->_left==NULL&&root->_right==NULL)
  107.     {
  108.         return 1;
  109.     }
  110.     return BinaryTreeSize(root->_left)+BinaryTreeSize(root->_right)+1;
  111. }
  112.  
  113. // 二叉树查找值为x的节点
  114. BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
  115. {
  116.     if(root==NULL)
  117.     {
  118.         return NULL;
  119.     }
  120.     if(root->_data==x)
  121.     {
  122.         return root;
  123.     }
  124.     BinaryTreeFind(root->_left, x);
  125.     BinaryTreeFind(root->_right,x);
  126. }
  127.  
  128. // 二叉树第k层节点个数
  129. int BinaryTreeLevelKSize(BTNode* root, int k)
  130. {
  131.     if(root==NULL)
  132.     {
  133.         return 0;
  134.     }
  135.     if(k==1)
  136.     {
  137.         return 1;
  138.     }
  139.     return BinaryTreeLevelKSize(root->_left, k-1)+BinaryTreeLevelKSize(root->_right, k-1);
  140. }
  141.  
  142. // 二叉树叶子节点个数
  143. int BinaryTreeLeafSize(BTNode* root)
  144. {
  145.     if(root==NULL)
  146.     {
  147.         return 0;
  148.     }
  149.     if(root->_left==NULL&&root->_right==NULL)
  150.     {
  151.         return 1;
  152.     }
  153.     return BinaryTreeLeafSize(root->_left)+BinaryTreeLeafSize(root->_right);
  154. }
  155.  
  156. // 判断二叉树是否是完全二叉树
  157. int BinaryTreeComplete(BTNode* root)
  158. {
  159.     if(root==NULL)
  160.     {
  161.         return 1;
  162.     }
  163.     Queue q;
  164.     QueueInit(&q);
  165.     QueuePush(&q,root);
  166.     while(!QueueEmpty(&q))
  167.     {
  168.         BTNode *temp= QueueFront(&q);
  169.         QueuePop(&q);
  170.         if(temp==NULL)
  171.         {
  172.             break;
  173.         }
  174.         QueuePush(&q,temp->_left);
  175.         QueuePush(&q,temp->_right);
  176.  
  177.     }
  178.     while(!QueueEmpty(&q))
  179.     {
  180.         BTNode *temp= QueueFront(&q);
  181.         QueuePop(&q);
  182.         if(temp!=NULL)
  183.         {
  184.             printf("不是完全二叉树\n");
  185.             return 0;
  186.         }
  187.     }
  188.     printf("是完全二叉树\n");
  189.     return 1;
  190. }
  191. // 二叉树销毁
  192. void BinaryTreeDestroy(BTNode** root)
  193. {
  194.     if(root==NULL)
  195.     {
  196.         return ;
  197.     }
  198.     if(*root==NULL)
  199.     {
  200.         return;
  201.     }
  202.     BinaryTreeDestroy(&((*root)->_left));
  203.     BinaryTreeDestroy(&((*root)->_right));
  204.     free(*root);
  205.     *root=NULL;
  206.     return;
  207. }
  208.  
  209. //求二叉树的高度
  210. int BinaryTreeHeight(BTNode*root)
  211. {
  212.     if(root==NULL)
  213.     {
  214.         return 0;
  215.     }
  216.     if(root->_right==NULL&&root->_left==NULL)
  217.     {
  218.         return 1;
  219.     }
  220.     return (BinaryTreeHeight(root->_left)>=BinaryTreeHeight(root->_right) ? BinaryTreeHeight(root->_left)+1 :BinaryTreeHeight(root->_right)+1);
  221. }
  222.  
  223. //队列的创建
  224. void QueueInit(Queue* pq)
  225. {
  226.     assert(pq);
  227.     pq->head = pq->tail = NULL;
  228. }
  229.  
  230. void QueueDestory(Queue* pq)
  231. {
  232.     assert(pq);
  233.     QNode* cur = pq->head;
  234.     while (cur)
  235.     {
  236.         QNode* next = cur->next;
  237.         free(cur);
  238.         cur = next;
  239.     }
  240.  
  241.     pq->head = pq->tail = NULL;
  242. }
  243.  
  244. void QueuePush(Queue* pq, QDataType x)
  245. {
  246.     assert(pq);
  247.     QNode* newnode = (QNode*)malloc(sizeof(QNode));
  248.     assert(newnode);
  249.  
  250.     newnode->data = x;
  251.     newnode->next = NULL;
  252.  
  253.     if (pq->tail == NULL)
  254.     {
  255.         assert(pq->head == NULL);
  256.         pq->head = pq->tail = newnode;
  257.     }
  258.     else
  259.     {
  260.         pq->tail->next = newnode;
  261.         pq->tail = newnode;
  262.     }
  263. }
  264.  
  265. void QueuePop(Queue* pq)
  266. {
  267.     assert(pq);
  268.     assert(pq->head && pq->tail);
  269.  
  270.     if (pq->head->next == NULL)
  271.     {
  272.         free(pq->head);
  273.         pq->head = pq->tail = NULL;
  274.     }
  275.     else
  276.     {
  277.         QNode* next = pq->head->next;
  278.         free(pq->head);
  279.         pq->head = next;
  280.     }
  281. }
  282.  
  283. bool QueueEmpty(Queue* pq)
  284. {
  285.     assert(pq);
  286.  
  287.     //return pq->head == NULL && pq->tail == NULL;
  288.     return pq->head == NULL;
  289. }
  290.  
  291. size_t QueueSize(Queue* pq)
  292. {
  293.     assert(pq);
  294.     QNode* cur = pq->head;
  295.     size_t size = 0;
  296.     while (cur)
  297.     {
  298.         size++;
  299.         cur = cur->next;
  300.     }
  301.  
  302.     return size;
  303. }
  304.  
  305. QDataType QueueFront(Queue* pq)
  306. {
  307.     assert(pq);
  308.     assert(pq->head);
  309.  
  310.     return pq->head->data;
  311. }
  312.  
  313. QDataType QueueBack(Queue* pq)
  314. {
  315.     assert(pq);
  316.     assert(pq->tail);
  317.  
  318.     return pq->tail->data;
  319. }

以下是我们写在Btree.h中的全部代码（二叉树再加上队列的代码）

  1. #pragma once
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <assert.h>
  5. #include <stdbool.h>
  6. typedef char BTDataType;
  7.  
  8. typedef struct BinaryTreeNode
  9. {
  10.     BTDataType _data;
  11.     struct BinaryTreeNode* _left;
  12.     struct BinaryTreeNode* _right;
  13. }BTNode;
  14.  
  15. BTNode* BuyNode(BTDataType x);
  16.  
  17. // 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
  18. BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi);
  19. // 二叉树销毁
  20. void BinaryTreeDestroy(BTNode** root);
  21. // 二叉树节点个数
  22. int BinaryTreeSize(BTNode* root);
  23. // 二叉树叶子节点个数
  24. int BinaryTreeLeafSize(BTNode* root);
  25. // 二叉树第k层节点个数
  26. int BinaryTreeLevelKSize(BTNode* root, int k);
  27. // 二叉树查找值为x的节点
  28. BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
  29. // 二叉树前序遍历
  30. void BinaryTreePrevOrder(BTNode* root);
  31. // 二叉树中序遍历
  32. void BinaryTreeInOrder(BTNode* root);
  33. // 二叉树后序遍历
  34. void BinaryTreePostOrder(BTNode* root);
  35. // 层序遍历
  36. void BinaryTreeLevelOrder(BTNode* root);
  37. // 判断二叉树是否是完全二叉树
  38. int BinaryTreeComplete(BTNode* root);
  39. //求二叉树的高度
  40. int BinaryTreeHeight(BTNode* root);
  41.  
  42. typedef BTNode *QDataType;
  43.  
  44. typedef struct QueueNode
  45. {
  46.     QDataType data;
  47.     struct QueueNode* next;
  48. }QNode;
  49.  
  50. typedef struct Queue
  51. {
  52.     QNode* head;
  53.     QNode* tail;
  54.  
  55.     //size_t size;
  56. }Queue;
  57.  
  58. void QueueInit(Queue* pq);
  59. void QueueDestory(Queue* pq);
  60. void QueuePush(Queue* pq, QDataType x);
  61. void QueuePop(Queue* pq);
  62. bool QueueEmpty(Queue* pq);
  63. size_t QueueSize(Queue* pq);
  64. QDataType QueueFront(Queue* pq);
  65. QDataType QueueBack(Queue* pq);

三、测试代码

以下是我们写在test.c中的代码

  1. #include"Btree.h"
  2. int main() {
  3.     char a[17]={'A','B','D','#','#','E','#','H','#','#','C','F','#','#','G','#','#'};
  4.     int b=0;
  5.     int *pi=&b;
  6.     BTNode *Btree=BinaryTreeCreate(a, 16, pi);
  7.     printf("\n");
  8. //前序遍历
  9.     BinaryTreePrevOrder(Btree);
  10.     printf("\n");
  11. //中序遍历
  12.     BinaryTreeInOrder(Btree);
  13.     printf("\n");
  14. //后序遍历
  15.     BinaryTreePostOrder(Btree);
  16.     printf("\n");
  17.     //乘次遍历
  18.     BinaryTreeLevelOrder(Btree);
  19.     printf("\n");
  20.  
  21.     int number=BinaryTreeSize(Btree);
  22.     printf("%d",number);
  23.     printf("\n");
  24.     //查找为x的结点
  25.     BTNode *find=BinaryTreeFind(Btree, 'A');
  26.     printf("%c\n",find->_data);
  27.  
  28.     //查询第k层的结点个数
  29.     int w=BinaryTreeLevelKSize(Btree, 3);
  30.     printf("%d\n",w);
  31.  
  32.     //查询叶子结点的个数
  33.     int count=BinaryTreeLeafSize(Btree);
  34.     printf("%d\n",count);
  35.  
  36. //判断当前是否为一棵完全二叉树
  37.     int r=BinaryTreeComplete(Btree);
  38.  
  39.     //求二叉树的高度
  40.     int x=BinaryTreeHeight(Btree);
  41.     printf("二叉树的高度是%d\n",x);
  42. //    int c=fmax(2,1);
  43. //    printf("%d\n",c);
  44. //销毁二叉树
  45.     BinaryTreeDestroy(&Btree);
  46.     return 0;
  47. }

以下是我们代码的输出结果

​​​​​​​

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/233224
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号