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: 
**LARGEST BINARY SEARCH TREE IN A BINARY TREE:**

**There are two ways we can approach this problem,**

i)Largest BST not induced (From a node, all its children need not satisfy the BST condition)

ii)Largest BST induced (From a node , all its children will satisfy the BST condition)

We will discuss about the largest BST(Not Induced) here. We will follow bottom up approach(Post order traversal) to solve this.

a)Reach the leaf node

b)A tree node(from the leaf) will return a TreeNodeHelper object which has the following fields in it.

```
public static class TreeNodeHelper {
        TreeNode node;
        int nodes;
        Integer maxValue;
        Integer minValue;
        boolean isBST;

        public TreeNodeHelper() {}

        public TreeNodeHelper(TreeNode node, int nodes, Integer maxValue, Integer minValue, boolean isBST) {
            this.node = node;
            this.nodes = nodes;
            this.maxValue = maxValue;
            this.minValue = minValue;
            this.isBST = isBST;
        }      
    }

```

c)Initially from the leaf node, nodes=1,isBST=true,minValue=maxValue=node.data . And further, the nodes count will be increased if it satisfies the BST condition.

d)With the help of this, we will check the BST condition with current node. And we will repeat the same till root. 

e)From each node two objects will be returned. one for last maximum BST and another one for current BST satisfying nodes. So from each node(above leaf) (2+2)=4 (2 for left subtree and 2 for right sub tree) objects will be compared and two will be returned.

f) The final maximum node object from root will be the largest BST

**PROBLEM:**

There is a problem in this approach. While following this approach, if a subtree is not satisfying the BST condition with the current node, we can't simply ignore the subtree(even it has less number of nodes). For example 

```
 55
  \
   75
  /  \
 27  89
    /  \
   26  95
      /  \
     23  105
         /  \
        20  110

```

From the leaf nodes(20,110) the objects will be tested with node(105), it satisfies the condition. But when it reaches node(95) the leaf node(20) does not satisfy the BST condition. Since this solution is for BST(Not induced) we should not ignore node(105) and node(110) which satisfies the condition. So from node(95) we have to backtrack again testing BST condition and catch those nodes(105, 110).

The complete code for this implementation is available in this link

<https://github.com/dineshappavoo/Implementation/tree/master/LARGEST_BST_IN_BT_NOT_INDUCED_VER1.0>
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