Convert Sorted List to Binary Search Tree

http://oj.leetcode.com/problems/convert-sorted-list-to-binary-search-tree/

Example:

Input:  Linked List 1->2->3
Output: A Balanced BST 
     2   
   /    
  1    3 


Input: Linked List 1->2->3->4->5->6->7
Output: A Balanced BST
        4
      /   
     2     6
   /     / 
  1   3  4   7  

Input: Linked List 1->2->3->4
Output: A Balanced BST
      3   
    /    
   2    4 
 / 
1

Input:  Linked List 1->2->3->4->5->6
Output: A Balanced BST
      4   
    /     
   2     6 
 /     / 
1   3  5   

 

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

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; next = null; }
 * }
 */
/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
 public TreeNode sortedListToBST(ListNode head) {

        if (head == null)
            return null;
        int count = 0;
        ListNode l1 = head;
        while (l1 != null) {
            count++;
            l1 = l1.next;
        }
        return sortedListToBST_helper(head, count);
    }

    public ListNode getMid(ListNode head, int n) {
        ListNode l1 = head;
        while (n-- > 0) {
            l1 = l1.next;
        }
        return l1;
    }

    public TreeNode sortedListToBST_helper(ListNode head, int count) {
        if (count < 1)
            return null;
        int mid = count / 2;
        ListNode mid_node = getMid(head, count / 2);
        TreeNode root = new TreeNode(mid_node.val);
        ListNode mid_node_pre = getMid(head, count / 2 - 1);
        mid_node_pre.next = null;
        root.left = sortedListToBST_helper(head, count / 2);
        root.right = sortedListToBST_helper(mid_node.next, count - mid - 1);
        return root;
    }
}

此解法时间复杂度为O(nlog(n))

关于Java传值还是传引用

　　1. 对象就是传引用

　　2. 原始类型就是传值

此题另一种decent的解法:

/* This function counts the number of nodes in Linked List and then calls
   sortedListToBSTRecur() to construct BST */
struct TNode* sortedListToBST(struct LNode *head)
{
    /*Count the number of nodes in Linked List */
    int n = countLNodes(head);
 
    /* Construct BST */
    return sortedListToBSTRecur(&head, n);
}
 
/* The main function that constructs balanced BST and returns root of it.
       head_ref -->  Pointer to pointer to head node of linked list
       n  --> No. of nodes in Linked List */
struct TNode* sortedListToBSTRecur(struct LNode **head_ref, int n)
{
    /* Base Case */
    if (n <= 0)
        return NULL;
 
    /* Recursively construct the left subtree */
    struct TNode *left = sortedListToBSTRecur(head_ref, n/2);
 
    /* Allocate memory for root, and link the above constructed left 
       subtree with root */
    struct TNode *root = newNode((*head_ref)->data);
    root->left = left;
 
    /* Change head pointer of Linked List for parent recursive calls */
    *head_ref = (*head_ref)->next;
 
    /* Recursively construct the right subtree and link it with root 
      The number of nodes in right subtree  is total nodes - nodes in 
      left subtree - 1 (for root) which is n-n/2-1*/
    root->right = sortedListToBSTRecur(head_ref, n-n/2-1);
 
    return root;
}
/* UTILITY FUNCTIONS */
 
/* A utility function that returns count of nodes in a given Linked List */
int countLNodes(struct LNode *head)
{
    int count = 0;
    struct LNode *temp = head;
    while(temp)
    {
        temp = temp->next;
        count++;
    }
    return count;
}

此解法时间复杂度位O(n)

我尝试用Java来写。由于Java和C系列的指针不大一样。失败了。。以后再改进吧。