把二元查找树转变成排序的双向链表

题目：
输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。
要求不能创建任何新的结点，只调整指针的指向。
10
/ \
6 14
/ \ / \
4 8 12 16
转换成双向链表
4=6=8=10=12=14=16
16=14=12=10=8=6=4

#include <iostream>
using namespace std;

/*二叉树结点类*/
class Binary_Search_Tree_Node
{
public:
    Binary_Search_Tree_Node() :data(0), left_subtree_address(NULL), right_subtree_address(NULL)
    {
    }
    int data;
    Binary_Search_Tree_Node* left_subtree_address;
    Binary_Search_Tree_Node* right_subtree_address;
};

typedef Binary_Search_Tree_Node* Tree_Node_address;

Tree_Node_address LDR_first_node_address = NULL;/*保存循环链表第一个结点*/
Tree_Node_address tmp_operate = NULL;/*转换操作介参*/


/* 建立二叉排序树 */
void Add_Tree_Node(Tree_Node_address& current_node_address, int value)
{
    if (!current_node_address){
        Tree_Node_address node_address = new Binary_Search_Tree_Node;
        if(!node_address)
            cout << "分配内存失败" << endl;
        node_address->data = value;
        node_address->left_subtree_address = NULL;
        node_address->right_subtree_address = NULL;
        current_node_address = node_address;
    }
    else if (current_node_address->data < value) /*大的放右边*/
        Add_Tree_Node(current_node_address->right_subtree_address, value);
    else if (current_node_address->data > value) /*小的放左边*/
        Add_Tree_Node(current_node_address->left_subtree_address, value);
    else
        cout << "node repeated" << endl;

}


/* 打印双向链表链表 */
void Print_List(Tree_Node_address first_node_address)
{
    if (!first_node_address)
        return;
    while (first_node_address->right_subtree_address) 
    {
        cout << first_node_address->data << " ";
        first_node_address = first_node_address->right_subtree_address;
    }

    cout << first_node_address->data << endl;
    while (first_node_address)
    {
        cout << first_node_address->data << " ";
        first_node_address = first_node_address->left_subtree_address;
    }

}


/* 调整结点保存的右子树指针成 -> 双向链表 */
void Tree_To_List(Tree_Node_address current_node_address)
{

    current_node_address->left_subtree_address = tmp_operate;                               

    if (NULL == tmp_operate)                                                                    
        LDR_first_node_address = current_node_address;/*定头结点*/
    else                                                                                
        tmp_operate->right_subtree_address = current_node_address;/*换指向*/

    tmp_operate = current_node_address;                                                     

}


/* 中序遍历二叉树(递归) */
void Inorder_Traversal_Tree(Tree_Node_address current_node_address)
{

    if (NULL == current_node_address)
        return;

    if (current_node_address->left_subtree_address)
        Inorder_Traversal_Tree(current_node_address->left_subtree_address);

    Tree_To_List(current_node_address);/* 调整结点指针 */

    if (current_node_address->right_subtree_address)
        Inorder_Traversal_Tree(current_node_address->right_subtree_address);

}


/* 测试函数 */
int main()
{
    Tree_Node_address first_node_address = NULL;

    Add_Tree_Node(first_node_address, 10);

    Add_Tree_Node(first_node_address, 6);

    Add_Tree_Node(first_node_address, 14);

    Add_Tree_Node(first_node_address, 4);

    Add_Tree_Node(first_node_address, 8);

    Add_Tree_Node(first_node_address, 12);

    Add_Tree_Node(first_node_address, 16);

    Inorder_Traversal_Tree(first_node_address);

    Print_List(LDR_first_node_address);

    return 0;
}