树的非递归遍历

一、二叉树的非递归遍历

先序遍历：

　　1、根节点p不为空，打印，根节点入栈，并将左孩子作为当前节点，左孩子即当前节点不为空，打印。。。一个while搞定

　　2、若左孩子为空，跳出while循环；if stack 不为空，top栈顶作为当前节点，pop栈顶，将当前节点的右孩子作为当前节点

void preOrder(binaryTree* root)
{
　　stack<binaryTree*> s;
　　binaryTree* current = root;
　　while(NULL != current || false == s.empty())
　　{
　　　　while(NULL != current)
　　　　{
 　　　　　 cout << current->data << " ";  //打印当前节点
　　　　　　s.push(current);
　　　　　　current = current->leftChild;
　　　　}
　　　　if( false == s.empty())
　　　　{
　　　　　　current = s.top();  //保存栈顶节点
　　　　　　s.pop();
　　　　　　current = current->rightChild;
　　　　}
　　}
}

中序遍历：（跟前序遍历很像，利用栈结构达到链表从后向前打印的效果）

void midOrder(binaryTree* root)
{
　　stack<binaryTree*> s;
　　binaryTree* current = root;
　　while(NULL != current || false == s.empty())
　　{
　　　　while(NULL != current)
　　　　{
　　　　　　s.push(current);
　　　　　　current = current->leftChild;
　　　　}
　　　　if( false == s.empty())
　　　　{
　　　　　　current = s.top();  //保存栈顶节点
 　　　　　 cout << current->data << " ";  //打印当前节点
　　　　　　s.pop();
　　　　　　current = current->rightChild;
　　　　}
　　}
}

后续遍历：

要保证根结点在左孩子和右孩子访问之后才能访问根节点；

因此对于任一结点P，先将其入栈。if P不存在左孩子和右孩子，或者P存在左孩子或者右孩子都已被访问过了，则同样可以直接访问该结点。

否则，则将P的右孩子和左孩子依次入栈，这样就保证了每次取栈顶元素的时候按照左右根的顺序访问。

void postOrder(BinTree *root)     //非递归后序遍历
{
    stack<BinatyTree*> s;
    BinatyTree *current;                      //当前结点 
    BinatyTree *pre = NULL;                 //前一次访问的结点 

    s.push(root);
    while(false == s.empty())
    {
        current = s.top();
        if((NULL == current->leftChild && NULL == current->rightChild) ||
           (NULL != pre && ( pre==current->leftChild || pre==current->rightChild)))
        {
            cout<<current->data<<" ";  //如果当前结点没有孩子结点或者孩子节点都已被访问过 
            s.pop();
            pre = current; 
        }
        else
        {
            if(NULL != current->rightChild)
               s.push(current->rightChild);
            if(NULL != current->leftChild)    
               s.push(current->leftChild);
        }
    }    
}

 

二、多叉树的遍历

                                                                                            原文链接

多叉树的节点包括当前节点pNode和以链表list<Node*>存储的孩子节点

struct Node{  
   Node *pNode;  
   list<Node *> childsNode;  
};  

递归：

//前序遍历(正序遍历):    
void EnumNode(Node *root)  
{  
  if(NULL == root)
  　 return;
  Node* current = root;
　if(NULL != current->pNode){
　cout << root->pNode->data << " "; 
  }  
  if(NULL != current->childsNode.size){
  　　list<Node *>::iterator iter; //正向遍历器    
  　　for(iter=pNode->childsNode.begin(); iter!=pNode->childsNode.end(); ++iter)  
  　　{  
     　　EnumNode(*iter);  
 　　 } 
　　}   
}  
  
//后序遍历(反序遍历):    
void REnumNode(Node *root)  //考虑异常输入，同上即可
{    
  list<Node *>::reverse_iterator iter; //反向遍历器    
  for(iter=pNode->childsNode.rbegin();iter!=pNode->childsNode.rend();++iter)  
  {  
     REnumNode(*iter);  
  }    
  cout << root->pNode->data << " ";    
}  

非递归：（栈）

//多叉树堆栈遍历    
//前序遍历(正序遍历):    
void EnumNode(Node *root)  
{  
  if(NULL == root)
     return;
  stack<Node *> stack;  
  stack.push(root);  
  Node *current;    
  while(!stack.empty())  
  {  
      current = stack.top();                                                                   
      stack.pop();    
      cout << current->pNode->data << " ";   
　　　 if(NULL != current->childsNode.size()){
      　　list<Node *>::reverse_iterator iter; //反向遍历器    
      　　for(iter=current->childsNode.rbegin();iter!=pNode->childsNode.rend();++iter)   //逆序插入栈中
      　　{  
      　　   stack.push(*iter);  
      　　}
　　　　}  
  }    
}  

//后序遍历(反序遍历):    
void REnumNode(Node *root)  
{  
  if(NULL != root)
　　 return;
　stack<Node *> stack;  
  stack.push(root);  
  Node *current;  
  Node *keyNode = NULL; //保存最近一次处理的节点,或者说某个节点的第一个子节点    
  while(!stack.empty())  
  {  
      current = stack.top();  
      //keyNode是 最后一个儿子节点 到 第一个儿子节点 
     //当一个儿子节点遍历过后，再将该儿子节点赋给keyNode
     //当keyNode == *current->childsNode.begin()，表示第一个儿子节点已经遍历完毕，并从栈中弹出。
 　　　　//此时当前节点为其父节点，防止current->childsNode.size()为真，继续遍历儿子节点，
      // 所以加入keyNode != *current->childsNode.begin()避免二次遍历儿子节点
　　　  if (NULL != current->childsNode.size() && keyNode != *current->childsNode.begin())   //size不为0，说明current有孩子

      {  
         list<Node *>::iterator iter; //正向遍历器  
         for(iter = childsNode.begin();iter! = current->childsNode.end();++iter)  
         {  
            stack.push(*iter);  
         }  
       }
　　　　else{   
         cout << current->pNode->data << " ";  
         keyNode = current;
　　　　　 stack.pop();
　　　　}
　　}
}