# Trees: Is This a Binary Search Tree?

### Problem Statement :

```For the purposes of this challenge, we define a binary search tree to be a binary tree with the following properties:

The data value of every node in a node's left subtree is less than the data value of that node.
The data value of every node in a node's right subtree is greater than the data value of that node.
The data value of every node is distinct.
For example, the image on the left below is a valid BST. The one on the right fails on several counts:
- All of the numbers on the right branch from the root are not larger than the root.
- All of the numbers on the right branch from node 5 are not larger than 5.
- All of the numbers on the left branch from node 5 are not smaller than 5.
- The data value 1 is repeated.

Function Description

Complete the function checkBST in the editor below. It must return a boolean denoting whether or not the binary tree is a binary search tree.

checkBST has the following parameter(s):

root: a reference to the root node of a tree to test
Input Format

You are not responsible for reading any input from stdin. Hidden code stubs will assemble a binary tree and pass its root node to your function as an argument.

Constraints

0   <=  data  <=  10^4

Output Format

Your function must return a boolean true if the tree is a binary search tree. Otherwise, it must return false.```

### Solution :

```                        ```Solution in C++ :

In   C++ :

struct Node {
int data;
Node* left;
Node* right;
}
*/
bool soy=true;
int mini(int a, int b)
{
return a<b ? a:b;
}
int maxi(int a, int b)
{
return a>b ? a:b;
}
typedef pair<int, int> ii;
#define f first
#define s second
ii revisar(Node* root)
{
ii h(-1, 10005), iz(10005,10005), de(-1,-1);
if (root->left!=NULL)
{
iz=revisar(root->left);
if (iz.s >= root->data or iz.f >= root->data) soy=false;
}
if (root->right!=NULL)
{
de=revisar(root->right);
if (de.f <= root->data or de.s <= root->data) soy=false;
}

return ii{mini(root->data, iz.f),maxi(root->data, de.s) };
}

bool checkBST(Node* root) {
soy=true;
if (root!=NULL)
revisar(root);
//else return false;
return soy;
}```
```

```                        ```Solution in Java :

In   Java :

class Node {
int data;
Node left;
Node right;
}
*/
boolean checkBST(Node root) {
//return fasle;
return checkBSTHelper(root, Integer.MIN_VALUE, Integer.MAX_VALUE);
}

private boolean checkBSTHelper(Node n, int min, int max) {
if (n == null) return true;
if (n.data <= min || n.data >= max) return false;
return checkBSTHelper(n.left, min, n.data) && checkBSTHelper(n.right, n.data, max);
}```
```

```                        ```Solution in Python :

In   Python3 :

""" Node is defined as
class node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
"""

def check(node, max_val = float('inf'), min_val = float('-inf')):
if not node:
return True
if node.data <= min_val or node.data >= max_val:
return False
return check(node.left, node.data, min_val) and check(node.right, max_val, node.data)

def check_binary_search_tree_(root):
return check(root)```
```

## Truck Tour

Suppose there is a circle. There are N petrol pumps on that circle. Petrol pumps are numbered 0 to (N-1) (both inclusive). You have two pieces of information corresponding to each of the petrol pump: (1) the amount of petrol that particular petrol pump will give, and (2) the distance from that petrol pump to the next petrol pump. Initially, you have a tank of infinite capacity carrying no petr

## Queries with Fixed Length

Consider an -integer sequence, . We perform a query on by using an integer, , to calculate the result of the following expression: In other words, if we let , then you need to calculate . Given and queries, return a list of answers to each query. Example The first query uses all of the subarrays of length : . The maxima of the subarrays are . The minimum of these is . The secon

## QHEAP1

This question is designed to help you get a better understanding of basic heap operations. You will be given queries of types: " 1 v " - Add an element to the heap. " 2 v " - Delete the element from the heap. "3" - Print the minimum of all the elements in the heap. NOTE: It is guaranteed that the element to be deleted will be there in the heap. Also, at any instant, only distinct element