剑指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;    }};