C/C++二叉树的创建及遍历：递归遍历、非递归遍历、层次遍历

淩亂°似流年 2022-04-24 09:20 367阅读 0赞

文章目录

  • 1 二叉树的主要性质
  • 2 二叉树的创建及遍历
    • 2.1 C语言实现
      • 2.1.1 递归遍历
      • 2.1.2 非递归遍历
        • 先序
        • 中序
        • 后序
      • 2.1.3 层次遍历
    • 2.2 C++实现

1 二叉树的主要性质

  1. 一棵非空二叉树的第i层最多有 2 i 2^i 2i（i >= 1)个节点
  2. 一棵深度为k的二叉树最多有 2 k 2^k 2k-1个节点
  3. 一棵非空二叉树，设叶子节点数为 n 0 n_0 n0​，度为2的节点数为 n 2 n_2 n2​，则 n 0 n_0 n0​ = n 2 n_2 n2​ + 1
  4. 设有n个节点的完全二叉树的深度为k，则 k = [ l o g 2 n log_2n log2​n] + 1 （[ l o g 2 n log_2n log2​n]表示不大于 l o g 2 n log_2n log2​n的最大整数）

2 二叉树的创建及遍历

2.1 C语言实现

在这里插入图片描述

2.1.1 递归遍历

  1. #include <malloc.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  5. typedef char elemType;
  6. typedef struct BiTNode { 
  7.     elemType data;
  8.     struct BiTNode *lchild, *rchild;
  9. } BiTNode, *BiTree;
  11. BiTree createBiTree();            // 先序输入节点的值，构造二叉树
  12. void PreOrderTraverse(BiTree T);  // 先序遍历二叉树
  13. void InOrderTraverse(BiTree T);   // 中序遍历二叉树
  14. void PostOrderTraverse(BiTree T); // 后序遍历二叉树
  15. void visit(elemType x);           // 输出元素x
  16. BiTNode *SearchNode(BiTree T,
  17.                     elemType x); // 在以T为根节点的二叉树中查找元素为x的节点
  18. int CountLeaf(BiTree T);  // 求二叉树叶子节点个数
  19. int BiTreeHigh(BiTree T); // 求二叉树的深度
  20. int CountNodes(BiTree T); // 求二叉树叶子节点个数
  22. int main(void)
  23. { 
  24.     BiTree root;
  26.     printf("请按先序顺序输入节点值，输入‘#’代表节点为空：\n");
  27.     root = createBiTree();
  29.     printf("先序递归：");
  30.     PreOrderTraverse(root);
  31.     printf("\n");
  32.     printf("中序递归：");
  33.     InOrderTraverse(root);
  34.     printf("\n");
  35.     printf("后序递归：");
  36.     PostOrderTraverse(root);
  37.     printf("\n");
  39.     BiTNode *temp = SearchNode(root, 'E');
  40.     printf("查找出的节点元素为：%c\n", temp->data);
  42.     int leaves1 = CountLeaf(root);
  43.     printf("二叉树叶子节点总数为：%d\n", leaves1);
  45.     int nodes = CountNodes(root);
  46.     printf("二叉树节点总数为：%d\n", nodes);
  48.     int high = BiTreeHigh(root);
  49.     printf("二叉树深度为：%d\n", high);
  51.     return 0;
  52. }
  54. // 先序输入节点的值，构造二叉树
  55. BiTree createBiTree()
  56. { 
  57.     char ch;
  58.     BiTree T;
  60.     if ((ch = getchar()) == '#')
  61.         T = NULL;
  62.     else { 
  63.         T = (BiTNode *)malloc(sizeof(BiTNode));
  64.         T->data = ch;
  65.         T->lchild = createBiTree();
  66.         T->rchild = createBiTree();
  67.     }
  69.     return T;
  70. }
  71. // 输出元素x
  72. void visit(elemType x) {  printf("%c, ", x); }
  73. // 先序遍历二叉树
  74. void PreOrderTraverse(BiTree T)
  75. { 
  76.     if (T != NULL) { 
  77.         visit(T->data);
  78.         PreOrderTraverse(T->lchild);
  79.         PreOrderTraverse(T->rchild);
  80.     }
  81. }
  82. // 中序遍历二叉树
  83. void InOrderTraverse(BiTree T)
  84. { 
  85.     if (T) { 
  86.         InOrderTraverse(T->lchild);
  87.         visit(T->data);
  88.         InOrderTraverse(T->rchild);
  89.     }
  90. }
  91. // 后序遍历二叉树
  92. void PostOrderTraverse(BiTree T)
  93. { 
  94.     if (T) { 
  95.         PostOrderTraverse(T->lchild);
  96.         PostOrderTraverse(T->rchild);
  97.         visit(T->data);
  98.     }
  99. }
  100. // 在以T为根节点的二叉树中查找元素为x的节点
  101. BiTNode *SearchNode(BiTree T, elemType x)
  102. { 
  103.     if (!T)
  104.         return NULL;
  106.     if (T->data == x)
  107.         return T;
  108.     else { 
  109.         BiTNode *temp;
  111.         temp = SearchNode(T->lchild, x);
  112.         if (!temp) { 
  113.             return SearchNode(T->rchild, x);
  114.         }
  116.         return temp;
  117.     }
  119.     return NULL;
  120. }
  122. // 求二叉树的深度
  123. int BiTreeHigh(BiTree T)
  124. { 
  125.     int lh, rh, h;
  127.     if (T == NULL)
  128.         h = 0;
  129.     else { 
  130.         lh = BiTreeHigh(T->lchild);
  131.         rh = BiTreeHigh(T->rchild);
  132.         h = (lh > rh ? lh : rh) + 1;
  133.     }
  135.     return h;
  136. }
  137. // 求二叉树叶子节点个数
  138. int CountLeaf(BiTree T)
  139. { 
  140.     if (T == NULL)
  141.         return 0;
  142.     else if ((T->lchild == NULL) && (T->rchild == NULL))
  143.         return 1;
  144.     else
  145.         return (CountLeaf(T->lchild) + CountLeaf(T->rchild));
  146. }
  147. // 求二叉树总节点个数
  148. int CountNodes(BiTree T)
  149. { 
  150.     if (T) { 
  151.         if ((T->lchild == NULL) && (T->rchild == NULL))
  152.             return 1;
  153.         else
  154.             return (CountNodes(T->rchild) + CountNodes(T->lchild) + 1);
  155.     }
  157.     return 0;
  158. }

在这里插入图片描述

2.1.2 非递归遍历

先序

先序遍历的过程是首先访问根结点.然后先序遍历根的左子树，最后先序遍历根的右子树。对于根的左子树和右子树，遍历的过程相同。如果用非递归方法，就要在遍历左子树之前先保存右子树根结点的地址(指针)，以便在完成左子树的遍历之后取出右子树根结点的地址，再遍历这棵右子树。同样,在遍历左子树的左子树之前也要先保存左子树的右子树根结点的地址，以此类推。可以看出,对这些地址的保存和取出符合后进先出的原则,可设置一个辅助栈来保存这些右子树根结点的地址。为了方便编写算法,这个辅助栈保存所有经过的结点的指针,包括空的根指针和空的孩子指针。

中序

中序遍历的过程是首先中序遍历左子树,然后访问根结点，最后中序遍历根的右子树。对于根的左子树和右子树,遍历的过程相同。如果用非递归方法，就要在遍历左子树之前先保存根结点的地址(指针),以便在完成左子树的遍历之后取出根结点的地址访问根结点,然后再中序遍历右子树。同样,在中序遍历左子树的左子树之前也要先保存左子树的根结点地址，以此类推。可以看出,对这些地址的保存和取出符合后进先出的原则,可设置一个辅助栈来保存所经过的结点的地址。为了方便编写算法,栈中也保存空树的空指针。中序遍历二叉树的非递归算法如下:

后序

后序遍历的过程是首先后序遍历左子树，然后后序遍历根的右子树,最后访问根结点。如果用非递归方法，就要在遍历左子树之前先保存根结点的地址，以便在完成左子树遍历之后根据根结点的地址遍历右子树和访问根结点。对于根的左子树和根的右子树，遍历的过程相同。对这些地址的保存和使用符合后进先出的原则，可设置-一个辅助栈来保存所经过的结点的地址。因为后序遍历的特点是只有在遍历了左子树和右子树之后才能访问根结点,所以为了表明子树是否被遍历过,可再设置一个辅助变量。

2.1.3 层次遍历

由层次遍历的定义可以推知，在进行层次遍历时，对一层结点访问完后再按照它们的访问次序对各个结点的左孩子和右孩子顺序访问，这样一层一层地进行，先遇到的结点先访问,这与队列的操作原则比较吻合。因此，在进行层次遍历时可设置一个队列结构,遍历从二叉树的根结点开始，首先将根结点指针入队列，然后从队头取出一个元素,每取一个元素执行下面两个操作:

(1)访问该元素所指的结点;
(2)若该元素所指结点的左、右孩子指针非空，则将该元素所指结点的非空左孩子指针和右孩子指针顺序入队。

若队列非空,重复以上过程,当队列为空时,二叉树的层次遍历结束。在下面的层次遍历算法中,二叉树以二叉链表存储，一 维数组Queue[ MAXNODE ]用于实现队列,变量front和rear分别表示当前队列首元素和队列尾元素在数组中的位置。
在这里插入图片描述

  1. #include <malloc.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  5. typedef char elemType;
  6. typedef struct BiTNode { 
  7.     elemType data;
  8.     struct BiTNode *lchild, *rchild;
  9. } BiTNode, *BiTree;
  10. BiTree createBiTree(); // 先序输入节点的值，构造二叉树
  11. void PreOrderTraverseNonRec(BiTree T);  // 先序非递归遍历二叉树
  12. void InOrderTraverseNonRec(BiTree T);   // 中序非递归遍历二叉树
  13. void PostOrderTraverseNonRec(BiTree T); // 后序非递归遍历二叉树
  14. void LevelOrderTraverse(BiTree T); // 层次遍历二叉树（从上到下，每层从左到右）
  16. #define STACK_INIT_SIZE 100
  17. #define STACKINCREMENT 10
  18. typedef struct StackNode { 
  19.     BiTNode **top;
  20.     BiTNode **base;
  21.     int size;
  22. } Stack;
  23. Stack *InitStack();             // 初始化空栈
  24. int isEmpty(Stack *S);          // 判断栈空
  25. BiTNode *GetTop(Stack *S);      // 取栈顶数据
  26. int push(Stack *S, BiTNode *p); // 入栈
  27. BiTNode *pop(Stack *S);         // 出栈
  29. #define MAXSIZE 100
  30. typedef struct { 
  31.     BiTNode *data[MAXSIZE]; // 指针数组，数组中的每一个元素指向BiTNode类型的节点
  32.     int front, rear; /* front:指向队列中第一个元素 rear:指向队列中最后一个元素下一位置 */
  33. } Queue;
  35. int main(void)
  36. { 
  37.     BiTree root;
  39.     printf("请按先序顺序输入节点值，输入‘#’代表节点为空：\n");
  40.     root = createBiTree();
  42.     printf("先序非递归：");
  43.     PreOrderTraverseNonRec(root);
  44.     printf("\n");
  45.     printf("中序非递归：");
  46.     InOrderTraverseNonRec(root);
  47.     printf("\n");
  48.     printf("后序非递归：");
  49.     PostOrderTraverseNonRec(root);
  50.     printf("\n");
  51.     printf("按层次遍历：");
  52.     LevelOrderTraverse(root);
  53.     printf("\n");
  55.     return 0;
  56. }
  58. // 先序输入节点的值，构造二叉树
  59. BiTree createBiTree()
  60. { 
  61.     char ch;
  62.     BiTree T;
  64.     if ((ch = getchar()) == '#')
  65.         T = NULL;
  66.     else { 
  67.         T = (BiTNode *)malloc(sizeof(BiTNode));
  68.         T->data = ch;
  69.         T->lchild = createBiTree();
  70.         T->rchild = createBiTree();
  71.     }
  73.     return T;
  74. }
  75. // 输出元素x
  76. void visit(elemType x) {  printf("%c, ", x); }
  77. Stack *InitStack()
  78. { 
  79.     Stack *S;
  81.     S = (Stack *)malloc(sizeof(Stack));
  82.     S->base = (BiTNode **)calloc(STACK_INIT_SIZE, sizeof(BiTNode *));
  83.     S->top = S->base;
  84.     S->size = STACK_INIT_SIZE;
  86.     return S;
  87. }
  88. // 取栈顶数据
  89. BiTNode *GetTop(Stack *S)
  90. { 
  91.     BiTNode *p = NULL;
  92.     if (S->top == S->base)
  93.         return NULL;
  94.     p = *(S->top - 1);
  96.     return p;
  97. }
  98. // 入栈
  99. int push(Stack *S, BiTNode *p)
  100. { 
  101.     if (S->top - S->base >= S->size) { 
  102.         S->base = (BiTNode **)realloc(
  103.             S->base, (STACKINCREMENT + STACK_INIT_SIZE) * sizeof(BiTNode *));
  104.         if (!S->base) { 
  105.             printf("入栈失败！\n");
  106.             return 0;
  107.         }
  108.         S->top = S->base + S->size;
  109.         S->size += STACKINCREMENT;
  110.     }
  111.     *S->top++ = p;
  113.     return 1;
  114. }
  115. // 出栈
  116. BiTNode *pop(Stack *S)
  117. { 
  118.     if (S->top == S->base) { 
  119.         printf("出栈失败！\n");
  120.         return NULL;
  121.     }
  122.     return *--S->top;
  123. }
  124. // 判断栈空
  125. int isEmpty(Stack *S) {  return S->top == S->base; }
  127. // 先序非递归遍历二叉树
  128. void PreOrderTraverseNonRec(BiTree T)
  129. { 
  130.     Stack *S = InitStack();
  131.     BiTNode *p;
  133.     push(S, T);
  134.     while (!isEmpty(S)) { 
  135.         p = GetTop(S);
  136.         while (p != NULL) //向左走到尽头
  137.         { 
  138.             visit(p->data);
  139.             push(S, p->lchild);
  140.             p = GetTop(S);
  141.         }
  143.         /* while (p = GetTop(S))//向左走到尽头 { visit(p->data); push(S, p->lchild); } */
  145.         p = pop(S); //空指针退栈
  146.         if (!isEmpty(S)) { 
  147.             p = pop(S);
  148.             push(S, p->rchild); //向右一步
  149.         }
  150.     }
  151. }
  152. // 中序非递归遍历二叉树
  153. void InOrderTraverseNonRec(BiTree T)
  154. { 
  155.     Stack *S = InitStack();
  156.     BiTNode *p;
  158.     push(S, T);
  159.     while (!isEmpty(S)) { 
  160.         p = GetTop(S);
  161.         while (p != NULL) //向左走到尽头
  162.         { 
  163.             push(S, p->lchild);
  164.             p = GetTop(S);
  165.         }
  167.         pop(S); //空指针退栈
  168.         if (!isEmpty(S)) { 
  169.             p = pop(S);
  170.             visit(p->data);
  171.             push(S, p->rchild);
  172.         }
  173.     }
  174. }
  175. // 后序非递归遍历二叉树
  176. void PostOrderTraverseNonRec(BiTree T)
  177. { 
  178.     Stack *S = InitStack();
  179.     BiTNode *p = T, *q; // q指向最近被访问过的节点，用作标志
  181.     do { 
  182.         while (p) //向左走到尽头
  183.         { 
  184.             push(S, p);
  185.             p = p->lchild;
  186.         }
  187.         q = NULL;
  188.         while (!isEmpty(S)) { 
  189.             p = GetTop(S);
  190.             if ((p->rchild == NULL) ||
  191.                 q == p->rchild) {  //右子树为空或已经访问过
  192.                 visit(p->data);
  193.                 q = p;
  194.                 pop(S);
  195.             }
  196.             else // 右子树非空且未被遍历
  197.             { 
  198.                 p = p->rchild; //向右一步
  199.                 break;
  200.             }
  201.         }
  202.     } while (!isEmpty(S));
  203. }
  204. // 层次遍历二叉树（从上到下，每层从左到右）
  205. void LevelOrderTraverse(BiTree T)
  206. { 
  207.     Queue Q;
  208.     BiTNode *temp = NULL;
  210.     Q.front = Q.rear = 0;
  211.     if (T) { 
  212.         Q.data[Q.rear] = T;
  213.         Q.rear = (Q.rear + 1) % MAXSIZE;
  214.         while (Q.front != Q.rear) { 
  215.             temp = Q.data[Q.front];
  216.             visit(temp->data);
  217.             Q.front = (Q.front + 1) % MAXSIZE;
  219.             if (temp->lchild) { 
  220.                 Q.data[Q.rear] = temp->lchild;
  221.                 Q.rear = (Q.rear + 1) % MAXSIZE;
  222.             }
  223.             if (temp->rchild) { 
  224.                 Q.data[Q.rear] = temp->rchild;
  225.                 Q.rear = (Q.rear + 1) % MAXSIZE;
  226.             }
  227.         }
  228.     }
  229. }

在这里插入图片描述

2.2 C++实现

在这里插入图片描述






























元素 5 6 9 3 null 44 1 11 22
下标 0 1 2 3 4 5 6 7 8 
  1. #include <iostream>
  2. #include <queue>
  3. #include <stack>
  4. #include <vector>
  5. using namespace std;
  7. #define nil INT_MIN
  9. // 二叉树结点定义
  10. struct TreeNode { 
  11.     int val;
  12.     TreeNode *left;
  13.     TreeNode *right;
  14.     TreeNode() : val(0), left(nullptr), right(nullptr) { }
  15.     TreeNode(int x) : val(x), left(nullptr), right(nullptr) { }
  16.     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) { }
  17. };
  19. // 创建二叉树
  20. TreeNode *createBinaryTree(vector<int> &vals, int n, int index)
  21. { 
  22.     TreeNode *node = nullptr;
  23.     if (index < n && vals[index] != nil) { 
  24.         node = new TreeNode(vals[index]);
  25.         node->left = createBinaryTree(vals, n, 2 * index + 1);
  26.         node->right = createBinaryTree(vals, n, 2 * index + 2);
  27.     }
  28.     return node;
  29. }
  31. // 打印一个结点信息
  32. void visit(const TreeNode *node) {  cout << node->val << ' '; }
  34. // 递归遍历
  35. void preOrder(TreeNode *root, void (*visit)(const TreeNode *node))
  36. { 
  37.     if (root) { 
  38.         visit(root);
  39.         preOrder(root->left, visit);
  40.         preOrder(root->right, visit);
  41.     }
  42. }
  43. void inOrder(TreeNode *root, void (*visit)(const TreeNode *node))
  44. { 
  45.     if (root) { 
  46.         inOrder(root->left, visit);
  47.         visit(root);
  48.         inOrder(root->right, visit);
  49.     }
  50. }
  51. void postOrder(TreeNode *root, void (*visit)(const TreeNode *node))
  52. { 
  53.     if (root) { 
  54.         postOrder(root->left, visit);
  55.         postOrder(root->right, visit);
  56.         visit(root);
  57.     }
  58. }
  60. // 非递归遍历
  61. void preOrderNonRecursive(TreeNode *root, void (*visit)(const TreeNode *node))
  62. { 
  63.     stack<TreeNode *> stk;
  64.     TreeNode *p = root;
  65.     while (p || !stk.empty()) { 
  66.         // 向左走到尽头
  67.         while (p) { 
  68.             visit(p);
  69.             stk.push(p);
  70.             p = p->left;
  71.         }
  72.         p = stk.top();
  73.         stk.pop();
  74.         p = p->right;
  75.     }
  76. }
  77. void inOrderNonRecursive(TreeNode *root, void (*visit)(const TreeNode *node))
  78. { 
  79.     stack<TreeNode *> stk;
  80.     TreeNode *p = root;
  81.     while (p || !stk.empty()) { 
  82.         // 向左走到尽头
  83.         while (p) { 
  84.             stk.push(p);
  85.             p = p->left;
  86.         }
  87.         p = stk.top();
  88.         stk.pop();
  89.         visit(p);
  90.         p = p->right;
  91.     }
  92. }
  93. /* * 后序：左子树 右子树 根结点 * 思想：1 沿着根的左孩子，依次入栈，直到左孩子为空 * 2 读栈顶元素，若其右孩子不空且未被访问过，将右子树执行步骤 1； * 否则，栈顶元素出栈并访问 */
  94. void postOrderNonRecursive(TreeNode *root, void (*visit)(const TreeNode *node))
  95. { 
  96.     stack<TreeNode *> stk;
  97.     // p 为当前访问的结点，rencent 为最近访问过的结点
  98.     TreeNode *p = root, *recent = nullptr;
  99.     while (p || !stk.empty()) { 
  100.         // 走到最左边
  101.         if (p) { 
  102.             stk.push(p);
  103.             p = p->left;
  104.         }
  105.         // 向右
  106.         else { 
  107.             p = stk.top();
  108.             // 若右子树存在且未被访问
  109.             if (p->right && p->right != recent) { 
  110.                 p = p->right;
  111.                 stk.push(p);
  112.                 p = p->left;
  113.             }
  114.             // 出栈并访问
  115.             else { 
  116.                 stk.pop();
  117.                 visit(p);
  118.                 recent = p;
  119.                 // 每次出栈访问完一个结点就相当于遍历完以该结点为根的子树，需将 p 置空
  120.                 p = nullptr;
  121.             }
  122.         }
  123.     }
  124. }
  126. // 层次遍历
  127. void levelOrder(TreeNode *root, void (*visit)(const TreeNode *node))
  128. { 
  129.     queue<TreeNode *> q;
  130.     q.push(root);
  131.     while (!q.empty()) { 
  132.         TreeNode *node = q.front();
  133.         q.pop();
  134.         visit(node);
  135.         if (node->left)
  136.             q.push(node->left);
  137.         if (node->right)
  138.             q.push(node->right);
  139.     }
  140. }
  141. int main(int argc, char const *argv[])
  142. { 
  143.     vector<int> vals{ 5, 6, 9, 3, nil, 44, 1, 11, 22};
  144.     TreeNode *root = createBinaryTree(vals, vals.size(), 0);
  145.     cout << "1、递归遍历\n";
  146.     cout << "先序：";
  147.     preOrder(root, visit);
  148.     cout << endl;
  149.     cout << "中序：";
  150.     inOrder(root, visit);
  151.     cout << endl;
  152.     cout << "后序：";
  153.     postOrder(root, visit);
  154.     cout << endl << endl;
  156.     cout << "2、非递归遍历\n";
  157.     cout << "先序：";
  158.     preOrderNonRecursive(root, visit);
  159.     cout << endl;
  160.     cout << "中序：";
  161.     inOrderNonRecursive(root, visit);
  162.     cout << endl;
  163.     cout << "后序：";
  164.     postOrderNonRecursive(root, visit);
  165.     cout << endl << endl;
  167.     cout << "3、层次遍历\n";
  168.     cout << "层次遍历：";
  169.     levelOrder(root, visit);
  170.     cout << endl << endl;
  172.     return 0;
  173. }
  175. 1、递归遍历
  176. 先序：5 6 3 11 22 9 44 1
  177. 中序：11 3 22 6 5 44 9 1
  178. 后序：11 22 3 6 44 1 9 5
  180. 2、非递归遍历
  181. 先序：5 6 3 11 22 9 44 1
  182. 中序：11 3 22 6 5 44 9 1
  183. 后序：11 22 3 6 44 1 9 5
  185. 3、层次遍历
  186. 层次遍历：5 6 9 3 44 1 11 22

发表评论

表情：
评论列表 （有 0 条评论，367人围观）

还没有评论，来说两句吧...

相关阅读