搜索二叉树和双向链表

递归实现

1、解题思路：

1.将左子树构造成双链表，并返回链表头节点。
2.定位至左子树双链表最后一个节点。
3.如果左子树链表不为空的话，将当前root追加到左子树链表。
4.将右子树构造成双链表，并返回链表头节点。
5.如果右子树链表不为空的话，将该链表追加到root节点之后。
6.根据左子树链表是否为空确定返回的节点。

2、实现代码

void ConvertNode(BinaryNode* pRootTree, BinaryNode*& pListNode)
{
	if (pRootTree == NULL)
		return;
	BinaryNode* pConvert = pRootTree;
	ConvertNode(pConvert->_left, pListNode);//将左孩子构造成双向链表
	pConvert->_left = pListNode;
	if (pListNode)
		pListNode->_right = pConvert;
	pListNode = pConvert;
	ConvertNode(pConvert->_right, pListNode);//将右孩子构造成双向链表
}
BinaryNode* Convert(BinaryNode* pRootOfTree)
{
	BinaryNode* pListNode = NULL;
	ConvertNode(pRootOfTree, pListNode);
	BinaryNode* pListHead = pRootOfTree;
	while (pListHead->_left)
		pListHead = pListHead->_left;
	return pListHead;
}

循环实现

1、解题思路：

1、遍历左子树直到最小的的结点，标记为双向链表的头结点。

2、最小结点向根遍历，转换为双向链表，直到根结点。

3、根结点的右子树遍历，转换为双向链表。

2、实现代码

BinaryNode* ConvertList(BinaryNode* pRootOfTree)
{
	if (pRootOfTree == NULL)
		return NULL;
	BinaryNode* Temp = pRootOfTree;
	BinaryNode* result = NULL;
	stack<BinaryNode* > s;
	while (Temp || !s.empty())
	{
		while (Temp)//左子树遍历完
		{
			s.push(Temp);
			Temp = Temp->_left;
		}
		Temp = s.top();
		s.pop();
		if (result == NULL)
		{
			result = Temp;
			pRootOfTree = result;
		}
		else
		{
			result->_right = Temp;
			Temp->_left = result;
			result = Temp;
		}
		Temp = Temp->_right;
	}
	return pRootOfTree;
}

测试用例

BinaryNode* CreateBinaryTree(int* array, int length)//创建搜索二叉树
{
	BinaryNode* root = new BinaryNode(array[0]);
	BinaryNode* pTemp = NULL;
	for (int idx = 1; idx < length; idx++)
	{
		BinaryNode* pCur = root;
		//寻找插入位置
		while (pCur)
		{
			if (array[idx]<pCur->_value)
			{
				pTemp = pCur;
				pCur = pCur->_left;
			}
			else if (array[idx]>pCur->_value)
			{
				pTemp = pCur;
				pCur = pCur->_right;
			}
			else
				return NULL;
		}
		//插入元素
		pCur = new BinaryNode(array[idx]);
		if (array[idx] < pTemp->_value)
			pTemp->_left = pCur;
		else
			pTemp->_right = pCur;
	}
	return root;
}

void FunTest5()
{
	BinaryNode* pRoot = NULL;
	int array[] = { 10, 6, 14, 4, 8, 12, 16 };
	int length = sizeof(array) / sizeof(array[0]);
	pRoot = CreateBinaryTree(array, length);
	//BinaryNode* pList = Convert(pRoot);//递归实现
	BinaryNode* pConvertList = ConvertList(pRoot);//循环实现
}