LeetCode099 Recover Binary Search Tree

4000

详细见：leetcode.com/problems/recover-binary-search-tree

Java Solution:
github

package leetcode;

import java.util.ArrayList;

/*
* Two elements of a binary search tree (BST) are swapped by mistake.

Recover the tree without changing its structure.

Note:
A solution using O(n) space is pretty straight forward.
Could you devise a constant space solution?
*/

import tools.TreeNode辅助.TreeNode;

public class P099_RecoverBinarySearchTree {
static int N = Integer.MIN_VALUE;

public static void main(String[] args) {
TreeNode root = tools.TreeNode辅助.A_生成满二叉树(new int[] {
// 1,
// N,3,
// N,N,N,2
10,
5, 15,
N, N, 7, 20
});
tools.TreeNode辅助.B_按层打印(root);
new Solution().recoverTree(root);
tools.TreeNode辅助.B_按层打印(root);
}
/*
* 这样的AC，有点挫
* 192 ms
*/
static class Solution {
ArrayList<TreeNode> arr = new ArrayList<TreeNode>();
boolean isFalse = false;
public void recoverTree(TreeNode root) {
searchAllTreeNode(root);
for (int i = 0; i < arr.size(); i++) {
for (int j = i + 1; j < arr.size(); j++) {
TreeNode tree1 = arr.get(i);
TreeNode tree2 = arr.get(j);
if (tree1 == tree2) {
continue;
}
int temp = tree1.val;
tree1.val = tree2.val;
tree2.val = temp;
isFalse = false;
search_judge(root, Long.MAX_VALUE, Long.MIN_VALUE);
if (!isFalse) {
return;
}
temp = tree1.val;
tree1.val = tree2.val;
tree2.val = temp;
}
}
}
private void searchAllTreeNode(TreeNode root) {
if (root == null) {
return;
}
arr.add(root);
if (root.right != null) {
searchAllTreeNode(root.right);
}
if (root.left != null) {
searchAllTreeNode(root.left);
}
}
void search_judge(TreeNode root, long max_edge, long min_edge) {
if (isFalse) {
return;
}
if ((long) root.val >= max_edge || (long) root.val <= min_edge) {
isFalse = true;
return;
}
if (root.left != null) {
search_judge(root.left, root.val, min_edge);
}
if (root.right != null) {
search_judge(root.right, max_edge, root.val);
}
}
}
}


C Solution:
github

/*
url: leetcode.com/problems/recover-binary-search-tree
both: AC 12ms 100.00%
*/

#include <stdio.h>
#include <stdlib.h>

typedef struct TreeNode stn;
typedef struct TreeNode * ptn;

struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
};

typedef ptn T;
typedef struct al sal;
typedef struct al * pal;

struct al {
int capacity;
int size;
T* arr;
};

pal al_init(int capacity) {
pal l = (pal) malloc(sizeof(sal));
if (capacity < 1) return NULL;
l->arr = (T*) malloc(sizeof(T) * capacity);
l->capacity = capacity;
l->size = 0;
return l;
}

void al_expand_capacity(pal l) {
T* new_arr = (T*) malloc(sizeof(T) * (l->capacity * 2 + 1));
int i = 0;
for (i = 0; i < l->capacity; i ++)
new_arr[i] = l->arr[i];
free(l->arr);
l->arr = new_arr;
l->capacity = l->capacity * 2 + 1;
}

void al_add_last(pal l, T v) {
if (l->capacity == l->size) al_expand_capacity(l);
l->arr[l->size] = v;
l->size ++;
}

T* al_convert_to_array_free_l(pal l) {
T* arr = l->arr;
free(l);
return arr;
}

void pre_order(pal l, ptn root) {
if (root == NULL) return;
pre_order(l, root->left);
al_add_last(l, root);
pre_order(l, root->right);
}

void swap(int* a, int* b) {
int t = *a;
*a = *b;
*b = t;
}

void recoverTree_n(ptn root) {
int i = 0, c = 0;
pal l = al_init(16);
int w1 = 0, w2 = 0;
int size = 0;
ptn * arr = NULL;
pre_order(l, root);
size = l->size;
arr = al_convert_to_array_free_l(l);
for (i = 1; i < size; i ++) {
if (arr[i]->val < arr[i-1]->val) {
if (c == 0) {
w1 = i;
c ++;
} else if (c == 1) {
w2 = i;
c ++;
}
}
}
if (c == 2) {
swap(&(arr[w1-1]->val), &(arr[w2]->val));
}
if (c == 1) {
swap(&(arr[w1]->val), &(arr[w1-1]->val));
}
}

void pre_order_1(ptn root, ptn* p, ptn* ps) {
if (root == NULL) return;
pre_order_1(root->left, p, ps);
if (*p != NULL)
if (root->val <= (*p)->val) {
if (ps[0] == NULL) {
ps[0] = *p;
}
ps[1] = root;
}
*p = root;
pre_order_1(root->right, p, ps);
}

void recoverTree_1(ptn root) {
ptn p = NULL;
ptn ps[2] = {NULL, NULL};
pre_order_1(root, &p, ps);
swap(&(ps[0]->val), &(ps[1]->val));
}

void recoverTree(ptn root) {
recoverTree_n(root);
}



Python Solution:
github

#coding=utf-8

'''
url: leetcode.com/problems/recover-binary-search-tree
@author: zxwtry
@email: zxwtry@qq.com
@date: 2017年4月25日
@details: Solution: 149ms 23.71%
'''

class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None

class Solution(object):
def inOrder(self, n, p, s):
if n == None: return
self.inOrder(n.left, p, s)
if p[0] != None:
if n.val <= p[0].val:
if s[0] == None:
s[0] = p[0]
s[1] = n
p[0] = n
self.inOrder(n.right, p, s)

def recoverTree(self, n):
"""
:type n: TreeNode
:rtype: void Do not return anything, modify n in-place instead.
"""
p, s = [None], [None, None]
self.inOrder(n, p, s)
s[0].val, s[1].val = s[1].val, s[0].val