My code:
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
/**
* Definition for a binary tree node.
* 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 total = 1;
ListNode temp = head;
while (temp.next != null) {
temp = temp.next;
total++;
}
return getBST(1, total, head, temp);
}
private TreeNode getBST(int begin, int end, ListNode beginNode, ListNode endNode) {
if (begin > end)
return null;
else if (begin == end)
return new TreeNode(beginNode.val);
int mid = (begin + end) / 2;
ListNode dummy = new ListNode(Integer.MIN_VALUE);
dummy.next = beginNode;
ListNode temp = beginNode;
ListNode pre = dummy;
ListNode post = temp.next;
for (int i = begin; i <= end; i++) {
if (i == mid)
break;
else {
pre = pre.next;
temp = pre.next;
post = temp.next;
}
}
TreeNode root = new TreeNode(temp.val);
if (pre == dummy) {
root.left = null;
root.right = getBST(mid + 1, end, post, endNode);
}
else {
root.left = getBST(begin, mid - 1, beginNode, pre);
root.right = getBST(mid + 1, end, post, endNode);
}
return root;
}
}
My test result:
這道題目不難，感覺就是用二叉搜索法將鏈表改造成balanced BST
1 -> 2 -> 3 -> 4 -> 5
begin = 1; end = 5; mid = 3
3 will be the root and
the left should be getBST(...., begin, mid - 1)
the right should be getBST(...., mid + 1, end)
SO:
1 -> 2
begin = 1, end = 2; mid = 1
1 will be the root and
the left should be null
the right should be getBST(...., mid + 1, end)
SO:
2
begin = 2; end = 2; mid = 2
2 will be the root and
we don't need to take care of its left and right tree which means they are null.
SO:
4 -> 5
begin = 4; end = 5; mid = 4
...
基本是相同的流程，然后就可以寫出一個DFS出來。
下面復習下，什么是 balanced bst
bst 的問題就在于樹的結構根據輸入結果的順序而變化，不可人為控制，導致經常性復雜度很大。
于是設計出了balanced bst ，可以進行自我調節。
比如有， AVL, red-black tree 等等。
他們的統一要求是，
http://www.cnblogs.com/huangxincheng/archive/2012/07/22/2603956.html
之前做的一道題目需要判斷一棵給定的樹是不是balanced。馬上在復習下。
http://www.lxweimin.com/p/b17a7c404ff6
**
然后這里介紹一個技巧，是我之前完全不知道的。
用快慢指針來找一個鏈表的中點。
慢指針走一步，快指針走兩步，同時每次循環都得判斷下，
fast.next != null && fast.next.next != null
同時還有個細節。
如果是奇數個結點，則此時將中間值壓入棧中了，事實上沒有數字和他對應，所以需要手動彈出。
這是鏈表的一個小技巧。
還有個小技巧就是，設置 dummy head。 可以簡單地通過許多corner case.
**
看了自己的代碼，實在是不忍心看。太丑了。而且沒有用快慢指針。
于是用快慢指針實現之。
public TreeNode sortedListToBST(ListNode head) {
if (head == null)
return null;
ListNode tail = head;
while (tail.next != null)
tail = tail.next;
return form(head, tail);
}
public TreeNode form(ListNode head, ListNode tail) {
if (head == tail)
return new TreeNode(head.val);
ListNode pre = null;
ListNode slow = head;
ListNode fast = head;
while (fast.next != null && fast.next.next != null) {
pre = slow;
slow = slow.next;
fast = fast.next.next;
}
TreeNode root = new TreeNode(slow.val);
if (pre != null) {
pre.next = null;
root.left = form(head, pre);
}
if (slow.next != null)
root.right = form(slow.next, tail);
return root;
}
但是一開始寫的時候我是錯的，一直爆棧。
后來發現，
要加上 pre.next = null; 這么一句來切斷其與后面結點的聯系。否則，快指針可以一直往后走，就會報錯！
千萬要注意這個錯誤。這在 sort list 里面，我也犯過同樣的錯誤！
還有個bug今天我也是通過debug才找出來的。
當寫for循環時。
for (int i = 0; i < N; i++) {...}
一定要注意，N會不會在循環過程中發生改變。如果會改變，而你忽略了，就會產生你無法發現的bug。因為N不會變已經刻入你的大腦了，你不會往這個方向去找bug
一定要當心！
把鏈表分成兩個子鏈表處理最后匯總時，記得之前要切斷左子鏈表與中間結點的連接，在許多情況下！
for的N會不會變，要去想一下！
**
總結： sorted ascending linked list -> balanced bst
**
Anyway, Good luck, Richardo!
My code:
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
public class Solution {
public TreeNode sortedListToBST(ListNode head) {
return helper(head);
}
private TreeNode helper(ListNode head) {
if (head == null)
return null;
else if (head.next == null)
return new TreeNode(head.val);
ListNode slow = head;
ListNode fast = head;
ListNode pre = head;
/** find the middle node of this linked list */
while (fast.next != null && fast.next.next != null) {
pre = slow;
slow = slow.next;
fast = fast.next;
fast = fast.next;
}
/** cut the connection */
ListNode right = slow.next;
slow.next = null;
pre.next = null;
TreeNode root = new TreeNode(slow.val);
if (head != slow)
root.left = helper(head);
if (right != slow)
root.right = helper(right);
return root;
}
}
自己寫的。就是走到中間，切開。中間結點和他前面一個結點也要切開。然后中間結點作 root。然后繼續遞歸。
寫了這么多道鏈表題目，眼睛發花了。想不動了。
Anyway, Good luck, Richardo!
My code:
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
/**
* Definition for a binary tree node.
* 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;
}
return helper(head);
}
private TreeNode helper(ListNode head) {
if (head == null) {
return null;
}
else if (head.next == null) {
return new TreeNode(head.val);
}
ListNode dummy = new ListNode(-1);
dummy.next = head;
ListNode slow = head;
ListNode fast = head;
ListNode pre = dummy;
while (fast.next != null && fast.next.next != null) {
pre = pre.next;
slow = slow.next;
fast = fast.next.next;
}
ListNode left = (head == slow ? null : head);
ListNode right = slow.next;
slow.next = null;
pre.next = null;
TreeNode root = new TreeNode(slow.val);
root.left = helper(left);
root.right = helper(right);
return root;
}
}
這道題目不難，但是有挺多注意點。
首先，找到中點后，第一個思路就是斷開他與后面的聯系。
但是忘了一點，也得斷開他與左邊子鏈表的聯系。所以得有個pre指針。
其次，左邊以head開頭，他很可能等于 這個中間節點，得考慮到這種情況。
然后，就差不多了。
Anyway, Good luck, Richardo! -- 08/16/2016
