My code:
/**
* 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 inorderSuccessor(TreeNode root, TreeNode p) {
if (root == null || p == null) {
return null;
}
if (p.right != null) {
TreeNode ret = p.right;
while (ret.left != null) {
ret = ret.left;
}
return ret;
}
TreeNode pre = null;
TreeNode curr = root;
while (curr != null) {
if (curr.left == p) {
return curr;
}
else if (curr.right == p) {
return pre;
}
else if (curr.val < p.val) {
curr = curr.right;
}
else {
pre = curr;
curr = curr.left;
}
}
return null;
}
}
首先，這道題目我竟然從來沒做過，我表示很好奇。在我腦海里，我好像做過好幾次了。最終導(dǎo)致我不能一邊AC
我自己寫出了這個(gè)iteration 的做法。
然后關(guān)鍵點(diǎn)在哪里呢？
在于，當(dāng) curr.val < p.val的時(shí)候，
curr = curr.right, 但我們不用更新pre
也就是說，當(dāng)curr往右邊走的時(shí)候，
pre指針保留在原地。這是為了防止，p是 curr這個(gè)subtree的最右邊的結(jié)點(diǎn)，那么他的繼承者就是pre，所以pre不能動(dòng)。
或者可以這么說，如果curr往右走，那么p的繼承者不一定會出現(xiàn)在這課右子樹上，所以pre得做好準(zhǔn)備
如果往左走，那么p的繼承者，一定在這棵左子樹上！pre可以跟進(jìn)
如果curr往左邊走，那么就可以更新curr了。
如果p是curr的左孩子，那么curr就是繼承者。
如果p是curr的右孩子，那么pre就是繼承者
同時(shí)，一開始，就先判斷 p的右孩子是否為空。
如果不是，那么他的繼承者，一定是右子樹的最左邊結(jié)點(diǎn)。
這就是 iteration 做法的思考點(diǎn)
然后看答案看到了recursion做法，感覺很巧妙，自己寫了下。
My code:
/**
* 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 inorderSuccessor(TreeNode root, TreeNode p) {
if (root == null) {
return null;
}
if (root.val <= p.val) {
return inorderSuccessor(root.right, p);
}
else {
TreeNode left = inorderSuccessor(root.left, p);
return left == null ? root : left;
}
}
}
巧妙在，他的分割點(diǎn)選的很好。
為什么一定是 root.val <= p.val 作為第一個(gè)判斷條件呢？
因?yàn)?root.val <= p.val, 那么 p 的繼承者一定在右子樹
如果 root.val >= p.val, p的繼承者不一定就在左子樹！
所以這個(gè)地方如此寫是用了很多心的。
接著往下看。
但我們走到 root.val > p.val的時(shí)候，
這個(gè)時(shí)候我們需要往左走。這個(gè)時(shí)候，繼承者可能存在于左子樹上，也可能是當(dāng)前這個(gè)結(jié)點(diǎn)。所以加了一層判斷。
這里的root，其實(shí)就相當(dāng)于iteration里面的pre指針。
每當(dāng)pre指針需要往左走的時(shí)候，都得考慮下。
如果curr是往右走，那么pre不用往走左。
如果curr往左走，這個(gè)時(shí)候pre才用往左走。
下面考慮下求 Predecessor 問題。
My code:
public class Solution {
public TreeNode inorderPredecessor(TreeNode root, TreeNode p) {
if (root == null) {
return null;
}
else if (root.left != null) {
TreeNode ret = root.left;
while (ret.right != null) {
ret = ret.right;
}
return ret;
}
TreeNode curr = root;
TreeNode pre = null;
while (curr != null) {
if (curr.left == p) {
return pre;
}
else if (curr.right == p) {
return curr;
}
else if (curr.val > p.val) {
curr = curr.left;
}
else {
pre = curr;
curr = curr.right;
}
}
return null;
}
}
和find繼承者差不多，只不過完全相反。
recursion:
My code:
public class Solution {
public TreeNode inorderPredecessor(TreeNode root, TreeNode p) {
if (root == null) {
return null;
}
if (root.val >= p.val) {
return inorderPredecessor(root.left, p);
}
else {
TreeNode right = inorderPredecessor(root.right, p);
return right == null ? root : right;
}
}
}
也差不多。只是相反。
reference：
https://discuss.leetcode.com/topic/25076/share-my-java-recursive-solution/2
估計(jì)過段時(shí)間就忘記了。但希望能記住這個(gè)思想，那么臨場就能很快地寫出來。
Anyway, Good luck, Richardo! -- 09/06/2016
My code:
/**
* 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 inorderSuccessor(TreeNode root, TreeNode p) {
TreeNode pre = null;
TreeNode curr = root;
while (curr != null) {
if (curr.val > p.val) {
pre = curr;
curr = curr.left;
}
else if (curr.val < p.val) {
curr = curr.right;
}
else {
if (curr.right != null) {
curr = curr.right;
while (curr.left != null) {
curr = curr.left;
}
return curr;
}
else {
return pre;
}
}
}
return null;
}
public TreeNode inorderPredecessor(TreeNode root, TreeNode p) {
TreeNode curr = root;
TreeNode pre = null;
while (curr != null) {
if (curr.val < p.val) {
curr = curr.left;
}
else if (curr.val > p.val) {
pre = curr;
curr = curr.right;
}
else {
if (curr.left != null) {
curr = curr.left;
while (curr.right != null) {
curr = curr.right;
}
return curr;
}
else {
return pre;
}
}
}
return null;
}
}
正好完全相反
Anyway, Good luck, Richardo! -- 09/25/2016
