Convert Binary Search Tree to Sorted Doubly Linked List

Description

https://leetcode.com/problems/convert-binary-search-tree-to-sorted-doubly-linked-list/

Convert a BST to a sorted circular doubly-linked list in-place. Think of the left and right pointers as synonymous to the previous and next pointers in a doubly-linked list.

Let’s take the following BST as an example, it may help you understand the problem better:

We want to transform this BST into a circular doubly linked list. Each node in a doubly linked list has a predecessor and successor. For a circular doubly linked list, the predecessor of the first element is the last element, and the successor of the last element is the first element.

The figure below shows the circular doubly linked list for the BST above. The “head” symbol means the node it points to is the smallest element of the linked list.

Solution

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

    Node() {}

    Node(int _val, Node* _left, Node* _right) {
        val = _val;
        left = _left;
        right = _right;
    }
};
*/
class Solution {
public:
    Node* treeToDoublyList(Node* root) {
        if (root == NULL) return NULL;
        
        pair<Node*, Node*> ret = makeList(root); 
        ret.second->right = ret.first;
        ret.first->left = ret.second;
        
        return ret.first;
    }
    
    pair<Node*, Node*> makeList(Node* root) {
        
        pair<Node*, Node*> pairLeft = root->left ? 
                    makeList(root->left) : make_pair(root, root);
        pair<Node*, Node*> pairRight = root->right ? 
                    makeList(root->right) : make_pair(root, root);
        
        if (root->left) {
            pairLeft.second->right = root;
            root->left = pairLeft.second;
        }
        if (root->right) {
            pairRight.first->left = root;
            root->right = pairRight.first;
        }
        
        return make_pair(pairLeft.first, pairRight.second);
    }
    
};