/*
* julia's comment:
* 1. It takes some time to do calculation of index, length of subtree.
* This should be addressed in a simple way, maybe, 1-2 minutes.
*
* Julia found out that code needs to be worked on, more simple as blog:
* http://blog.csdn.net/linhuanmars/article/details/23904883
*
* 2. Better solution is written called sortedListToBST_B
*/
public static TreeNode sortedListToBST(ListNode head, int len)
{
if (len == 0) return null;
if (len == 1) return
new TreeNode (head.val);
// put all calculations here - think about how to spend shortest time on the calculation
int rootIndex = len / 2 ; // starting from 0,
int rightTreeHeadIndex = len /2 + 1; // example: len is even, 1, 2, 3, 4 four node
// left tree, 1, 2, then, root index:
int leftTreeLen = len / 2; //
int rightTreeLen = len - len/2 -1; // leftTreeLen + rightTreeLen + 1 = len;
// len can be even or odd, so len%2 can be 1 or 0
ListNode nthNode = nth_node(head, rootIndex);
TreeNode root = new TreeNode(nthNode.val); // Julia's comment: cost of calculation: O(n/2) ,
// go through the list node one by one starting from head.
// how many times: O(log n), height of tree
// time complexity: O(n logn)
// if the root node can be random accessed like array, hashmp, O(1)
// then, this algorithm will not be best in time complexity.
// this should be considered when you choose the algorithm,
// this is called top-down
root.left = sortedListToBST(head, leftTreeLen);
ListNode secondHalf = nth_node(head, rightTreeHeadIndex);
root.right = sortedListToBST(secondHalf, rightTreeLen);
return root;
}
/*
* Julia's comment:
* Action Item: make the calculation to minimum, less error-prone.
* 1. put all calculations here - think about how to spend shortest time on the calculation
2. len /2 only shows once, all other, use m
* 3. Julia needs to learn how to use abstract symbol
* 4. Try to make the code look simple, testable, maintainable.
*/
public static TreeNode sortedListToBST_B(ListNode head, int len)
{
if (len == 0) return null;
if (len == 1) return
new TreeNode(head.val);
int m = len / 2; // root index,
int r_start = m + 1; // right sub tree start position, do not go to detail: even, odd, waste time
int l_Len = m; // left subtree length
int r_len = len - m - 1; // right sub tree length
ListNode nthNode = nth_node(head, m);
TreeNode root = new TreeNode(nthNode.val); // each divide and conquer, O(1) calculation to get the root index.
root.left = sortedListToBST(head, l_Len);
ListNode secondHalf = nth_node(head, r_start);
root.right = sortedListToBST(secondHalf, r_len);
return root;
}