26、剑指offer--二叉搜索树与双向链表

题目描述

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

 

解题思路：在二叉搜索树中，左结点<根节点<右节点，因此中序遍历就是排序好的。

在我们遍历转换到根节点时，它的左子树已经排好序的链表，并且处于链表中的最后一个结点为当前值最大结点。我们把该值与根结点连接起来。此时链表中最后一个结点为根结点，接着遍历右子树，并把根结点与右子树中最小的结点链接起来。使用递归进行实现。

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/
class Solution {
public:
    void CovertNode(TreeNode *root,TreeNode **pLastNodeInitList)
    {
        if(root == NULL)
            return;
        TreeNode *pCurrent = root;
        if(pCurrent->left)
        {
            CovertNode(pCurrent->left,pLastNodeInitList);
        }
        pCurrent->left = *pLastNodeInitList;
        if(*pLastNodeInitList != NULL)
            (*pLastNodeInitList)->right = pCurrent;
        *pLastNodeInitList = pCurrent;
        if(pCurrent->right != NULL)
        {
            CovertNode(pCurrent->right,pLastNodeInitList);
        }
    }
    TreeNode* Convert(TreeNode* pRootOfTree)
    {
        TreeNode *pLastNodeInitList = NULL;
        CovertNode(pRootOfTree,&pLastNodeInitList);
        //pLastNodeInitLast指向链表的最后一个结点
        TreeNode *pHead = pLastNodeInitList;
        while(pHead != NULL && pHead->left != NULL)
        {
            pHead = pHead->left;
        }
        return pHead;
    }
};

递归不是很好理解，一种不用递归实现的易于理解的方法：
1）采用vector来存储中序遍历后各节点
2）将各节点链接起来构成双向链表
3）返回v[0]即链表头

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/
class Solution {
public:
    //非递归中序遍历
    void midorder2(TreeNode* root,vector<TreeNode *> *v){
        if(root==NULL)
            return;
        stack<TreeNode *> s;
        while(root||!s.empty())
        {
                while(root)
                {
                    s.push(root);
                    root=root->left;
                }
                root=s.top();
                s.pop();
                (*v).push_back(root);
                root=root->right;
        }
    }
    TreeNode* Convert(TreeNode* pRootOfTree)
    {
        if(pRootOfTree == NULL)
            return NULL;
        vector<TreeNode *> v;
        midorder2(pRootOfTree,&v);
         
        int n = v.size();
         
        v[0]->left = NULL;
        for(int i=1;i<n;i++)
        {
            v[i-1]->right = v[i];
            v[i]->left = v[i-1];
        }
        v[n-1]->right = NULL;
        return v[0];
    }
};