Find if a Tree is a Binary Search Tree

public boolean isBinarySearchTree() {
return isBinarySearchTree(this, -99999, 99999);
}
public boolean isBinarySearchTree(BinarySearchTree T, int min, int max) {
if(T==null)return true;
if(T.data>min && T.data<max 
&& isBinarySearchTree(T.left, min, T.data) && isBinarySearchTree(T.right, T.data, max))
return true;
return false;
}

Delete Node from Binary Search Tree

// Binary Search Tree full program is available here: link

    private BinarySearchTree ParentNode; //Parent Node of the node to delete

    private boolean LeftOrRightFlag; //Deleting node is Left from parent means true, else Right means false

    public void DeleteNode(int data)    {
        DeleteNode(this, data);
    }
    private void DeleteNode(BinarySearchTree T, int data)    {
        if(T==null) return;
        if(data==T.data)    {    //delete root note
            T.data=getMin(T.right).data;
            DeleteNode(T.right, T.data);
        }    else    {
            BinarySearchTree Current = findNode(T, data);
            if(Current.left==null && Current.right==null)
                if(LeftOrRightFlag)
                    ParentNode.left=null;
                else
                    ParentNode.right=null;
            else if(Current.left==null)
                if(LeftOrRightFlag)
                    ParentNode.left=Current.right;
                else
                    ParentNode.right=Current.right;
            else if(Current.right==null)
                if(LeftOrRightFlag)
                    ParentNode.left=Current.left;
                else
                    ParentNode.right=Current.left;
            else    {//Current node has both children
                Current.data=getMin(Current.right).data;
                DeleteNode(T.right, Current.data);
            }
        }
    }

    private BinarySearchTree getMin(BinarySearchTree T)    {
        while(T.left!=null)
            T=T.left;
        return T;
    }

    public BinarySearchTree findNode(BinarySearchTree T,int data)    {    //except root
        if(data==T.data)
            return T;
        else if(data<T.data)    {
            ParentNode=T;
            LeftOrRightFlag=true;
            return findNode(T.left, data);
        }    else    {
            ParentNode=T;
            LeftOrRightFlag=false;
            return findNode(T.right, data);
        }
    }

get InOrder sucessor of a given node in a BST

    private Stack<BinarySearchTree> S;
    public int inOrderSuccessor(int data)    {
        S = new Stack<BinarySearchTree>();
        BinarySearchTree Current = getNode(this, data);
        if(Current.right!=null)    {
            return getMin(Current.right).data;
        }    else    {
            BinarySearchTree parent = S.pop();
            if(parent.left==Current)
                return parent.data;
            else
                return S.pop().data;
        }
    }
    private BinarySearchTree getMin(BinarySearchTree T)    {
        while(T.left!=null)
            T=T.left;
        return T;
    }
    private BinarySearchTree getNode(BinarySearchTree T, int data)    {
        if(T==null)    return null;
        else if(data==T.data)        {
            return T;
        }
        else if(data<T.data) {
            S.add(T);
            return getNode(T.left, data);
        }
        else {
            S.add(T);
            return getNode(T.right, data);
        }
    }

is Binary Tree a Binary Search Tree

    public boolean isBinarySearchTree()    {
        return isBinaryTree(this, (-10^23), 10^23);
    }
    private boolean isBinarySearchTree(BinaryTree T, int min, int max)    {
        if(T==null) return true;
        if(T.data>min && T.data<max
                && isBinaryTree(T.left, min, T.data)
                && isBinaryTree(T.right, T.data, max))
            return true;
        return false;
    }

Insert Sorted Array into a Binary Search Tree with minimum height

public class BinarySearchTree {
    BinarySearchTree left, right;
    int data;
    public BinarySearchTree(int... SortedArrayOfdata) {
        int mid=SortedArrayOfdata.length/2;
        this.left=null;
        this.right=null;
        this.data=SortedArrayOfdata[mid];
        insertSortedArray(SortedArrayOfdata, 0, mid-1);
        insertSortedArray(SortedArrayOfdata, mid+1, SortedArrayOfdata.length-1);
    }
    private void insertSortedArray(int[] a, int startIndex, int endIndex)    {
        if(startIndex<=endIndex)    {
            int mid=(startIndex+endIndex)/2;
            insert(a[mid]); //Insert method is available here: link
            insertSortedArray(a, startIndex, mid-1);
            insertSortedArray(a, mid+1, endIndex);
        }
    }
}

Example Input:
BinarySearchTree BST = new BinarySearchTree(0,1,2,3,4,5,6,7,8,9,10,11,12,13);

Find all Root to Leaf Path of a Binary Tree

 This program uses the Binary Search Tree program available here: link
The same program can also be used for Binary Tree

    public void FindAllRoot2LeefPath()    {
        ArrList = new ArrayList<CustomLinkedList>();
        FindAllRoot2LeefPath(this, new ArrayList<Integer>());
        for(CustomLinkedList L:ArrList)    {
            L.printList();
        }
    }
   
    public ArrayList<CustomLinkedList> ArrList;
   
    private ArrayList<Integer> FindAllRoot2LeefPath(BinarySearchTree T, ArrayList<Integer> path)    {
        if(T!=null){
            path.add(T.data);
            if(T.left==null && T.right==null)    {
                CustomLinkedList L = new CustomLinkedList(path.get(0));
                L.appendList(path);
                ArrList.add(L);
                System.out.println(path);
            }    else    {
                FindAllRoot2LeefPath(T.left, new ArrayList<>(path));
                FindAllRoot2LeefPath(T.right, new ArrayList<>(path));
            }
        }
        return path;
    }
/*-----------------------------------------------------------------------------------------------*/
CustomLinkedList is a program given here: link
I added one more method there for this:

    public void appendList(ArrayList<Integer> ArrList)    {
        int size = ArrList.size();
        /*Starts from i=1 because
         * Head Element already need to be added when creating a new list*/
        for(int i=1;i<size;i++)    {
            append(ArrList.get(i));           
        }
    }

Height of a Binary Tree

This program uses the Binary Search Tree program available here: link
The same program can also be used for Binary Tree 

    public int FindHeight()    {
        return FindHeight(this);
    }
   
    private int FindHeight(BinarySearchTree T)    {
        if(T!=null)    {
            return max(FindHeight(T.left), FindHeight(T.right))+1;
        }    else return -1;
    }
   
    private int max(int a, int b)    {
        if (a>b) return a;
        else return b;
    }

Level Order Traversal or BFS in a Binary Tree

In a Binary Tree, Level Order Traversal is also known as Breadth-first search or BFS. This BFS is different from a non-Binary Tree Graph.

This program uses the Binary Search Tree program available here: link
The same program can also be used for Binary Tree

//BinarySearchTree Reffers to the link given above
     public String LevelOrder()    {
        Queue<BinarySearchTree> Q = new LinkedList<BinarySearchTree>();
        StringBuffer sb = new StringBuffer();
        Q.add(this); //Inserting Root Node to Queue
        while(Q.size()!=0)    {
            BinarySearchTree CurrentNode = Q.remove();
            sb.append(CurrentNode.data).append(", ");
            if(CurrentNode.left!=null)
                Q.add(CurrentNode.left);
            if(CurrentNode.right!=null)
                Q.add(CurrentNode.right);
        }
        return sb.toString();
    }

Simple Binary Search Tree using Java

Input: List of Intigers

public class BinarySearchTree {
    BinarySearchTree left, right;
    int data;

    public BinarySearchTree(int data) {
        System.out.println("newNode "+data);
        this.data = data;
        left=null;
        right=null;
    }

    public void insertElement(int... element)    {
        int size=element.length;
        for(int i=0; i<size; i++)    {
            System.out.println(element[i]);
            insertElement(this, element[i]);
        }
    }

    public void insertElement(int element)    {
        insertElement(this,element);
    }

    private void insertElement(BinarySearchTree T, int element)    {
        if(element==T.data)    {
            System.out.println("ERROR: Data already exist");
        }    else if(T.left == null && T.right ==null)    {
                if(element<T.data)
                    T.left=new BinarySearchTree(element);
                else
                    T.right=new BinarySearchTree(element);
        }    else if(T.left == null)    {
                if(element<T.data)
                    T.left=new BinarySearchTree(element);
                else
                    insertElement(T.right, element);
        }    else if(T.right == null)    {
                if(element>T.data)
                    T.right=new BinarySearchTree(element);
                else
                    insertElement(T.left, element);
        }    else    {    //Root has both Left and Right
                if(element<T.data)
                    insertElement(T.left, element);
                else
                    insertElement(T.right, element);
        }
    }

    public String PreOrder()    {
        return PreOrder(new StringBuffer(), this).toString();
    }
   
    private StringBuffer PreOrder(StringBuffer sb, BinarySearchTree T)    {
        if(T!=null)    {
            PreOrder(sb, T.left);
            PreOrder(sb, T.right);
            sb.append(T.data).append(", ");
            return sb;
        }    else return sb;
    }
   
    public String PostOrder()    {
        return PostOrder(new StringBuffer(), this).toString();
    }
   
    private StringBuffer PostOrder(StringBuffer sb, BinarySearchTree T)    {
        if(T!=null)    {
            sb.append(T.data).append(", ");
            PreOrder(sb, T.left);
            PreOrder(sb, T.right);
            return sb;
        }    else return sb;
    }
   
    public String InOrder()    {
        return InOrder(new StringBuffer(), this).toString();
    }
   
    private StringBuffer InOrder(StringBuffer sb, BinarySearchTree T)    {
        if(T!=null)    {
            InOrder(sb, T.left);
            sb.append(T.data).append(", ");
            InOrder(sb, T.right);
            return sb;
        }    else return sb;
    }
}