将二叉搜索树转换成一个排序的双向链表

题目：将二叉搜索树转换成一个排序的双向链表。提示：要求不能创建任何新的结点，只能调整树中结点指针的指向，也就是left当prev，right当next。–中序线索化的变型。



1、由于要求链表是有序的，可以借助二叉树中序遍历，因为中序遍历算法的特点就是从小到大访问结点。当遍历访问到根结点时，假设根结点的左侧已经处理好，只需将根结点与上次访问的最近结点（左子树中最大值结点）的指针连接好即可。进而更新当前链表的最后一个结点指针。

2、由于中序遍历过程正好是转换成链表的过程，即可采用递归处理。

中序遍历该二叉树的结果：





把二叉搜索树看成三部分：根节点，左子树和右子树。在把左，右子树都转换成排序的双向链表之后再和根节点链接起来，整棵二叉搜索也就转换成了排序的双向链表。

二叉搜索树的结点：

template<class K, class V>          //键值队
struct BSTNode
{
BSTNode(const K& key, const V& value)
: _pLeft(NULL)
, _pRight(NULL)
,_pParent(NULL)
, _key(key)
, _value(value)
{}

BSTNode<K, V>* _pLeft;
BSTNode<K, V>* _pRight;
BSTNode<K, V>* _pParent;
K _key;
V _value;
};

template<class K, class V>
class BinarySearchTree
{
typedef BSTNode<K, V> Node;
typedef BinarySearchTree<K, V> Self;
public:
BinarySearchTree()
: _pRoot(NULL)
{}
//拷贝构造函数
//BinarySearchTree(const Self& bst);
//赋值运算符重载
//Self& operator=(const Self& bst);
//析构函数
~BinarySearchTree()
{
_DestroyTree(_pRoot);
}

// 查找--非递归
bool Find_Nor(const K& key)
{
Node* pCur = _pRoot;
while (pCur)  //二叉树存在
{
if (pCur->_key == key)
return true;
else if (key < pCur->_key)
return pCur = pCur->_pLeft;
else
pCur = pCur->_pRight;
}
return false;
}
//递归查找
bool Find(const K& key)
{
return _Find(_pRoot, key);
}

// 插入--非递归
bool Insert_Nor(const K& key, const V& value)  //插入某元素
{
if (NULL == _pRoot)
{
_pRoot = new Node(key, value);
return true;
}
//找元素插入位置
Node* pCur = _pRoot;
Node* pParent = NULL;  //标记
while (pCur)
{
if (key < pCur->_key)
{
pParent = pCur;
pCur = pCur->_pLeft ;  //新插入的结点保存在左子树
}
else if (key > pCur->_key)
{
pParent = pCur;
pCur = pCur->_pRight;   //新插入的结点保存在右子树
}
else
return false;
}
pCur = new Node(key, value);
if (key < pParent->_key)
//pParent = pParent->_pLeft ;
pParent->_pLeft = pCur;
else if (key > pParent->_key)
//pParent = pParent->_pRight;
pParent->_pRight = pCur;
else
return false;

}
//  递归--插入
bool Insert(const K& key, const V& value)
{
return _Insert(_pRoot, key, value);  //
}
void InOrder()
{
cout << "InOrder(): " << endl;
_InOrder(_pRoot);
cout << endl;
}
//二叉搜索树与双向链表
Node* Convert()  //_pRoot
{
Node* pLastNodeInList = NULL;
ConvertNode(_pRoot, &pLastNodeInList);   //pLastNodeInList-->双向链表的尾结点
//返回头结点
Node* pHeadOfList = pLastNodeInList;
while (pHeadOfList != NULL && pHeadOfList->_pLeft != NULL)
pHeadOfList =  pHeadOfList->_pLeft;
return pHeadOfList;
}
private:
bool _Find(Node* pRoot, const K& key)
{
if (pRoot)  //二叉树存在
{
if (key == pRoot->_key)  //查找的值在左子树中
return true;
else if (key < pRoot->_key)
return  _Find(pRoot->_pLeft, key); // 查找的值在左子树中
else
return _Find(pRoot->_pRight, key);  //查找的值在右子树中

}
return false; //树不存在
}

bool _Insert(Node* &pRoot, const K& key, const V& value)  //---
{
if (NULL == pRoot)  //1）、树为空，插入结点作为根结点
{
pRoot = new Node(key, value);
return true;
}
else  //二叉树存在--插入的结点在左右子树中
{
if (key < pRoot->_key)
return _Insert(pRoot->_pLeft, key, value);  //
else if (key > pRoot->_key)
return _Insert(pRoot->_pRight, key, value);  //
else
return false;
}
}

void _InOrder(Node* pRoot)  //Node* pRoot--中序遍历
{
if(pRoot)
{
//遍历左子树
_InOrder(pRoot->_pLeft);
cout<<pRoot->_key<<" ";
_InOrder(pRoot->_pRight);  //遍历右子树
}
}

//二叉搜索树与双向链表
void ConvertNode(Node* pRoot, Node** pLastNodeInList)
{
if (NULL == pRoot)
return;
Node* pCur = pRoot;
if (NULL != pCur->_pLeft)  //递归处理左子树
ConvertNode(pCur->_pLeft, pLastNodeInList);
//pCur--处理当前结点，将当前结点的左指针指向链表的尾结点
pCur->_pLeft = *pLastNodeInList;  //pLastNodeInList-->双向链表的尾结点
if (NULL != *pLastNodeInList)
(*pLastNodeInList)->_pRight = pCur;
//更新已经转换好的链表的尾结点
*pLastNodeInList = pCur;

//递归处理右子树
if (NULL != pCur->_pRight)
ConvertNode(pCur->_pRight, pLastNodeInList);
}
void _DestroyTree(Node*& pRoot)
{
if (pRoot)
{
_DestroyTree(pRoot->_pLeft);
_DestroyTree(pRoot->_pRight);
delete pRoot;
pRoot = NULL;
}
}
private:
Node* _pRoot;
};