426. Convert Binary Search Tree to Sorted Doubly Linked List 解题报告

转换binary search tree 为双向链表并返回最小的node为head

返回最小的node，岂不是就是中序遍历吗？

那这道题目就是中序遍历BST，并把访问的当前node动态更新双向链表的指针。因为双向链表要指向其前序(predecessor),需要把上一次访问的节点记录下来。

iterative 代码如下：

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;

    Node() {}

    Node(int _val) {
        val = _val;
        left = NULL;
        right = NULL;
    }

    Node(int _val, Node* _left, Node* _right) {
        val = _val;
        left = _left;
        right = _right;
    }
};
*/

class Solution {
public:
    Node* treeToDoublyList(Node* root) {
        Node* head = nullptr;
        Node* preTra=nullptr;
        
        if(root == nullptr)
            return nullptr;
        
        stack<Node*> mystack;
        
        while(!mystack.empty() || root!=nullptr) { 
            while(root != nullptr) {
                mystack.push(root);
                root= root->left;
            }
        
            root = mystack.top();
            if(head == nullptr) {
                root->left = nullptr;
                head = root;
            }
            else {
                root->left = preTra;
                preTra->right = root;
            }
            preTra = root;
            mystack.pop();
            
            root = root->right;
        }
        
        preTra->right = head;

//（这边我犯了个错误，赋值的=号写成了 ==，debug了半天没有找到原因）。
        head->left = preTra;

        
        return head;
    }
};

2. recursion 递归解法

递归解法也简单，让左右子树分别返回处理好的双向链表，然后再合并起来。

合并的过程是左子树的双向链表 + root + 右子树的双向链表。

这样的话左子树返回的时候就需要返回左子树双项链表的头尾，右子树也这样。

然后再拼接起来。

最后，需要把合并完的双向列表更新下头尾指针。代码如下：

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;

    Node() {}

    Node(int _val) {
        val = _val;
        left = NULL;
        right = NULL;
    }

    Node(int _val, Node* _left, Node* _right) {
        val = _val;
        left = _left;
        right = _right;
    }
};
*/

class Solution {
public:
   pair<Node*, Node*> help(Node* root) {
       if(root == nullptr)
           return make_pair(nullptr, nullptr);
       
        pair<Node*, Node*> left  = help(root->left);
        pair<Node*, Node*> right = help(root->right);
        
        if(left.second != nullptr){
            left.second->right = root;
            root->left = left.second;
        } else {
            root->left = root;
        }
       
        if(right.first != nullptr) {
            root->right = right.first;
            right.first->left = root;
        } else {
            root->right = root;
        }
       
        if(left.first != nullptr && right.second != nullptr )
            return make_pair(left.first, right.second);
        else if(left.first == nullptr && right.second == nullptr)
            return make_pair(root, root);
        else if(left.first == nullptr)
            return make_pair(root, right.second);
       else if(right.second == nullptr)
           return make_pair(left.first, root);
       
       return make_pair(nullptr, nullptr);
    }
    
    Node* treeToDoublyList(Node* root) {
        if(root == NULL)
            return root;
        
        pair<Node*, Node*> ret;
        
        ret = help(root);
        
        ret.first->left = ret.second;
        ret.second->right = ret.first;
        
        return ret.first;
    }
};