学一道算法题, 经常回顾一下. 第二次重温, 决定增加一些图片, 帮助自己记忆. 在网上找他人的资料, 不如自己动手. 把从底向上树的算法搞通俗一些.

先做一个例子:

Here is the whole story for working on this alogrithm problem:

109 Convert sorted list to binary search tree (No. 109)

8/25/2015

Read the following blogs:

http://articles.leetcode.com/2010/11/convert-sorted-list-to-balanced-binary.html

C#, bottom up, time O(n), space O(log n) solution - best solution:

https://github.com/jianminchen/Leetcode_C-/blob/master/109ConvertSortedListToBinarySearchTreeB.cs

C#, top down, time O(n^2), space O(long n) solution - naive solution:

worked on code 2 times, first time, the calculation is kind of messy, then, worked on Leetcode question 108, get the idea to make it more simple;

tips like len/2 only shows once, afterwards, use m instead. Just need to improve coding, think to make it more abstract, simple.

https://github.com/jianminchen/Leetcode_C-/blob/master/109ConvertSortedListToBinarySearchTreeC.cs

9/21/2015

Review the best solution, and then, totally forgot the bottom up solution idea. So, update the code with more comment.

Need to review more about bottom up/ top down solution in tree problems. Get more experience on bottom-up solution, read some articles about it.

9/22/2015

Go over one example to build some muscle memory about this bottom up, O(1) solution to find the root node in subtree function.

Sorted List:

1->2->3->4->5->6->7,

How to convert the above sorted list to a binary search tree?

Thought process:

1.      First, get length of the list, which is 7 in the above list;

2.      Secondly, define a recursive function called

constructBST(ref  TreeNode head, int start, int end)

the above function definition, 3 arguments:

1.      First one is the reference of head node of sorted list,

2.      Start index of the list,

3.     End index of the list

In the function, first define the base case:

head is null, or start<end, return null

start==end, return head

then, call the recursive function for left subtree:

head node is the same, start is the same, but end is len/2-1;

great tip comes in, the head node should move in the function, so that

root node can be accessed in the list using O(1), instead of starting from very beginning.

One more statement:

head = head.next;

TreeNode root = head;   // return this node as tree root node

Root.left = left subtree root node

Root.right = right subtree recursive function

constructBST(ref  head.next, mid+1, end)

The tips to remember in the design, the recursive function should return the root node of the tree; secondly, input argument of linked list should

use reference, and also head node moves in the recursive function, so it is O(1) to find the root node.

Just cannot believe that only call .next function once in the recursive function! How to argue that the move is only once? Therefore, the total calls

of .next should be length of list. Total recursive function calls is n, length of list.

Debate why the recursive function has to return root node, and set up root node, connect its left/ right subtree root node.

Debate why the linked list head node is moving.

The main point to understand the best solution using O(ln N) space, the left subtree has to be built first, and then,

head node can be retrieved as .next method call, root node can be set up, and then, left subtree can be built. So,

left subtree, then right subtree, then the tree with root node. Bottom up.

Whereas sorted array to BST, the root node can be find right away, and then, tree can be set up top down. Julia is

still confusing this top down / bottom up difference. :-) read more blogs.

Blogs:

1. use global variable to remember the head node of linked list, great idea:

http://www.jiuzhang.com/solutions/convert-sorted-list-to-binary-search-tree/

2. another implementation using two pointers. Try it using C# later.

https://siddontang.gitbooks.io/leetcode-solution/content/tree/convert_sorted_listarray_to_binary_search_tree.html

3. Java implementation, teach me how to use reference in Java or wrapper class. Good point!

http://rleetcode.blogspot.ca/2014/02/convert-sorted-list-to-binary-search.html

4. Time and space complexity analysis - think about it - very clear analysis

http://blog.unieagle.net/2012/12/14/leetcode%E9%A2%98%E7%9B%AE%EF%BC%9Aconvert-sorted-list-to-binary-search-tree/

5. Three implementation discussions

http://www.cnblogs.com/feiling/p/3267917.html

6. Great explanation - bottom up / top down, and in order traversal/ post order traversal

https://leetcodenotes.wordpress.com/2013/11/23/convert-sorted-list-to-binary-search-tree/

Implement the above 6 blogs using C#, and then, share the blog. After 1 month, check again and see if I can come out the bottom

up solution in 5 minutes. If yes, stop; otherwise review again.