剑指Offer_面试题27_二叉搜索树与双向链表

题目描述

输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。

分析：题目的意思是用二叉树结点指针left、right代替pre、next构成双向链表。二叉搜索树的中序序列有序，只要把结点按照中序遍历的顺序链接起来就行。但是需要知道中序的前一个结点。为了方便获取前一个结点，首先用中序遍历非递归方法，即使用栈来遍历，实现链接。

非递归：

#include <stdio.h>
#include <stdlib.h>
#include <stack>
using namespace std;

struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
		val(x), left(NULL), right(NULL) {
	}
};

//解法一：中序遍历非递归
TreeNode* Convert(TreeNode* root)
{
	stack<TreeNode*> nodeStack;
	TreeNode *p = root;
	TreeNode *pre = NULL;    //指向中序遍历上一个结点
	bool isFirst = true;     //第一个结点
	while (!(p == NULL && nodeStack.empty()))   //p为空栈为空则遍历完
	{
		while (p != NULL)
		{
			nodeStack.push(p);
			p = p->left;
		}
		p = nodeStack.top();
		nodeStack.pop();
		//链接
		if (isFirst)//判断是否是中序第一个结点
		{
			root = p;
			pre = root;
			isFirst = false;
		}
		else {
			pre->right = p;
			p->left = pre;
			pre = p;
		}

		p = p->right;
	}
	return root;
}

既然中序非递归可以实现，那么递归同样也可以，只需要有一个记录前一个结点的全局变量或者引用、指针参数

中序递归：

//中序递归本体
void ConvertRes(TreeNode *cur, TreeNode *& pre)
{
	if (cur == NULL) return;

	ConvertRes(cur->left, pre);

	cur->left = pre;
	if(pre)
		pre->right = cur;
	pre = cur;

	ConvertRes(cur->right, pre);
	
}
//解法二：中序递归法
TreeNode *Convert2(TreeNode *root)
{
	if (root == NULL) return NULL;
	TreeNode *pre = NULL;
	ConvertRes(root, pre);

	TreeNode *res = root;
	while (res->left)
		res = res->left;
	return res;
}

测试中按照 剑指offer6根据先序序列和中序序列重建二叉树

//剑指offer原书版，根据先序遍历序列、中序遍历序列重建二叉树      
TreeNode* ConstructByPreIn(int *preOrder, int *inOrder, int length)
{
	if (preOrder == NULL || inOrder == NULL || length <= 0) return NULL;
	//新建结点,当前先序序列第一个元素为根结点      
	int root_val = preOrder[0];
	TreeNode *root = new TreeNode(root_val);
	//初始化左右子树参数      
	int leftLength = 0;
	int rightLength = 0;
	//在中序序列中找到根节点的位置（必存在）      
	for (int i = 0; i < length; i++)
	{
		if (inOrder[i] == root_val)
		{
			leftLength = i;
			rightLength = length - i - 1;
			break;
		}
	}
	//中序序列中，根节点左边的为左子树，右边的为右子树      
	int *leftPre = preOrder + 1;
	int *leftIn = inOrder;
	int *rightPre = preOrder + leftLength + 1;
	int *rightIn = inOrder + leftLength + 1;
	//递归构建左右子树      
	root->left = ConstructByPreIn(leftPre, leftIn, leftLength);
	root->right = ConstructByPreIn(rightPre, rightIn, rightLength);
	return root;

}

测试代码：

//正逆向打印双链表
void PrintDeList(TreeNode *head)
{
	TreeNode *rear = NULL;
	printf("正序：");
	while (head != NULL)
	{
		printf("%d ", head->val);
		if (head->right == NULL)
			rear = head;
		head = head->right;
	}
	printf("\n逆序：");
	while (rear != NULL)
	{
		printf("%d ", rear->val);
		rear = rear->left;
	}
	printf("\n");
}

int main()
{
	//建树
	int pre[] = {10, 6, 4, 8, 14, 12, 16};
	int in[] = {4,6,8,10,12,14,16};
	TreeNode *root = ConstructByPreIn(pre, in, 7);
	//改链表
	root = Convert(root);
	//输出结果
	PrintDeList(root);

	//建树2
	int pre2[] = { 10, 6, 4, 8, 14, 12, 16 };
	int in2[] = { 4,6,8,10,12,14,16 };
	TreeNode *root2 = ConstructByPreIn(pre2, in2, 7);
	//改链表
	root2 = Convert2(root2);
	//输出结果
	PrintDeList(root2);

	getchar();
	return 0;
}

结果：

原版书上的解法是递归实现，是先让左子树有序，保存它的尾结点，再让右子树有序，保存它的头结点，然后和 root 链接起来。感觉理解起来比较麻烦，还是用中序递归或非递归实现，简洁明了。