一个bug啊！！！怎么查不出来啊！！！简单的树结构问题！！！

编july出的第一道题，出现小bug却怎么也查不出来啊！！！谁帮我看一下？
原题：
=====================================================
1.把二元查找树转变成排序的双向链表
题目：
输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。
要求不能创建任何新的结点，只调整指针的指向。

10
/ \
6 14
/ \ / \
4 8 12 16

转换成双向链表
4=6=8=10=12=14=16。

首先我们定义的二元查找树 节点的数据结构如下：
struct BSTreeNode
{
int m_nValue; // value of node
BSTreeNode *m_pLeft; // left child of node
BSTreeNode *m_pRight; // right child of node
};
=======================================================================
#include<iostream>
#include<Windows.h>
using namespace std;
struct Node{
int value;
Node* left;
Node* right;
};
struct Tree{
Node* parent;
};

int minimum(const Node* node){
while(node->left)
node=node->left;
return node->value;
}

int maximum(const Node* node){
while(node->right)
node=node->right;
return node->value;
}

void insert(Tree* &tree, int value){
Node* pNode=tree->parent;
if(pNode==NULL){
Node* nNode=new Node;
nNode->left=NULL;
nNode->right=NULL;
nNode->value=value;
tree->parent=nNode;
return;
}
while(1){
if(value<pNode->value){
if(pNode->left)
pNode=pNode->left;
else{
Node* nNode=new Node;
nNode->left=NULL;
nNode->right=NULL;
nNode->value=value;
pNode->left=nNode;
return;
}
}
else{
if(pNode->right)
pNode=pNode->right;
else{
Node* nNode=new Node;
nNode->left=NULL;
nNode->right=NULL;
nNode->value=value;
pNode->right=nNode;
return;
}
}
}
}

int inSearch(const Node* node, int value){
if(node==NULL)
return -1;
if(node->value==value)
return value;
if(value<node->value)
return inSearch(node->left, value);
else
return inSearch(node->right, value);
}

int search(const Tree* tree, int value){
return inSearch(tree->parent,value);
}

void internalPreOrder(const Node* node){
if(node==NULL)
return;
cout<<node->value<<'\t';
internalPreOrder(node->left);
internalPreOrder(node->right);
}

void preOrder(const Tree* tree){
internalPreOrder(tree->parent);
}

void internalInOrder(const Node* node){
if(node==NULL)
return;
internalInOrder(node->left);
cout<<node->value<<'\t';
internalInOrder(node->right);
}

void inOrder(const Tree* tree){
internalInOrder(tree->parent);
}

void internalPostOrder(const Node* node){
if(node==NULL)
return;
internalPostOrder(node->left);
internalPostOrder(node->right);
cout<<node->value<<'\t';
}

void postOrder(const Tree* tree){
internalPostOrder(tree->parent);
}

void convert(Node* &node, Node* &nodeList){
node->left=nodeList;
if(nodeList!=NULL){
nodeList->right=node;
}
cout<<"convert"<<endl;
nodeList=node;
nodeList->right=node->right;
cout<<node->value<<endl;
}

void internalInOrderConv(Node* &treeNode, Node* &nodeList){
if(treeNode==NULL){
cout<<"this is null"<<endl;
return;
}
if(treeNode->left!=NULL){
cout<<treeNode->value<<"+left"<<endl;
Sleep(100);
internalInOrderConv(treeNode->left, nodeList);
}
convert(treeNode, nodeList);
if(treeNode->right!=NULL){
cout<<treeNode->value<<"+right"<<endl;
internalInOrderConv(treeNode->right, nodeList);
}
}

void inOrderConv(Tree* &tree, Node* &nodeList){
internalInOrderConv(tree->parent, nodeList);
}


void main(){
Tree* tree=new Tree;
tree->parent=NULL;
insert(tree, 10);
insert(tree, 6);
insert(tree, 14);
insert(tree, 4);
insert(tree, 5);
insert(tree, 13);
insert(tree, 16);
postOrder(tree);
cout<<endl;
inOrder(tree);
cout<<endl;
preOrder(tree);
cout<<endl;
Node* pNode=NULL;
inOrderConv(tree, pNode);
system("pause");
}