将BST展平到排序列表|订单增加

给定一个二叉搜索树，任务是将其展平为一个有序列表。精确地，每个节点的值必须小于其右侧所有节点的值，并且在展平后其左侧节点必须为NULL。我们必须在O(H)额外空间中执行此操作，其中“ H”是BST的高度。

例子：

Input: 
          5 
        /   \ 
       3     7 
      / \   / \ 
     2   4 6   8
Output: 2 3 4 5 6 7 8
Input:
      1
       \
        2
         \
          3
           \
            4
             \
              5
Output: 1 2 3 4 5

方法：一种简单的方法是根据其顺序遍历重新创建BST。如果N是BST中的节点数，则将占用O(N)额外空间。
为了改善这一点，我们将按以下顺序模拟遍历二叉树：

1. 创建一个虚拟节点。
2. 创建一个名为“ prev”的变量，使其指向虚拟节点。
3. 在每个步骤中依次执行遍历。
   • 设置上一个->右=当前
   • 设置prev-> left = NULL
   • 设置上一个= curr

在最坏的情况下，这将使空间复杂度提高到O(H)，因为有序遍历会占用O(H)额外的空间。

下面是上述方法的实现：

// 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 print flattened
// binary Tree
void print(node* parent)
{
    node* curr = parent;
    while (curr != NULL)
        cout << curr->data << " ", curr = curr->right;
}
  
// Function to perform in-order traversal
// recursively
void inorder(node* curr, node*& prev)
{
    // Base case
    if (curr == NULL)
        return;
    inorder(curr->left, prev);
    prev->left = NULL;
    prev->right = curr;
    prev = curr;
    inorder(curr->right, prev);
}
  
// Function to flatten binary tree using
// level order traversal
node* flatten(node* parent)
{
    // Dummy node
    node* dummy = new node(-1);
  
    // Pointer to previous element
    node* prev = dummy;
  
    // Calling in-order traversal
    inorder(parent, prev);
  
    prev->left = NULL;
    prev->right = NULL;
    node* ret = dummy->right;
  
    // Delete dummy node
    delete dummy;
    return ret;
}
  
// Driver code
int main()
{
    node* root = new node(5);
    root->left = new node(3);
    root->right = new node(7);
    root->left->left = new node(2);
    root->left->right = new node(4);
    root->right->left = new node(6);
    root->right->right = new node(8);
  
    // Calling required function
    print(flatten(root));
  
    return 0;
}

输出：

2 3 4 5 6 7 8