递归和非递归遍历二叉树

#include <vector>
#include <stack>
#include <iostream>
#include <cmath>

using namespace std;
struct TreeNode {
     int val;
     TreeNode *left;
     TreeNode *right;
     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 };
class Solution {
public:
    void preordertraverse(TreeNode *root) {
        if(root==NULL)return;
            cout<<root->val;
            preordertraverse(root->left);
            preordertraverse(root->right);
    }
    void midordertraverse(TreeNode *root) {
        if(root==NULL)return;
            midordertraverse(root->left);
            cout<<root->val;
            midordertraverse(root->right);
    }
    void latordertraverse(TreeNode *root) {
        if(root==NULL)return;
            latordertraverse(root->left);
            latordertraverse(root->right);
            cout<<root->val;
    }
    void preorder(TreeNode *root) {
        if(root==NULL)return;
        stack<TreeNode *> T;
        TreeNode *node;
        node=root;
        while(!T.empty()|(node!=nullptr)){
            while(node){
                T.push(node);
                cout<<node->val;
                node=node->left;
                }
            node=T.top();
            T.pop();
            node=node->right;
        }
    }
    void midorder(TreeNode *root) {
        if(root==NULL)return;
        stack<TreeNode *> T;
        TreeNode *node;
        node=root;
        while(!T.empty()|(node!=nullptr)){
            while(node){
                T.push(node);
                node=node->left;
                }
            node=T.top();
            cout<<node->val;
            T.pop();
            node=node->right;
        }
    }
    void latorder(TreeNode *root) {
        if(root==NULL)return;
        stack<TreeNode *> T;
        TreeNode *node;
        TreeNode *temp;
        node=root;
        while(!T.empty()|(node!=nullptr)){
            while(node!=nullptr){
                T.push(node);
                node=node->left;
                }
            temp=T.top();
            node=temp->right;
            if(temp->right==nullptr){
                cout<<temp->val;
                T.pop();
                while(!T.empty()&&temp==T.top()->right){
                    temp=T.top();
                    T.pop();
                    cout<<temp->val;
                }
            }
        }
    }
};
int main(){
    TreeNode *T1=new TreeNode(1);
    TreeNode *T2=new TreeNode(2);
    TreeNode *T3=new TreeNode(3);
    TreeNode *T4=new TreeNode(4);
    TreeNode *T5=new TreeNode(5);
    TreeNode *T6=new TreeNode(6);
    TreeNode *T7=new TreeNode(7);
    TreeNode *T8=new TreeNode(8);
    
    T1->left=T2;
    T1->right=T3;
    T2->left=T4;
    T2->right=T5;
    T3->left=T6;
    T3->right=T7;
    T6->right=T8;
    
    Solution s;
//    s.preordertraverse(T1);
//    cout<<"--"<<endl;
//    s.midordertraverse(T1);
//    cout<<"--"<<endl;
    s.latordertraverse(T1);
    cout<<"--"<<endl;
//    s.preorder(T1);
//    s.midorder(T1);
    s.latorder(T1);
    
    return 0;
}