LeetCode098 Validate Binary Search Tree

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

Java Solution: github

package leetcode;

import java.util.LinkedList;
import java.util.Queue;

/*
 * 	Given a binary tree, determine if it is a valid binary search tree (BST).

	Assume a BST is defined as follows:
	
	The left subtree of a node contains only nodes with keys less than the node's key.
	The right subtree of a node contains only nodes with keys greater than the node's key.
	Both the left and right subtrees must also be binary search trees.
	Example 1:
	    2
	   / \
	  1   3
	Binary tree [2,1,3], return true.
	Example 2:
	    1
	   / \
	  2   3
	Binary tree [1,2,3], return false.
 */

import tools.TreeNode辅助.TreeNode;;

public class P098_ValidateBinarySearchTree {
	static int N = Integer.MIN_VALUE;
	public static void main(String[] args) {
		TreeNode root = tools.TreeNode辅助.A_生成满二叉树(new int[] {
				10,
				5, 15,
				N, N, 6, 20
		});
		root = tools.TreeNode辅助.A_生成满二叉树(new int[] {
				10,
				5, 15,
				N, N, 12, 20
		});
		Solution2 s = new Solution2();
		System.out.println(s.isValidBST(root));
		tools.TreeNode辅助.B_按层打印(root);
	}
	/*
	 * 	这种想法太简单了，肯定是错误的。
	 */
	static class Solution {
	    public boolean isValidBST(TreeNode root) {
	    	Queue<TreeNode> queue = new LinkedList<TreeNode>();
	    	queue.add(root);
	    	while (! queue.isEmpty()) {
	    		TreeNode root_now = queue.poll();
	    		if (root_now.left != null) {
	    			if (root_now.left.val > root_now.val) {
	    				return false;
	    			}
	    			queue.add(root_now.left);
	    		}
	    		if (root_now.right != null) {
	    			if (root_now.right.val < root_now.val) {
	    				return false;
	    			}
	    			queue.add(root_now.right);
	    		}
	    		
	    	}
	        return true;
	    }
	}
	/*
	 * 	AC
	 * 	0 ms
	 */
	static class Solution2 {
		boolean isFalse = false;
	    public boolean isValidBST(TreeNode root) {
	    	if (root == null) {
	    		return true;
	    	}
	    	search(root, Long.MAX_VALUE, Long.MIN_VALUE);
	    	return ! isFalse;
	    }
	    /*
	     * 	保证root != null
	     */
	    void search(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(root.left, root.val, min_edge);
	    	}
	    	if (root.right != null) {
	    		search(root.right, max_edge, root.val);
	    	}
	    }
	}
}

C Solution: github

/*
    url: leetcode.com/problems/validate-binary-search-tree
*/

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

#define bool int

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

long _min(long a, long b) {
    return a < b ? a : b;
}

long _max(long a, long b) {
    return a > b ? a : b;
}

bool search(struct TreeNode* root, long min, long max) {
    long v = 0;
    if (root == NULL) return 1;
    v = root->val;
    if (v < min || v > max) return 0;
    //printf("%ld %ld\n", min, max);
    return search(root->left, min, _min(max, v-1)) && 
        search(root->right, _max(min, v+1), max);
}

bool isValidBST(struct TreeNode* root) {
    return search(root, INT_MIN, INT_MAX);
}

Python Solution: github

#coding=utf-8

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

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

class Solution(object):
    def search(self, n, i, j):
        if n == None: return True
        if n.val > j or n.val < i: return False
        return self.search(n.left, i, min(j, n.val-1)) \
            and self.search(n.right, max(i, n.val+1), j)
        
    def isValidBST(self, n):
        """
        :type n: TreeNode
        :rtype: bool
        """
        if n == None: return True
        return self.search(n, -2147483648, 2147483647)