左神算法基础班4_1&2实现二叉树的先序、中序、后序遍历，包括递归方式和非递归

Problem：
　　实现二叉树的先序、中序、后序遍历，包括递归方式和非递归方式

Solution：
　　切记递归规则：
　　先遍历根节点，然后是左孩子，右孩子，
　　根据不同的打印位置来确定中序、前序、后续遍历。

Code:

　　

 #pragma once
 #include <iostream>
 #include <vector>
 #include <queue>
 #include <stack>
 #include <string>
 #include <sstream>

 using namespace std;

 struct Node
 {
     int val;
     Node* lchild;
     Node* rchild;
     Node() :val(a), lchild(NULL), rchild(NULL) {}
 };

 void Create1(Node*& root, vector<int>num, int i)//前序构造树
 {
     )
         root = NULL;
     else if (i < num.size())
     {
         root = new Node(num[i]);
         Create1(root->lchild, num, i + );
         Create1(root->rchild, num, i + );
     }
 }

 void Create2(Node*& root, vector<int>num)//层序构造树
 {
     queue<Node*>q;
     root = ]);
     q.push(root);
     ;
     while (i < num.size() && !q.empty())
     {
         Node* p = q.front();
         q.pop();
         if (!p)//空节点p
             break;
         )
             p->lchild = new Node (num[i++]);
         )
             p->rchild = new Node (num[i++]);
         q.push(p->lchild);
         q.push(p->rchild);
     }
 }

 void PreTravel(Node* root)//前序遍历
 {
     if (!root)
         return;
     cout << root->val << "  ";
     PreTravel(root->lchild);
     PreTravel(root->rchild);
 }

 void NotPreTravel(Node* root)//非递归前序遍历
 {
     stack<Node*>s;
     if (root)
     {
         s.push(root);
         while (!s.empty())
         {
             root = s.top();
             cout << root->val << "  ";
             s.pop();
             if (root->rchild)
                 s.push(root->rchild);
             if (root->lchild)
                 s.push(root->lchild);
         }
     }
 }

 void MidTravel(Node* root)//中序遍历
 {
     if (!root)
         return;

     MidTravel(root->lchild);
     cout << root->val << "  ";
     MidTravel(root->rchild);
 }

 void NotMidTravel(Node* root)//非递归中序遍历
 {
     stack<Node*>s;
     if (root)
     {
         while (!s.empty() || root)
         {
             if (root)
             {
                 s.push(root);
                 root = root->lchild;
             }
             else
             {
                 root = s.top();
                 s.pop();
                 cout << root->val << "  ";
                 root = root->rchild;
             }
         }
     }
 }

 void LastTravel(Node* root)//后序遍历
 {
     if (!root)
         return;
     LastTravel(root->lchild);
     LastTravel(root->rchild);
     cout << root->val << "  ";
 }

 void NotLastTravel(Node* root)//非递归后序遍历
 {
     stack<Node*>s1;
     stack<Node*>s2;
     if (root)
     {
         s1.push(root);
         while (!s1.empty())
         {
             root = s1.top();
             s1.pop();
             s2.push(root);
             if (root->lchild)
                 s1.push(root->lchild);
             if(root->rchild)
                 s1.push(root->rchild);
         }
         while (!s2.empty())
         {
             root = s2.top();
             s2.pop();
             cout << root->val << "  ";
         }
     }
 }

 void NotLastTravel2(Node* root)//非递归后序遍历,使用一个栈
 {
     stack<Node*>s;
     if (root)
     {
         s.push(root);
         Node* p;
         while (!s.empty())
         {
             p = s.top();
             if (p->lchild && root != p->lchild && root != p->rchild)
                 s.push(p->lchild);
             else if (p->rchild && root != p->rchild )
                 s.push(p->rchild);
             else
             {
                 cout << p->val << "  ";
                 s.pop();
                 root = p;
             }
         }

     }
 }

 string getSpace(int num)
 {
     string space = " ";
     ; i < num; ++i)
         space.append(" ");
     return space;
 }

 void PrintShape(Node* root, int h, string c, int len)
 {
     if (root)
     {
         PrintShape(root->rchild, h + , "v", len);
         string val;
         stringstream ss;
         ss << root->val;
         ss >> val;
         val = c + val + c;
         int lenM = val.length();
         ;
         int lenR = len - lenM - lenL;
         val = getSpace(lenL) + val + getSpace(lenR);
         cout << getSpace(h*len) + val << endl;
         PrintShape(root->lchild, h + , "^", len);
     }

 }

 //直观地打印一颗树，即打印一横向的树，每个节点的左上角节点为其父节点
 void PrintTree(Node* root)
 {
     cout << "The shape of tree is: " << endl;
     cout << "===============================================" << endl;
     PrintShape(root, , );
     cout << "===============================================" << endl;
 }

 void Test()
 {
     //我们使用多种方法来构造一颗树：
     //                 1
     //            2            3
     //         4     5     6     7
     //        8 9  10 11 12 N  N  NULL
     //  使用层序遍历来打印树

     Node* root1 = NULL;
     vector<,,,,,,,,,,,-,,-,- };
     Create1(root1, num1, );//前序构造树

     Node* root2 = NULL;
     vector<,,,,,,,,,,,,-,-,-};
     Create2(root2, num2);//层序构造树

     cout << endl << "==============前序遍历============" << endl;
     PreTravel(root2);//前序遍历

     cout << endl << "===============中序遍历=============" << endl;
     MidTravel(root2);//中序遍历

     cout << endl << "===============后序遍历============" << endl;
     LastTravel(root2);//后序遍历

     cout << endl << "===============非递归前序遍历============" << endl;
     NotPreTravel(root2);//非递归前序遍历

     cout << endl << "===============非递归中序遍历============" << endl;
     NotMidTravel(root2);//非递归中序遍历

     cout << endl << "===============非递归后序遍历============" << endl;
     NotLastTravel2(root2);//非递归后序遍历

     cout << endl << "===============打印树============" << endl;
     PrintTree(root2);

     ;

 }