Question: I know the theritical definition for distributed computing and interproces communication.

But in real time I was not able to come to conclusion that when we go for distributed or interprocess.

Tell me some scenario where we can go for distributed computing or interprocess communication by example.

Answer: 
The previous algorithm *(see revisions)* was `O(n^2)` - we can generalize it to `O(n log n)` by noticing the facts that:

1. If b is the root of the largest BST and `b.left.value < b.value`, then `b.left` is also in the BST (same for `b.right.value ≥ b.value`)
2. If b is the root of the largest BST and a is also in the BST, then every node between a and b is in the BST.

So if c is between a and b, and c is not in the BST rooted by b, neither is a *(due to (2.))*. Using this fact, we can easily determine if a node is in the BST rooted by any given ancestor. We'll do this by passing a node into our function along with a list of its ancestors, and the associated min/maxValues that the current child-node would have to satisfy if indeed that ancestor were the root of the largest BST (we'll call this list `ancestorList`). We'll store the entire collection of potential-roots in `overallRootsList`

Let's define a structure called potentialRoot as follows:

> 
> Each **potentialRoot** contains the following values:  
> 
>  \* **node**: The node we are considering for the root of the BST  
> 
>  \* **minValue and maxValue**: the range another node must fall between to be part of the BST rooted by node *(different for every node)*  
> 
>  \* **subNodes**: A list of the rest of the nodes in the largest BST rooted by node
> 
> 
> 

The pseudo code looks like this *(note that all lists mentioned are lists of potentialRoots)*:

```
FindLargestBST(node, ancestorList):
    leftList, rightList = empty lists
    for each potentialRoot in ancestorList:
        if potentialRoot.minValue < node.Value ≤ potentialRoot.maxValue:
            add node to potentialRoot.subNodes (due to (1.))
            (note that the following copies contain references, not copies, of subNodes)
            add copy of potentialRoot to leftList, setting maxValue = node.Value
            add copy of potentialRoot to rightList, setting minValue = node.Value

    add the potentialRoot (node, -∞, +∞) to leftList, rightList, and overallRootsList
    FindLargestBST(node.left, leftList)
    FindLargestBST(node.right, rightList)

```

At the end `overallRootsList` will be a list of `n` potentialRoots, each with a list of subNodes. The one with the largest subNodes list is your BST.

Since there are < treeHeight values in `ancestorList`, then (assuming the tree is balanced), the algorithm runs in `O(n log n)`
A binary search tree will give you a sorted result if you do a IN-ORDER Traversal. So, do an in-order traversal for the entire binary tree. The longest sorted sequence is your largest binary search sub tree.

* Do a inorder traversal of elements (VISIT LEFT, VISIT ROOT, VISIT RIGHT)
* While doing so, get the node data, compare whether the previous node data is lesser than the next data. If so, increment counter by 1. Store the start node.
* When the comparison fails, store the end node and reset counter to 0
* Store this information (counter,start,end) node in an array structure to later find which is having the maximum value and that will give you the longest binary search sub tree