二叉树的非递归遍历

数据结构

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

先序遍历

首先，从根节点A开始，根据操作1），输出A，并将其入栈，由于A的左孩子不为空，根据操作2），将B置为当前节点，再根据操作1），将B输出，并将其入栈，由于B的左孩子也不为空，根据操作2），将D置为当前节点，再根据操作1），输出D，并将其入栈，此时输出序列为ABD；

由于D的左孩子为空，根据操作3），将栈顶节点D出栈，但不输出，并将其右孩子置为当前节点；

由于D的右孩子为空，根据操作5），继续将栈顶节点B出栈，但不输出，并将其右孩子置为当前节点；

由于B的右孩子E不为空，根据操作1），输出E，并将其入栈，此时输出序列为：ABDE；

由于E的左孩子为空，根据操作3），将栈顶节点E出栈，但不输出，并将其右孩子置为当前节点；

由于E的右孩子为空，根据操作5），继续将栈顶节点A出栈，但不输出，并将其右孩子置为当前节点；

由于A的右孩子C不为空，根据操作1），输出C，并将其入栈，此时输出序列为：ABDEC；

由于A的左孩子F不为空，根据操作2），则将F置为当前节点，再根据操作1），输出F，并将其入栈，此时输出序列为：ABDECF；

由于F的左孩子为空，根据操作3），将栈顶节点F出栈，但不输出，并将其右孩子置为当前节点；

由于F的右孩子为空，根据操作5），继续将栈顶元素C出栈，但不输出，并将其右孩子置为当前节点；

此时栈空，且C的右孩子为NULL，因此遍历结束。

class Solution {
public:
    vector inorderTraversal(TreeNode* root) {
            stack stacktree;
            TreeNode *Pcur = root;
            vector ret;
            while(Pcur||!stacktree.empty())
            {
                ret.push_back(Pcur->val);
                stacktree.push(Pcur);
                Pcur = Pcur->left;
                while(!Pcur&&!stacktree.empty())
                {
                    Pcur = stacktree.top();
                    stacktree.pop();
                    Pcur = Pcur->right;
                }
            }
            return ret;
    }
};

中序遍历

首先，从根节点A开始，A的左孩子不为空，根据操作1）将A入栈，接着将B置为当前节点，B的左孩子也不为空，根据操作1），将B也入栈，接着将D置为当前节点，由于D的左子树为空，根据操作2），输出D；

由于D的右孩子也为空，根据操作4），执行出栈操作，将栈顶结点B出栈，并将B置为当前节点，此时输出序列为DB；

由于B的右孩子不为空，根据操作3），将其右孩子E置为当前节点，由于E的左孩子为空，根据操作1），输出E，此时输出序列为DBE；

由于E的右孩子为空，根据操作4），执行出栈操作，将栈顶节点A出栈，并将节点A置为当前节点，此时输出序列为DBEA；

此时栈为空，但当前节点A的右孩子并不为NULL，继续执行，由于A的右孩子不为空，根据操作3），将其右孩子C置为当前节点，由于C的左孩子不为空，根据操作1），将C入栈，将其左孩子F置为当前节点，由于F的左孩子为空，根据操作2），输出F，此时输出序列为：DBEAF；

由于F的右孩子也为空，根据操作4），执行出栈操作，将栈顶元素C出栈，并将其置为当前节点，此时的输出序列为：DBEAFC；

由于C的右孩子为NULL，且此时栈空，根据操作5），遍历结束。

class Solution {
public:
    vector inorderTraversal(TreeNode* root) {
            stack stacktree;
            TreeNode *Pcur = root;
            vector ret;

            while(Pcur||!stacktree.empty())
            {
                if(Pcur->left)
                {
                    stacktree.push(Pcur);
                    Pcur = Pcur->left;
                }
                else
                {
                    ret.push_back(Pcur->val);
                    Pcur = Pcur->right;

                    while(!Pcur&&!stacktree.empty())
                    {
                        Pcur = stacktree.top();
                        stacktree.pop();
                        ret.push_back(Pcur->val);
                        Pcur = Pcur->right;
                    }
                }
            }
            return ret;
    }
};

后续遍历

void beh_traverse(BTree pTree)  
{  
    PSTACK stack = create_stack();  //创建一个空栈  
    BTree node_pop;          //用来保存出栈的节点  
    BTree pCur;              //定义指针，指向当前节点  
    BTree pPre = NULL;       //定义指针，指向上一各访问的节点  
  
    //先将树的根节点入栈  
    push_stack(stack,pTree);    
    //直到栈空时，结束循环  
    while(!is_empty(stack))  
    {  
        pCur = getTop(stack);   //当前节点置为栈顶节点  
        if((pCur->pLchild==NULL && pCur->pRchild==NULL) ||   
            (pPre!=NULL && (pCur->pLchild==pPre || pCur->pRchild==pPre)))  
        {  
            //如果当前节点没有左右孩子，或者有左孩子或有孩子，但已经被访问输出，  
            //则直接输出该节点，将其出栈，将其设为上一个访问的节点  
            printf("%c ", pCur->data);  
            pop_stack(stack,&node_pop);  
            pPre = pCur;  
        }  
        else  
        {  
            //如果不满足上面两种情况,则将其右孩子左孩子依次入栈  
            if(pCur->pRchild != NULL)  
                push_stack(stack,pCur->pRchild);  
            if(pCur->pLchild != NULL)  
                push_stack(stack,pCur->pLchild);  
        }  
    }  
}