二叉树的遍历

二叉树的遍历，从大角度看，可以分为DFS(深度优先遍历)和BFS(广度优先遍历)，其中DFS对应着最常用的前序、中序、后序遍历，而BFS对应着层序遍历

下面对每种遍历分别实现其递归和非递归实现：

//二叉树的DFS(前中后序遍历)和BFS(层序遍历)的递归和非递归实现
       

//前序遍历:
       //递归
       void PreOrder_recursive(BiTNode* root)
       {
              if (root == nullptr)
                     return;
              cout << root->data << " ";        //根节点操作
              PreOrder_recursive(root->lchild);
              PreOrder_recursive(root->rchild);
       }
       //非递归
       /*第一种思路：
       对于任一结点P：
     1)访问结点P，并将结点P入栈;
     2)判断结点P的左孩子是否为空，若为空，则取栈顶结点并进行出栈操作，并将栈顶结点的右孩子置为当前的结点P，循环至1);若不为空，则将P的左孩子置为当前的结点P;
     3)直到P为NULL并且栈为空，则遍历结束。*/
       void PreOrder_iterative(BiTNode* root)
       {
              stack<BiTNode*> BTstack;
              BiTNode* currentNode = root;
              while (!BTstack.empty() || currentNode != nullptr)             //栈为空时，表明遍历完成
              {
                     while (currentNode != nullptr)
                     {
                           cout << currentNode->data << " ";
                           BTstack.push(currentNode);
                           currentNode = currentNode->lchild;
                     }
                     if (!BTstack.empty())
                     {
                           currentNode = BTstack.top();
                           BTstack.pop();
                           currentNode = currentNode->rchild;
                     }
              }
       }
       /*第二种思路：在遍历了根结点后，就开始遍历左子树，最后才是右子树。因此可以借助堆栈的数据结构，由于堆栈是后进先出的顺序，由此可以先将右子树压栈，然后再对左子树压栈，
这样一来，左子树结点就存在了栈顶上，因此某结点的左子树能在它的右子树遍历之前被遍历。
       */
       void PreOrder_iterative1(BiTNode* root) {
              stack<BiTNode *> nodeStack;  //使用C++的STL标准模板库
              nodeStack.push(root);
              BiTNode *node;
              while (!nodeStack.empty()) {
                     node = nodeStack.top();
                     cout << node->data << " ";               //访问根结点
                     nodeStack.pop();
                     if (node->rchild) {
                           nodeStack.push(node->rchild);  //先将右子树压栈
                     }
                     if (node->lchild) {
                           nodeStack.push(node->lchild);  //再将左子树压栈
                     }
              }
       }
       

//中序遍历：
       //递归
       void InOrder_recursive(BiTNode* root)
       {
              if (root == nullptr)
                     return;
              InOrder_recursive(root->lchild);
              cout << root->data << " ";
              InOrder_recursive(root->rchild);
       }
       //非递归
       /*对于任一结点P：
       1)将节点入栈;
       2)判断栈顶结点P的左孩子是否为空，若为空，则取栈顶结点进行访问并进行出栈操作，并将栈顶结点的右孩子置为当前的结点P，循环至1);若不为空，则将P的左孩子置为当前的结点P;
       3)直到P为NULL并且栈为空，则遍历结束。*/
       void InOrder_iterative(BiTNode* root)
       {
              stack<BiTNode*> BTstack;
              BiTNode* currentNode = root;
              while (!BTstack.empty() || currentNode != nullptr)
              {
                     while (currentNode != nullptr)
                     {
                           BTstack.push(currentNode);
                           currentNode = currentNode->lchild;
                     }
                     if (!BTstack.empty())
                     {
                           currentNode = BTstack.top();
                           BTstack.pop();
                           cout << currentNode->data << " ";
                           currentNode = currentNode->rchild;
                     }
              }
       }
       

//后序遍历：
       //递归
       void PostOrder_recursive(BiTNode* root)
       {
              if (root == nullptr)
                     return;
              PostOrder_recursive(root->lchild);
              PostOrder_recursive(root->rchild);
              cout << root->data << " ";
       }
       //非递归
       /*第一种思路：对于任一结点P，将其入栈，然后沿其左子树一直往下搜索，直到搜索到没有左孩子的结点，此时该结点出现在栈顶，但是此时不能将其出栈并访问， 因此其右孩子还为被访问。所以接下来按照相同的规则对其右子树进行相同的处理，
       当访问完其右孩子时，该结点又出现在栈顶，此时可以将其出栈并访问。这样就保证了正确的访问顺序。可以看出，在这个过程中，每个结点都两次出现在栈顶，只有在第二次出现在栈顶时，才能访问它。因此需要多设置一个变量标识该结点是 否是第一次出现在栈顶。*/
       struct BTNode
       {
              BiTNode* node;
              bool isFirst;        //标记位用于标记是否第一次访问
       };
       void PostOrder_iterative(BiTNode* root)
       {
              stack<BTNode*> BTstack;
              BiTNode* currentNode = root;
              BTNode* temp = nullptr;
              while (!BTstack.empty() || currentNode != nullptr)
              {
                     while (currentNode != nullptr)
                     {
                           BTNode* btn = new BTNode;
                           btn->node = currentNode;
                           btn->isFirst = true;
                           BTstack.push(btn);
                           currentNode = currentNode->lchild;
                     }
                     if (!BTstack.empty())
                     {
                           temp = BTstack.top();
                           BTstack.pop();
                           if (temp->isFirst == true)                                    //该栈顶之前没有出现过，表明该栈顶节点的右孩子还没有访问过，对右孩子进行访问，当右孩子访问完之后，会再次对该节点进行访问，此时就可以出栈了
                           {
                                  temp->isFirst = false;
                                  BTstack.push(temp);
                                  currentNode = temp->node->rchild;        
                           }
                           else
                           {
                                  cout << temp->node->data << " ";
                                  currentNode = nullptr;
                           }
                     }
              }
       }
       /*第二种思路：要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。如果P不存在左孩子和右孩子，则可以直接访问它；或者P存 在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。
       若非上述两种情况，则将P的右孩子和左孩子依次入栈，这样就保证了 每次取栈顶元素的时候，左孩子在右孩子前面被访问，左孩子和右孩子都在根结点前面被访问。*/
       void PostOrder_iterative1(BiTNode* root)
       {
              stack<BiTNode*> BTstack;
              BiTNode* currentNode = nullptr;          //当前节点
              BiTNode* previousNode = nullptr;  //前一次访问的节点
              BTstack.push(root);
              while (!BTstack.empty())
              {
                     currentNode = BTstack.top();
                     //如果当前节点没有孩子节点或者孩子节点都已经访问过，那么就直接出栈访问          不用怀疑下面这句话为什么可以成立，因为永远都是先访问的左节点再访问的右节点，这个在下面是保证了的
                     if ((currentNode->lchild == nullptr && currentNode->rchild == nullptr) || (previousNode != nullptr) && ((previousNode == currentNode->lchild) || (previousNode == currentNode->rchild)))
                     {
                           cout << currentNode->data << " ";
                           BTstack.pop();
                           previousNode = currentNode;
                     }
                     else         //表明当前节点还有孩子节点没有访问,注意由于是栈，所以要先右孩子进，再左孩子进
                     {
                           if (currentNode->rchild != nullptr)
                                  BTstack.push(currentNode->rchild);
                           if (currentNode->lchild != nullptr)
                                  BTstack.push(currentNode->lchild);
                     }
                                                
              }
       }
       

//层序遍历(BFS)
       //递归
       void Levelorder(BiTNode* root, vector<vector<int>>& res, int level)
       {
              if (root != nullptr)
              {
                     if (level == res.size() + 1)
                           res.push_back({});
                     res[level - 1].push_back(root->data);
                     Levelorder(root->lchild, res, level + 1);
                     Levelorder(root->rchild, res, level + 1);
              }
       }
       void Levelorder_recursive(BiTNode* root)
       {
              vector<vector<int>> res;
              Levelorder(root, res, 1);
              for (int i = 0; i < res.size(); ++i)
              {
                     for (int j = 0; j < res[i].size(); ++j)
                     {
                           cout << res[i][j] << " ";
                     }
                     cout << endl;
              }
       }
       //非递归，需要使用队列实现
       void Levelorder_iterative(BiTNode* root)
       {
              queue<BiTNode*> BTqueue;
              BiTNode* currentNode = nullptr;
              BTqueue.push(root);
              while (!BTqueue.empty())
              {
                     currentNode = BTqueue.front();
                     BTqueue.pop();
                     cout << currentNode->data << " ";
                     if (currentNode->lchild != nullptr)
                           BTqueue.push(currentNode->lchild);
                     if (currentNode->rchild != nullptr)
                           BTqueue.push(currentNode->rchild);
              }
       }