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

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

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

在二叉搜索树中，每个结点都有两个指向子节点的指针，在双向链表中，每个结点也有两个指针，分别指向前一个结点和后一个结点。在二叉搜索树中，左子节点的值总是小于右子结点的值，右子结点的值总是大于父节点的值。因此，我们在转换为双向链表时，原先指向左子节点的指针调整为链表中指向前一个节点的指针，原先指向右子结点的指针调整为链表中指向后一个结点的指针。

例如：

要求将二叉搜索树转换成一个排序的双向链表，我们可以中序遍历每一个节点。当遍历到根节点时，将树看为3部分：值为4的节点，根节点为2的左子树，根节点为6的右子树，根据排序好的链表可以看出应当把结点4的left指针指向3，把结点3的right指针指向4，结点4的左子树已经转换为一个有序的双向链表，并且结点3是这个已经转化的双向链表的尾结点，我们可以用一个变量lastNode来保存最后一个结点的指针，方便与根节点连续时使用，然后将这个变量的值更新为指向根节点4，对于结点4的右子树采用相同的逻辑。

代码实现：

#include 
using namespace std;
template 
struct BinaryTreeNode
{
	BinaryTreeNode* _left;
	BinaryTreeNode* _right;
	T _data;

	BinaryTreeNode(const T& x)
		:_left(NULL)
		,_right(NULL)
		, _data(x)
	{}

};


template 
class BinaryTree
{
	typedef BinaryTreeNode Node;
public:
	BinaryTree()
		:_root(NULL)
	{}

	~BinaryTree()
	{
		Destroy(_root);
	}

	void Destroy(Node* root)
	{
		if (root == NULL)
			return;
		Destroy(root->_left);
		Destroy(root->_right);
		delete root;
	}

	bool Insert(const T& x)        //构成搜索二叉树
	{
		if (_root == NULL)
		{
			_root = new Node(x);
			return true;
		}
		Node* parent = NULL;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_data > x)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_data < x)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;  //不能有相同的_data;
			}
		}
		if (parent->_data < x)
		{
			parent->_right = new Node(x);
			return true;
		}
		if (parent->_data > x)
		{
			parent->_left = new Node(x);
			return true;
		}
		return false;
	}

	void InOrder()        //中序遍历二叉树
	{
		_InOrder(_root);
		cout << endl;
	}



	Node* Convert()
	{
		return _Convert(_root);
	}

	void ConvertNode(Node* root, Node** lastNode)    
	{
		if (root == NULL)
			return ;

		if (root->_left)        //找到最左节点，即转换后链表的头结点
			ConvertNode(root->_left, lastNode);
		root->_left = *lastNode;  //调整root的左指针，指向左子树的最后一个结点
		if (*lastNode != NULL)
			(*lastNode)->_right = root;//调整左子树所构成链表的最后一个结点指向根节点，将其连接起来
		*lastNode = root;              //调整指向最后一个结点的指针
		if (root->_right != NULL)      //依次对右子树进行转换，lastNode是转换后链表的最后一个结点的指针
			ConvertNode(root->_right, lastNode);
	}

	void Printf1()
	{
		Node* cur = _root;
		while (cur->_left!=NULL)
		{
			cur = cur->_left;
		}
		while (cur)
		{
			cout << cur->_data << " ";
			cur = cur->_right;
		}
		cout << endl;
	}
	void Printf2()
	{
		Node* cur = _root;
		while (cur->_right!=NULL)
		{
			cur = cur->_right;
		}
		while (cur)
		{
			cout << cur->_data << " ";
			cur = cur->_left;
		}
		cout << endl;
	}

protected:
	void _InOrder(Node* root)
	{
		if (root == NULL)
			return;
		_InOrder(root->_left);
		cout << root->_data << " ";
		_InOrder(root->_right);
	}

	
	Node* _Convert(Node* rootOfTree)
	{
		Node* lastNode = NULL;
		ConvertNode(rootOfTree, &lastNode);

		Node* HeadOfList = lastNode;   //lastNode指向双向链表的尾结点，需要返回头结点
		while (HeadOfList != NULL && HeadOfList->_left != NULL)
			HeadOfList = HeadOfList->_left;
		return HeadOfList;
	}

protected:
	Node* _root;
};

void Test()
{

	int arr[] = { 11, 23, 1, 4, 5, 7, 8, 10, 9 };
	size_t size = sizeof(arr) / sizeof(arr[0]);
	BinaryTree s;
	for (size_t i = 0; i < size; ++i)
	{
		s.Insert(arr[i]);
	}
	cout << "搜索二叉树中序遍历：" << " ";
	s.InOrder();

	BinaryTreeNode* head = s.Convert();
	cout << "双向链表从左到右序列：" << "";
	s.Printf1();
	cout << "双向链表从右到序列：" << "";
	s.Printf2();

}empty

测试结果：