https://leetcode.com/mockinterview/session/result/xyc51it/
https://leetcode.com/problems/recover-binary-search-tree/ // 想到了Space O(N)的解法:方法是直接将BST放平,然后重新排序,然后比较一下就可以。
// 原题中提到说,有 Space O(Constant)的方法,还要研究一下 看了Discuss,也上网搜了一下,发现空间O(1)可以用 Morris遍历的方法。单独写了一篇博客,方法介绍如下:
http://www.cnblogs.com/charlesblc/p/6013506.html
下面是leetcode这道题目我的解答。没有使用O(1)空间复杂度,使用了O(n)空间复杂度。 还用到了Java里面 Arrays.sort方法,也需要注意toArray函数的参数。

除了这种解法,还有一种,是我之前做的方法,也很好,通过两个数字记录可能出错的位置,很巧妙,在这个后面给出。
package com.company;import java.util.*;

class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
} class StkNode {
TreeNode tn;
int count;
StkNode(TreeNode tn) {
this.tn = tn;
count = 0;
}
} class Solution { List<Integer> getArray(TreeNode root) { List<Integer> ret = new ArrayList<>();
if (root.left != null) {
ret.addAll(getArray(root.left));
}
ret.add(root.val);
if (root.right != null) {
ret.addAll(getArray(root.right));
}
return ret;
} public void recoverTree(TreeNode root) { // Space O(N)的解法,想到了是直接将BST放平,然后重新排序,然后比较一下就可以。 // 分情况, 左ok, 右ok, 1. 上ok, 2. 上不ok
// 左不ok, 或者右不ok, 1. 上ok,
// 想不清楚,先用直接的方法:
if (root == null) {
return;
}
List<Integer> ret = getArray(root);
Integer[] sortRet= ret.toArray(new Integer[0]);
Arrays.sort(sortRet); int[] change = new int[2];
int[] index = new int[2];
int ii = 0;
for (int i=0; i<sortRet.length; i++) {
//System.out.printf("old: %d, new: %d\n", ret.get(i), sortRet[i]);
if (ret.get(i) != sortRet[i]) {
index[ii] = i+1;
change[ii] = sortRet[i];
ii++;
if (ii >= 2) {
break;
}
}
}
//System.out.printf("ii:%d\n", ii); Stack<StkNode> stk = new Stack<>();
int count = 0;
int k = 0;
StkNode stkRoot = new StkNode(root);
stk.push(stkRoot);
while (!stk.isEmpty()) {
StkNode tmp = stk.pop();
//System.out.printf("here: %d, %d, %d\n", tmp.count, count, tmp.tn.val);
if (tmp.count == 1) {
count++;
if (count == index[k]) {
//System.out.printf("here: %d\n", count);
tmp.tn.val = change[k];
k++;
if (k>=2) {
return;
}
}
if (tmp.tn.right != null) {
StkNode newTmp = new StkNode(tmp.tn.right);
stk.push(newTmp);
}
}
else {
tmp.count++;
stk.push(tmp);
if (tmp.tn.left != null) {
StkNode newTmp = new StkNode(tmp.tn.left);
stk.push(newTmp);
}
}
} }
} public class Main { public static void main(String[] args) {
System.out.println("Hello!");
Solution solution = new Solution(); TreeNode root = new TreeNode(2);
TreeNode root2 = new TreeNode(3);
TreeNode root3 = new TreeNode(1);
root.left = root2;
root.right = root3;
solution.recoverTree(root);
System.out.printf("Get ret: \n");
System.out.printf("Get ret1: %d\n", root.left.val);
System.out.printf("Get ret2: %d\n", root.val);
System.out.printf("Get ret3: %d\n", root.right.val);
System.out.println(); /*Iterator<List<Integer>> iterator = ret.iterator();
while (iterator.hasNext()) {
Iterator iter = iterator.next().iterator();
while (iter.hasNext()) {
System.out.printf("%d,", iter.next());
}
System.out.println();
}*/ System.out.println(); }
}

下面我之前的解法,也很好,通过两个数字来记录可能的出错位置,并且在遍历的同时,更新这个位置。需要对出错的规律有深刻了解,比如在解法中,first_result位置就始终没有变过,因为一旦找到就可以不变,通过second_result位置的改变,就能满足条件:

https://leetcode.com/problems/recover-binary-search-tree/

/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
stack < pair <TreeNode*, int> > stk;
public:
void recoverTree(TreeNode* root) {
if (root == NULL) {
return;
}
pair<TreeNode*, int> pr(root, 0);
stk.push(pr); TreeNode * first_result = NULL;
TreeNode * last_result = NULL;
TreeNode* last = NULL; pair<TreeNode*, int> tmp;
TreeNode* tn_tmp; while ( !stk.empty() ) {
tmp = stk.top();
stk.pop(); if (tmp.second == 0) {
// left
tn_tmp = tmp.first;
pair<TreeNode*, int> tmp_cur(tn_tmp, 1);
stk.push(tmp_cur); if (tn_tmp->left != NULL) {
pair<TreeNode*, int> tmp_left(tn_tmp->left, 0);
stk.push(tmp_left);
} }
else {
// right
tn_tmp = tmp.first;
if (last != NULL && last->val > tn_tmp->val) {
// Found
if (first_result == NULL ) {
first_result = last;
last_result = tn_tmp;
}
else {
last_result = tn_tmp;
break;
}
}
last = tn_tmp; if (tn_tmp->right != NULL) {
pair<TreeNode*, int> tmp_pr(tn_tmp->right, 0);
stk.push(tmp_pr);
} } } if (first_result != NULL && last_result != NULL) {
int swap = first_result->val;
first_result->val = last_result->val;
last_result->val = swap;
}
return; } };

好!recover-binary-search-tree(难)& 两种好的空间O(n)解法 & 空间O(1)解法的更多相关文章

  1. [LeetCode] Validate Binary Search Tree (两种解法)

    Given a binary tree, determine if it is a valid binary search tree (BST). Assume a BST is defined as ...

  2. Leetcode 笔记 99 - Recover Binary Search Tree

    题目链接:Recover Binary Search Tree | LeetCode OJ Two elements of a binary search tree (BST) are swapped ...

  3. 【LeetCode练习题】Recover Binary Search Tree

    Recover Binary Search Tree Two elements of a binary search tree (BST) are swapped by mistake. Recove ...

  4. LeetCode: Recover Binary Search Tree 解题报告

    Recover Binary Search Tree Two elements of a binary search tree (BST) are swapped by mistake. Recove ...

  5. [LeetCode] 99. Recover Binary Search Tree(复原BST) ☆☆☆☆☆

    Recover Binary Search Tree leetcode java https://leetcode.com/problems/recover-binary-search-tree/di ...

  6. [线索二叉树] [LeetCode] 不需要栈或者别的辅助空间,完成二叉树的中序遍历。题:Recover Binary Search Tree,Binary Tree Inorder Traversal

    既上篇关于二叉搜索树的文章后,这篇文章介绍一种针对二叉树的新的中序遍历方式,它的特点是不需要递归或者使用栈,而是纯粹使用循环的方式,完成中序遍历. 线索二叉树介绍 首先我们引入“线索二叉树”的概念: ...

  7. 【LeetCode】99. Recover Binary Search Tree

    Recover Binary Search Tree Two elements of a binary search tree (BST) are swapped by mistake. Recove ...

  8. 【LeetCode】99. Recover Binary Search Tree 解题报告(Python)

    [LeetCode]99. Recover Binary Search Tree 解题报告(Python) 标签(空格分隔): LeetCode 题目地址:https://leetcode.com/p ...

  9. 【leetcode】Recover Binary Search Tree

    Recover Binary Search Tree Two elements of a binary search tree (BST) are swapped by mistake. Recove ...

  10. 39. Recover Binary Search Tree && Validate Binary Search Tree

    Recover Binary Search Tree OJ: https://oj.leetcode.com/problems/recover-binary-search-tree/ Two elem ...

随机推荐

  1. NAND的一些相关概念

    chipsize:整个NAND FLASH 的大小,单位为MB pagesize:一页的大小,单位为字节Byte erasesize:最小擦除大小,单位为字节Byte   NAND写操作基本单位是页, ...

  2. 登录超时自动退出,计算时间差-b

    // 此方法适用于所有被创建过的controller,且当前controller生命周期存在,如有错误的地方望大神斧正 //  说一下我们的需求和实现原理,需求:在点击home键退出但没有滑飞它,5分 ...

  3. 如何在eclipse中添加android ADT

    百度经验:http://jingyan.baidu.com/article/b0b63dbfa9e0a74a4830701e.html 截图:

  4. 父<IFRAME>获取子页属性以及子页中<IFRAME>的方法

    例子如下: 1.父页index.jsp <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "ht ...

  5. Ext学习-前后交互模式介绍

    在前后台交互模式的介绍中,实际上就是Store中Proxy相关的内容,比如Ajax提交. 所以详细的文档请参考: Ext学习-基础概念,核心思想介绍   中关于数据模型和MVC结构部分. 作者:sdj ...

  6. Unity3D 与 objective-c 之间数据交互。iOS SDK接口封装Unity3D接口

    原地址:http://www.cnblogs.com/qingjoin/p/3638915.html Unity 3D 简单工程的创建.与Xcode 导出到iOS 平台请看这 Unity3D 学习 创 ...

  7. POJ 2184 Cow Exhibition (01背包的变形)

    本文转载,出处:http://www.cnblogs.com/Findxiaoxun/articles/3398075.html 很巧妙的01背包升级.看完题目以后很明显有背包的感觉,然后就往背包上靠 ...

  8. CSS中nth-child和nth-of-type的简单使用

    ele:nth-child是查找父元素下的子元素,包括子元素类型非ele的,当子元素类型不是ele时,则不会进行任何操作: ele:nth-of-type是查找父元素下的子元素类型为ele的元素,其是 ...

  9. 自动装配【Spring autowire】

    public class AutoWiringDao { private String daoName; public void setDaoName(String daoName) { this.d ...

  10. cojs 简单的区间问题 解题报告

    新学了些弦图和区间图的新玩意,于是就想着出一道题目 其实这道题不用弦图和区间图的理论也是可以做的 首先考虑第一问,第一问是一个NOIP普及组水平的贪心 我们把区间按照右端点从小到大排序,之后从头到尾扫 ...