"Convert Sorted List to Binary Search Tree"

Author: lennylxx

README.md

@@ -179,7 +179,7 @@ The `☢` means that you need to have a LeetCode Premium Subscription.
 | 112 | [Path Sum]                                                   | [C](src/112.c)     |
 | 111 | [Minimum Depth of Binary Tree]                               | [C](src/111.c)     |
 | 110 | [Balanced Binary Tree]                                       | [C](src/110.c)     |
-| 109 | [Convert Sorted List to Binary Search Tree]                  |                    |
+| 109 | [Convert Sorted List to Binary Search Tree]                  | [C++](src/109.cpp) |
 | 108 | [Convert Sorted Array to Binary Search Tree]                 | [C](src/108.c)     |
 | 107 | [Binary Tree Level Order Traversal II]                       | [C++](src/107.cpp) |
 | 106 | [Construct Binary Tree from Inorder and Postorder Traversal] | [C](src/106.c)     |

src/109.cpp

@@ -0,0 +1,78 @@
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+struct ListNode {
+    int val;
+    ListNode *next;
+    ListNode(int x) : val(x), next(NULL) {}
+};
+
+struct TreeNode {
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution {
+public:
+    TreeNode* sortedListToBST(ListNode* head) {
+        if (head == NULL) return NULL;
+
+        ListNode *fast, *slow, *prev;
+        fast = slow = head;
+        prev = NULL;
+        while (fast) {
+            fast = fast->next;
+            if (!fast) break;
+            fast = fast->next;
+            prev = slow;
+            slow = slow->next;
+        }
+
+        if (slow == NULL) return NULL;
+        if (prev) prev->next = NULL;
+
+        TreeNode *node = new TreeNode(slow->val);
+        node->left = sortedListToBST(slow == head ? NULL : head);
+        node->right = sortedListToBST(slow->next);
+
+        return node;
+    }
+
+    void preOrderTraversal(TreeNode *root) {
+        if (root == NULL) return;
+
+        printf("%d ", root->val);
+        preOrderTraversal(root->left);
+        preOrderTraversal(root->right);
+    }
+};
+
+int main() {
+
+    ListNode *head = new ListNode(1);
+    ListNode *p = head;
+    for (int i = 2; i <= 7; i++) {
+        p->next = new ListNode(i);
+        p = p->next;
+    }
+    p->next = NULL;
+
+    p = head;
+    while (p) {
+        printf("%d ", p->val);
+        p = p->next;
+    }
+    printf("\n");
+
+    Solution s;
+    TreeNode *root = s.sortedListToBST(head);
+
+    s.preOrderTraversal(root);
+    printf("\n");
+
+    return 0;
+}