## Description

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

Convert a **Binary Search Tree** to a sorted **Circular Doubly-Linked List** in place.

You can think of the left and right pointers as synonymous to the predecessor and successor pointers in a doubly-linked list. 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.

We want to do the transformation **in place**. After the transformation, the left pointer of the tree node should point to its predecessor, and the right pointer should point to its successor. You should return the pointer to the smallest element of the linked list.

**Example 1:**

**Input:** root = [4,2,5,1,3]

**Output:** [1,2,3,4,5] **Explanation:**

The figure below shows the transformed BST. The solid line indicates the successor relationship, while the dashed line means the predecessor relationship.

**Example 2:**

Input:root = [2,1,3]Output:[1,2,3]

**Example 3:**

Input:root = []Output:[]Explanation:Input is an empty tree. Output is also an empty Linked List.

**Example 4:**

Input:root = [1]Output:[1]

## Explanation

Find the BST tree values in ascending order. Then use the BST tree values to build a Circular Doubly-Linked List.

## Python Solution

```
"""
# Definition for a Node.
class Node:
def __init__(self, val, left=None, right=None):
self.val = val
self.left = left
self.right = right
"""
class Solution:
def treeToDoublyList(self, root: 'Node') -> 'Node':
if not root:
return None
node_values = []
self.get_node_values(root, node_values)
first_node = Node(node_values[0])
prev = first_node
for value in node_values[1:]:
new_node = Node(value)
new_node.left = prev
prev.right = new_node
prev = new_node
prev.right = first_node
first_node.left = prev
return first_node
def get_node_values(self, root, results):
if not root:
return
self.get_node_values(root.left, results)
results.append(root.val)
self.get_node_values(root.right, results)
```

- Time Complexity: O(N).
- Space Complexity: O(N).