二叉树的四种遍历

 

 

 

 

  1 #include <iostream>
  2 #include <stack>
  3 
  4 using namespace std;
  5 
  6 #include "structure.h"
  7 
  8 
  9 void preOrder(TreeNode *pRoot);
 10 void preOrderRecursion(TreeNode *pRoot);
 11 void inOrder(TreeNode *pRoot);
 12 void inOrderRecursion(TreeNode *pRoot);
 13 void postOrderRecursion(TreeNode *pRoot);
 14 void postOrder(TreeNode *pRoot);
 15 
 16 int main()
 17 {
 18     TreeNode *pRoot = new TreeNode(4);
 19     pRoot->left = new TreeNode(2);
 20     pRoot->left->left = new TreeNode(1);
 21     pRoot->left->right = new TreeNode(3);
 22     pRoot->right = new TreeNode(6);
 23     pRoot->right->left = new TreeNode(5);
 24     pRoot->right->right = new TreeNode(7);
 25 
 26     preOrderRecursion(pRoot);
 27     cout << endl;
 28     preOrder(pRoot);
 29     cout << endl;
 30     inOrderRecursion(pRoot);
 31     cout << endl;
 32     inOrder(pRoot);
 33     cout << endl;
 34     postOrderRecursion(pRoot);
 35     cout << endl;
 36     postOrder(pRoot);
 37 
 38     return 0;
 39 }
 40 
 41 void preOrder(TreeNode *pRoot)
 42 {
 43     stack<TreeNode*> treeStack;
 44     treeStack.push(pRoot);
 45     while(!treeStack.empty())
 46     {
 47         TreeNode *node = treeStack.top();
 48         treeStack.pop();
 49         printf("%d ", node->val);
 50         if(node->right != NULL)
 51             treeStack.push(node->right);
 52         if(node->left != NULL)
 53             treeStack.push(node->left);
 54     }
 55 }
 56 
 57 void preOrderRecursion(TreeNode *pRoot)
 58 {
 59     if(pRoot == NULL)
 60         return;
 61 
 62     printf("%d ", pRoot->val);
 63     preOrderRecursion(pRoot->left);
 64     preOrderRecursion(pRoot->right);
 65 }
 66 
 67 void inOrder(TreeNode *pRoot)
 68 {
 69     stack<TreeNode*> treeStack;
 70     while(pRoot != NULL || !treeStack.empty())
 71     {
 72         while(pRoot != NULL)
 73         {
 74             treeStack.push(pRoot);
 75             pRoot = pRoot->left;
 76         }
 77         TreeNode *node = treeStack.top();
 78         treeStack.pop();
 79         printf("%d ", node->val);
 80         pRoot = node->right;
 81     }
 82 }
 83 
 84 void inOrderRecursion(TreeNode *pRoot)
 85 {
 86     if(pRoot == NULL)
 87         return;
 88 
 89     inOrderRecursion(pRoot->left);
 90     printf("%d ", pRoot->val);
 91     inOrderRecursion(pRoot->right);
 92 }
 93 
 94 void postOrder(TreeNode *pRoot)
 95 {
 96     stack<TreeNode*> treeStack;
 97     while(pRoot != NULL || !treeStack.empty())
 98     {
 99         while(pRoot != NULL)
100         {
101             treeStack.push(pRoot);
102             pRoot = pRoot->left;
103         }
104 
105         TreeNode *pNode = NULL;// 指针变量p指向当前结点的前驱结点
106         while(!treeStack.empty())
107         {
108             TreeNode *node = treeStack.top();
109             if(node->right == pNode)// 如果当前结点右孩子为空，或者已经被访问过，则访问当前结点
110             {
111                 treeStack.pop();
112                 printf("%d ", node->val);
113                 pNode = node;
114             }else
115             {
116                 pRoot = node->right;
117                 break;
118             }
119         }
120     }
121 }
122 
123 void postOrderRecursion(TreeNode *pRoot)
124 {
125     if(pRoot == NULL)
126         return;
127 
128     postOrderRecursion(pRoot->left);
129     postOrderRecursion(pRoot->right);
130     printf("%d ", pRoot->val);
131 }

main.c

 

 1 #ifndef __STRUCTURE_H__
 2 #define __STRUCTURE_H__
 3 
 4 #include <stdlib.h>
 5 
 6 
 7 struct ListNode {
 8     int val;
 9     struct ListNode *next;
10     ListNode(int x) :
11             val(x), next(NULL) {
12     }
13 };
14 
15 struct TreeNode {
16     int val;
17     struct TreeNode *left;
18     struct TreeNode *right;
19     TreeNode(int x) :
20             val(x), left(NULL), right(NULL) {
21     }
22 };
23 
24 #endif // __STRUCTURE_H__

structure.h

 

转载于:https://www.cnblogs.com/fenghualong/p/9571953.html