【二叉树问题】非递归进行二叉树的前序、中序、后序遍历

目录

非递归实现二叉树的前序遍历

非递归实现二叉树的中序遍历

非递归实现二叉树的后序遍历

代码实现

---

用非递归方法进行二叉树的前序、中序、后序遍历，要对从上到下遍历过的节点进行存储，再根据相关条件循环限制输出，因此要用到额外数据结构——栈，栈弹出元素的顺序即为对应的遍历顺序

非递归实现二叉树的前序遍历

1、将根节点压入栈中

2、栈不为空时，弹出栈顶元素temp，如果temp的右子树节点存在，将右子树节点压入栈中；如果temp的左子树节点存在，再将左子树节点压入栈中。

3、重复步骤2.

非递归实现二叉树的中序遍历

1、变量cur指向根节点

2、当cur不为NULL时，将cur 压入栈中，cur指向cur的左子树节点，即cur = cur->left;循环直到cur为NULL.（找到子树左下角的节点）

3、当cur为NULL时，弹出栈顶元素，令cur指向栈顶元素的右子树节点，cur = cur->right，重复第2步。

3、当cur为NULL并且stack为空时，退出循环。(会有stack为空，但是cur不为空的情况)

非递归实现二叉树的后序遍历

仅用一个栈实现

1、变量h指向栈中前一个弹出的节点，变量c指向栈顶元素。h初始化为头结点head，c初始化为null。压入头节点。

2、如果栈顶元素的左子树节点不为空，并且前一个弹出的节点既不等于栈顶元素的左子树节点，又不等于栈顶元素的右子树节点，说明栈顶元素的左子树还没有被处理，因此将c->left压入栈中

3、如果栈顶元素的右子树节点不为空，并且前一个弹出的节点不等于栈顶元素的右子树节点，说明栈顶元素的右子树还没有被处理，因此将c->right压入栈中

4、其他情况，都说明以栈顶元素为根节点的子树已经按后序遍历遍历完成，因此更新h为栈顶元素，并将栈顶元素弹出。

用两个栈实现

1、将根节点压入栈s1中

2、栈不为空时，弹出s1栈顶元素temp到s2中，如果temp的左子树节点存在，将左子树节点压入栈中；如果temp的右子树节点存在，再将右子树节点压入栈中。

3、重复步骤2.

4、弹出栈s2中元素

代码实现

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/

class TreeToSequence {
public:
    void DLR(vector<int> &result1,TreeNode*root){//非递归实现前序遍历
        //用栈来实现
       stack<TreeNode*>s;
     
       s.push(root);//头结点
       while(!s.empty())//栈不为空
       {
           TreeNode* temp = s.top(); 
           s.pop();
           result1.push_back(temp->val);//取出栈顶元素
           if(temp->right!=NULL)//右子树不为空
               s.push(temp->right);
           if(temp->left!=NULL)//左子树不为空
               s.push(temp->left);
         
       }
    }
    void LDR(vector<int> &result2,TreeNode*root){//中序遍历
        stack<TreeNode*>s;
        TreeNode * cur = root;
        s.push(cur);
        cur = cur->left;
       while(1){
          while(cur!=NULL){
             s.push(cur);
             cur = cur->left;
           }
           cur = s.top();
           result2.push_back(cur->val);
           cur = cur->right;
           s.pop();
           if(s.empty() && cur == NULL)
               break;
       }
    }
    void LRD(vector<int> &result3,TreeNode*root){//仅用一个栈实现后序遍历
        stack<TreeNode*>s;
        TreeNode * cur = root;
        s.push(cur);
        TreeNode* stacktop = NULL;
        TreeNode* justpop = cur;
        while(!s.empty()){
             stacktop= s.top();
          if (stacktop->left!=NULL && justpop!=stacktop->left && justpop!= stacktop->right){
            s.push(stacktop->left);
          
        }    
           else if(stacktop->right!=NULL &&justpop != stacktop->right){//右子树还没有被处理过
               s.push(stacktop->right);
              
           }
            else{
                result3.push_back(stacktop->val);
                justpop = stacktop;
                s.pop();
                }
        }
        
    }
    vector<vector<int> > convert(TreeNode* root) {
        // write code here
        vector<int> result1;
        vector<int> result2;
        vector<int> result3;
        DLR(result1,root);
        LDR(result2,root);
        LRD(result3,root);
        vector<vector<int>> result;
        result.push_back(result1);
        result.push_back(result2);
        result.push_back(result3);
        return result;
    }
};

两个栈实现后序遍历

   void LRD(vector<int> &result3,TreeNode*root){//后序遍历
       stack<TreeNode*>s;  stack<TreeNode*>s2;
       s.push(root);//头结点
       while(!s.empty())//栈不为空
       {
           TreeNode* temp = s.top(); 
           s2.push(temp);
           s.pop();
           if(temp->left!=NULL)//左子树不为空
               s.push(temp->left);
            if(temp->right!=NULL)//右子树不为空
               s.push(temp->right);
       }
        while(!s2.empty()){
            result3.push_back(s2.top()->val);//取出栈顶元素
            s2.pop();
        }
          
        
    }