剑指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 链接起来。感觉理解起来比较麻烦，还是用中序递归或非递归实现，简洁明了。