LeetCode109 Convert Sorted List to Binary Search Tree

详细见：leetcode.com/problems/convert-sorted-list-to-binary-search-tree

Java Solution:
github

package leetcode;

import java.util.ArrayList;
import java.util.HashMap;

/*
* Given a singly linked list where elements are sorted in ascending order,
* convert it to a height balanced BST.
*/

import tools.ListNode辅助.ListNode;
import tools.TreeNode辅助.TreeNode;

public class P109_ConvertSortedListtoBinarySearchTree {
public static void main(String[] args) {
ListNode head = tools.ListNode辅助.A_一维生成器(new int[] {1, 2, 3});
TreeNode root = new Solution2().sortedListToBST(head);
tools.TreeNode辅助.B_按层打印(root);
}
/*
* TLE了，对时间的要求很高哪。
*/
static class Solution {
public TreeNode sortedListToBST(ListNode head) {
int len = 0;
ListNode cur = head;
while (cur != null) {
len ++;
cur = cur.next;
}
int[] nums = new int[len];
len = 0;
cur = head;
while (cur != null) {
nums[len] = cur.val;
len ++;
cur = cur.next;
}
return sortedArrayToBST(nums, 0, len - 1);
}
private TreeNode sortedArrayToBST(int[] nums, int i, int j) {
if (i > j) {
return null;
}
if (i == j) {
return new TreeNode(nums[i]);
}
int root_index = (i + j) / 2;
TreeNode root = new TreeNode(nums[root_index]);
root.left = sortedArrayToBST(nums, i, root_index - 1);
root.right = sortedArrayToBST(nums, root_index + 1, j);
return root;
}
}
/*
* 还是TLE，是不是rehash的锅
* 下一个方法采用ArrayList的吧
*/
static class Solution2 {
HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
public TreeNode sortedListToBST(ListNode head) {
int count = 0;
while (head != null) {
map.put(count ++, head.val);
head = head.next;
}
return zxwtry_generate(0, count - 1);
}
private TreeNode zxwtry_generate(int i, int j) {
if (i > j) {
return null;
}
if (i == j) {
return new TreeNode(map.get(i));
}
int mid = (i + j) / 2;
TreeNode root = new TreeNode(map.get(mid));
root.left = zxwtry_generate(i, mid - 1);
root.right = zxwtry_generate(mid + 1, j);
return root;
}
}
/*
* 艰难地AC了
* 3 ms
*/
static class Solution3 {
ArrayList<Integer> arr = new ArrayList<>();
public TreeNode sortedListToBST(ListNode head) {
while (head != null) {
arr.add(head.val);
head = head.next;
}
return sortedArrayToBST(0, arr.size() - 1);
}
private TreeNode sortedArrayToBST(int i, int j) {
if (i > j) {
return null;
}
if (i == j) {
return new TreeNode(arr.get(i));
}
int root_index = (i + j) / 2;
TreeNode root = new TreeNode(arr.get(root_index));
root.left = sortedArrayToBST(i, root_index - 1);
root.right = sortedArrayToBST(root_index + 1, j);
return root;
}
}
}


C Solution:
github

/*
*/

#include <stdio.h>
#include <stdlib.h>

struct ListNode {
int val;
struct ListNode *next;
};

struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
};

typedef struct ListNode sln;
typedef struct ListNode * pln;
typedef struct TreeNode stn;
typedef struct TreeNode * ptn;

ptn search(int* a, int ai, int aj) {
int am = (ai + aj + 1) / 2;
ptn n = NULL;
if (ai > aj) return NULL;
n = (ptn) malloc(sizeof(stn));
n->left = search(a, ai, am-1);
n->right = search(a, am+1, aj);
n->val = a[am];
return n;
}

ptn sortedListToBST(pln h) {
int hn = 0, *a = NULL, i = 0;
pln t = h;
ptn ans = NULL;
while (t != NULL) {
t = t->next;
hn ++;
}
a = (int*) malloc(sizeof(int) * hn);
t = h;
while (t != NULL) {
a[i] = t->val;
t = t->next;
i ++;
}
ans = search(a, 0, hn-1);
free(a);
return ans;
}

Python Solution:
github

#coding=utf-8

'''
url: leetcode.com/problems/convert-sorted-list-to-binary-search-tree
@author: zxwtry
@email: zxwtry@qq.com
@date: 2017年4月29日
@details: Solution: 256ms 86.37%
'''

class ListNode(object):
def __init__(self, x):
self.val = x
self.next = None

class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None

class Solution(object):
def search(self, n, ni, nj):
if ni > nj: return None
nm = (ni+nj) // 2
root = TreeNode(n[nm])
root.left = self.search(n, ni, nm-1)
root.right = self.search(n, nm+1, nj)
return root

def sortedListToBST(self, h):
"""
:type h: ListNode
:rtype: TreeNode
"""
n, l = h, []
while n != None:
l.append(n.val)
n = n.next
return self.search(l, 0, len(l)-1)