LeetCode: Convert Sorted List to Binary Search Tree

第一次想用懒汉方法把list弄成vector再照前一题的方法，结果被判Memory exceed了。。然后只好再写次

 1 /**
 2  * Definition for singly-linked list.
 3  * struct ListNode {
 4  *     int val;
 5  *     ListNode *next;
 6  *     ListNode(int x) : val(x), next(NULL) {}
 7  * };
 8  */
 9 /**
10  * Definition for binary tree
11  * struct TreeNode {
12  *     int val;
13  *     TreeNode *left;
14  *     TreeNode *right;
15  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
16  * };
17  */
18 class Solution {
19 public:
20     TreeNode *dfs(ListNode* head, int len) {
21          if (!len) return NULL;
22          int tmplen = len/2;
23          ListNode *tmpl = head;
24          while (tmplen && tmpl) {
25              tmpl = tmpl->next;
26              tmplen--;
27          }
28          TreeNode *tmp = new TreeNode(tmpl->val);
29          tmp->left = dfs(head, len/2);
30          tmp->right = dfs(tmpl->next, (len-1)/2);
31          return tmp;
32     }
33     TreeNode *sortedListToBST(ListNode *head) {
34         // Start typing your C/C++ solution below
35         // DO NOT write int main() function
36         if (!head) return NULL;
37         int len = 0;
38         ListNode *tmp = head;
39         while (tmp) {
40             len++;
41             tmp = tmp->next;
42         }
43         return dfs(head, len);
44     }
45 };

 后来写了一个用双指针的写法。Interview的话应该这个程序更好

 1 /**
 2  * Definition for singly-linked list.
 3  * struct ListNode {
 4  *     int val;
 5  *     ListNode *next;
 6  *     ListNode(int x) : val(x), next(NULL) {}
 7  * };
 8  */
 9 /**
10  * Definition for binary tree
11  * struct TreeNode {
12  *     int val;
13  *     TreeNode *left;
14  *     TreeNode *right;
15  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
16  * };
17  */
18 class Solution {
19 public:
20     TreeNode *sortedListToBST(ListNode *head) {
21         // IMPORTANT: Please reset any member data you declared, as
22         // the same Solution instance will be reused for each test case.
23         if (head == NULL) return NULL;
24         ListNode *mid = head;
25         ListNode *end = head;
26         ListNode *pre = new ListNode(0);
27         pre->next = head;
28         while (end) {
29             end = end->next;
30             if (end == NULL) break;
31             end = end->next;
32             mid = mid->next;
33             pre = pre->next;
34         }
35         TreeNode *res = new TreeNode(mid->val);
36         end = mid->next;
37         if (pre->next == head) return new TreeNode(head->val);
38         else pre->next = NULL;
39         res->left = sortedListToBST(head);
40         res->right = sortedListToBST(end);
41         return res;
42     }
43 };

 C#

 1 /**
 2  * Definition for singly-linked list.
 3  * public class ListNode {
 4  *     public int val;
 5  *     public ListNode next;
 6  *     public ListNode(int x) { val = x; }
 7  * }
 8  */
 9 /**
10  * Definition for a binary tree node.
11  * public class TreeNode {
12  *     public int val;
13  *     public TreeNode left;
14  *     public TreeNode right;
15  *     public TreeNode(int x) { val = x; }
16  * }
17  */
18 public class Solution {
19     public TreeNode SortedListToBST(ListNode head) {
20         if (head == null) return null;
21         ListNode mid = head;
22         ListNode end = head;
23         ListNode pre = new ListNode(0);
24         pre.next = head;
25         while (end != null) {
26             end = end.next;
27             if (end == null) break;
28             end = end.next;
29             mid = mid.next;
30             pre = pre.next;
31         }
32         TreeNode ans = new TreeNode(mid.val);
33         end = mid.next;
34         if (pre.next == head) return new TreeNode(head.val);
35         else pre.next = null;
36         ans.left = SortedListToBST(head);
37         ans.right = SortedListToBST(end);
38         return ans;
39     }
40 }

View Code

 

转载于:https://www.cnblogs.com/yingzhongwen/archive/2013/03/19/2969492.html