Flatten BST to Double Linked List

Two ways:

1: recursion, to transform in in-order.

2: Iterative, BFS way.

/*
  Flatten BST into linkedlist (in-order).
*/
#include <vector>
#include <queue>
#include <iostream>
using namespace std;

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

TreeNode* constructBST() {
  TreeNode* root = new TreeNode(3);
  TreeNode* right = new TreeNode(4);
  TreeNode* left = new TreeNode(2);
  root->right = right;
  root->left = left;
  return root;
}

TreeNode* flatten(TreeNode* root) {
  TreeNode* head = NULL;
  TreeNode* end = NULL;
  queue<TreeNode*> nodes;
  nodes.push(root);
  while(!nodes.empty()) {
    TreeNode* node = nodes.front();
    nodes.pop();
    if(node->left) nodes.push(node->left);
    if(node->right) nodes.push(node->right);
    node->left = end;
    if(end == NULL) {
      end = head = node;
    } else {
      end->right = node;
    }
    end = node;
  }
  return head;
}
// Recursive way which is to put BST tree to in-order linked list.
TreeNode* flattenBST(TreeNode* root, TreeNode*& end, TreeNode*& head) {
  TreeNode* tmp = root;
  if(!tmp) return NULL;
  flattenBST(tmp->left, end, head);
  tmp->left = end;
  if(end == NULL) {
    end = head = tmp;
  } else {
    end->right = tmp;
  }
  end = tmp;
  flattenBST(tmp->right, end, head);
}

int main(void) {
  TreeNode* root = constructBST();
//  TreeNode* end = NULL;
//  TreeNode* head = NULL;
//  flattenBST(root, end, head);
//  while(head) {
//    cout << head->val << endl;
//    head = head->right;
//  }

  cout << "another" << endl;
  TreeNode* newHead = flatten(root);
  while(newHead) {
    cout << newHead->val << endl;
    newHead = newHead->right;
  }
}