按锯齿形遍历的顺序展平二叉树

给定二叉树，任务是按ZigZag遍历树的顺序对其进行展平。在扁平化的二叉树中，所有节点的左节点必须为NULL。

例子：

Input: 
          1 
        /   \ 
       5     2 
      / \   / \ 
     6   4 9   3 
Output: 1 2 5 6 4 9 3

Input:
      1
       \
        2
         \
          3
           \
            4
             \
              5
Output: 1 2 3 4 5

方法：我们将通过模拟二叉树的ZigZag遍历来解决此问题。
算法：

1. 创建两个堆栈“ c_lev”和“ n_lev”，并存储当前和下一个二进制树的节点。
2. 创建一个变量“ prev”，并通过父节点对其进行初始化。
3. 在c_lev堆栈中推送父母的左右孩子。
4. 应用ZigZag遍历。可以说“ curr”是“ c_lev”中最重要的元素。然后，
   • 如果’curr’为NULL，则继续。
   • 否则按适当的顺序将curr-> left和curr-> right压入堆栈“ n_lev”。如果我们正在执行从左到右的遍历，则先推curr-> left，否则先推curr-> right。
   • 设置prev = curr。

下面是上述方法的实现：

// C++ implementation of the approach
#include 
using namespace std;
  
// Node of the binary tree
struct node {
    int data;
    node* left;
    node* right;
    node(int data)
    {
        this->data = data;
        left = NULL;
        right = NULL;
    }
};
  
// Function to flatten Binary tree
void flatten(node* parent)
{
    // Queue to store node
    // for BFS
    stack c_lev, n_lev;
  
    c_lev.push(parent->left);
    c_lev.push(parent->right);
  
    bool lev = 1;
    node* prev = parent;
  
    // Code for BFS
    while (c_lev.size()) {
  
        // Size of queue
        while (c_lev.size()) {
  
            // Front most node in
            // queue
            node* curr = c_lev.top();
            c_lev.pop();
  
            // Base case
            if (curr == NULL)
                continue;
            prev->right = curr;
            prev->left = NULL;
            prev = curr;
  
            // Pushing new elements
            // in queue
            if (!lev)
                n_lev.push(curr->left);
            n_lev.push(curr->right);
            if (lev)
                n_lev.push(curr->left);
        }
        lev = (!lev);
        c_lev = n_lev;
        while (n_lev.size())
            n_lev.pop();
    }
  
    prev->left = NULL;
    prev->right = NULL;
}
  
// Function to print flattened
// binary tree
void print(node* parent)
{
    node* curr = parent;
    while (curr != NULL)
        cout << curr->data << " ", curr = curr->right;
}
  
// Driver code
int main()
{
    node* root = new node(1);
    root->left = new node(5);
    root->right = new node(2);
    root->left->left = new node(6);
    root->left->right = new node(4);
    root->right->left = new node(9);
    root->right->right = new node(3);
  
    // Calling required functions
    flatten(root);
  
    print(root);
  
    return 0;
}

输出：

1 2 5 6 4 9 3

时间复杂度： O(N)
空间复杂度： O(N)，其中N是二叉树的大小。

想要从精选的最佳视频中学习并解决问题，请查看有关从基础到高级C++的C++基础课程以及有关语言和STL的C++ STL课程。要完成从学习语言到DS Algo等的更多准备工作，请参阅“完整面试准备课程” 。