剑指offer 编程题（25）：二叉树搜索与双向链表

题目描述

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

在二叉搜索树中，每个结点都有两个分别指向其左、右子树的指针，左子树结点的值总是小于父结点的值，右子树结点的值总是大于父结点的值。而在双向链表中，每个结点也有两个指针，它们分别指向前一个结点和后一个结点。所以这两种数据结构的结点是一致，二叉搜索树之所以为二叉搜索树，双向链表之所以为双向链表，只是因为两个指针的指向不同而已，通过改变其指针的指向来实现是完全可能的。

例如如下的二叉搜索树，



若采用中序遍历，其遍历顺序为1-2-3-4-5-6-7，通过适当的指针变换操作，可变成的双向有序链表如下：

class Solution {
public:
TreeNode* Convert(TreeNode* pRootOfTree)
{
if(pRootOfTree == nullptr) return nullptr;
TreeNode* pre = nullptr;

convertHelper(pRootOfTree, pre);

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

void convertHelper(TreeNode* cur, TreeNode*& pre)
{
if(cur == nullptr) return;

convertHelper(cur ->left, pre);

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

convertHelper(cur ->right, pre);

}
};

class Solution {
public:
TreeNode* Convert(TreeNode* pRootOfTree)
{
if (pRootOfTree == NULL)return NULL;
TreeNode *pointer = NULL;
convert2List(pRootOfTree, pointer);
while (pointer->left!=NULL)
{
pointer = pointer->left;
}
return pointer;
}
void convert2List(TreeNode* pRoot,TreeNode *&pointer)
{
if (pRoot == NULL)
{
return;
}
{
if (pRoot->left != NULL)
{
convert2List(pRoot->left,pointer);
}

pRoot->left = pointer;
if (pointer != NULL)
{
pointer->right = pRoot;
}

pointer = pRoot;
if (pRoot->right!=NULL)
{
convert2List(pRoot->right, pointer);
}
}
}
};

可以中序遍历，然后push到一个vector里面，再连接成链表，此方法可以实现，但是违反题目不能创建新空间的规定，属于犯规作弊

class Solution {
public:
vector<TreeNode*> nodes;

void tranverse(TreeNode* pRoot) {
if (nullptr == pRoot)
return;
tranverse(pRoot->left);
nodes.push_back(pRoot);
tranverse(pRoot->right);
}

TreeNode* adjustTree() {
for (int i = 0; i < nodes.size() - 1; ++i)
nodes[i]->right = nodes[i+1];
nodes[nodes.size()-1]->right = nullptr;
for (int i = nodes.size() - 1; i > 0; --i)
nodes[i]->left = nodes[i-1];
nodes[0]->left = nullptr;
return nodes[0];
}

TreeNode* Convert(TreeNode* pRoot)
{
if (nullptr == pRoot)
return nullptr;
tranverse(pRoot);
return adjustTree();
}
};

非递归中序遍历

void inOrder2(BinTree *root)      //非递归中序遍历
{
stack<BinTree*> s;
BinTree *p=root;
while(p!=NULL||!s.empty())
{
while(p!=NULL)
{
s.push(p);
p=p->lchild;
}
if(!s.empty())
{
p=s.top();
cout<<p->data<<" ";
s.pop();
p=p->rchild;
}
}
}

/*
非递归中序遍历，加个指针pre记录上一次出栈值
*/
class Solution {
public:
TreeNode* Convert(TreeNode* pRootOfTree)
{
TreeNode *head = NULL, *pre = NULL;//head 输出，pre记录上一次出栈值
stack<TreeNode*> s;
while (pRootOfTree || !s.empty())
{
while (pRootOfTree)
{
s.push(pRootOfTree);
pRootOfTree = pRootOfTree->left;
}
if (!s.empty())
{
pRootOfTree = s.top();
s.pop();
if (pre != NULL)
{
pre->right = pRootOfTree;
pRootOfTree->left = pre;
}
else//pre为空，表示s第一次出栈，第一次出栈值为最左值，即输出值
{
head = pRootOfTree;
}
pre = pRootOfTree;
pRootOfTree = pRootOfTree->right;
}
}
return head;
}
};