Tree

//Node representation
class BSTNode<T> {
	T data;
	BSTNode<T> left, right;

	BSTNode(T val) {
//Note : T only in parameter not after Constructor name because it is itself a type
		this.data = val;
		left = right = null;//initiaize left and right node to null
	}
}
//BST Adding Nodes in tree,smaller goes to left and greater or equal goes right
public class BinarySearchTree {
//starting node of tree i.e root
	 BSTNode<Integer> root ;
 // Constructor with initialized reference node
BinarySearchTree(){
root=null;
}
	public static void main(String[] args) {

		BinarySearchTree tree = new BinarySearchTree();
		
		System.out.println("Inorder");
		inorderTraversal(root);
		

	}

// Runner code
public class BinarySearchTree {
//reference node poining to head
	static BSTNode<Integer> root;
//tree initialized to null
	BinarySearchTree() {
		root = null;
	}

	public static void main(String[] args) {
		BinarySearchTree tree = new BinarySearchTree();
		tree.insert(5);
		tree.insert(1);

	}

//Recursively inserting node in BST
void insert(int key) {
	
		root = insertREcur(root, key);// root is always pointing to first element after inserting as per logic
		
	}

	private BSTNode<Integer> insertREcur(BSTNode<Integer> current, int i) {

		if (current == null) {// //base con diton
			current = new BSTNode<>(i);

			return current;
		}
		if (i < current.data) {
			current.left = insertREcur(current.left, i); 

		} else if (i >= current.data) {		
			current.right = insertREcur(current.right, i);
		}
	
		return current;
	}

class BSTNode<T> {
	T data;
	BSTNode left, right;

	BSTNode(T val) {
		this.data = val;
		left = right = null;
	}
}

public class BinarySearchTree {
	static BSTNode<Integer> root;

	BinarySearchTree() {
		root = null;
	}

	public static void main(String[] args) {
		BinarySearchTree tree = new BinarySearchTree();

		System.out.println("Inorder");
		tree.inorderTraversal(root);

	}

	private void inorderTraversal(BSTNode<Integer> root) {

		if (root != null) {
			inorderTraversal(root.left);//Note: it's a recursive call in all tress in all operation not just direct data right/left call
			System.out.print(" --> " + root.data);
			inorderTraversal(root.right);

		}

	}

	private static void preorderTraversal(BSTNode<Integer> root) {
		if (root != null) {
			System.out.print(" --> " + root.data);
			preorderTraversal(root.left);
			preorderTraversal(root.right);
		}

	}

	private static void postorderTraversal(BSTNode<Integer> root) {

		if (root != null) {

			postorderTraversal(root.left);
			postorderTraversal(root.right);
			System.out.print(" --> " + root.data);
		}
	}

 void inorder(Node root)
    {
        if (root == null)
            return;

        Stack<Node> s = new Stack<Node>();
        Node curr = root;
 
        // traverse the tree
        while (curr != null || s.size() > 0)
        {
 
            /* Reach the left most Node of the
            curr Node */
            while (curr !=  null)
            {
                /* place pointer to a tree node on
                   the stack before traversing
                  the node's left subtree */
                s.push(curr);
                curr = curr.left;
            }
 
            /* Current must be NULL at this point */
            curr = s.pop();
 
            System.out.print(curr.data + " ");
 
            /* we have visited the node and its
               left subtree.  Now, it's right
               subtree's turn */
            curr = curr.right;
        }

// An iterative process to print preorder traversal of Binary tree
    void iterativePreorder(Node node)
    {
 
        // Base Case
        if (node == null) {
            return;
        }
 
        // Create an empty stack and push root to it
        Stack<Node> nodeStack = new Stack<Node>();
        nodeStack.push(root);
 
        /* Pop all items one by one. Do following for every popped item
         a) print it
         b) push its right child
         c) push its left child
         Note that right child is pushed first so that left is processed first */
        while (nodeStack.empty() == false) {
 
            // Pop the top item from stack and print it
            Node mynode = nodeStack.peek();
            System.out.print(mynode.data + " ");
            nodeStack.pop();
 
            // Push right and left children of the popped node to stack
            if (mynode.right != null) {
                nodeStack.push(mynode.right);
            }
            if (mynode.left != null) {
                nodeStack.push(mynode.left);
            }
        }
    }

// Iterative function to do Preorder
// traversal of the tree
void preorderIterative(Node node)
{
    if (node == null)
    {
        return;
    }
 
    Stack<Node> st = new Stack<Node>();
     
    // Start from root node (set curr
    // node to root node)
    Node curr = node;
     
    // Run till stack is not empty or
    // current is not NULL
    while (curr != null || !st.isEmpty())
    {
         
        // Print left children while exist
        // and keep pushing right into the 
        // stack.
        while (curr != null)
        {
            System.out.print(curr.data + " ");
             
            if (curr.right != null)
                st.push(curr.right);
                 
            curr = curr.left;
        }
         
        // We reach when curr is NULL, so We
        // take out a right child from stack
        if (!st.isEmpty())
        {
            curr = st.pop();
        }
    }
}

 // Two stacks as used in explanation
    static Stack<node> s1, s2;
 
    static void postOrderIterative(node root)
    {
        // Create two stacks
        s1 = new Stack<>();
        s2 = new Stack<>();
 
        if (root == null)
            return;
 
        // push root to first stack
        s1.push(root);
 
        // Run while first stack is not empty
        while (!s1.isEmpty()) {
            // Pop an item from s1 and push it to s2
            node temp = s1.pop();
            s2.push(temp);
 
            // Push left and right children of
            // removed item to s1
            if (temp.left != null)
                s1.push(temp.left);
            if (temp.right != null)
                s1.push(temp.right);
        }
 
        // Print all elements of second stack
        while (!s2.isEmpty()) {
            node temp = s2.pop();
            System.out.print(temp.data + " ");
        }
    }
 

printLevelorder(tree)
1) Create an empty queue q
2) temp_node = root /*start from root*/
3) Loop while temp_node is not NULL
    a) print temp_node->data.
    b) Enqueue temp_node’s children 
      (first left then right children) to q
    c) Dequeue a node from q.

// Iterative Queue based Java program
// to do level order traversal
// of Binary Tree

/* importing the inbuilt java classes
required for the program */
import java.util.Queue;
import java.util.LinkedList;

/* Class to represent Tree node */
class Node {
	int data;
	Node left, right;

	public Node(int item) {
		data = item;
		left = null;
		right = null;
	}
}

/* Class to print Level Order Traversal */
class BinaryTree {

	Node root;

	/* Given a binary tree. Print
	its nodes in level order
	using array for implementing queue */
	void printLevelOrder()
	{
		Queue<Node> queue = new LinkedList<Node>();
		queue.add(root);
		while (!queue.isEmpty())
		{

			/* poll() removes the present head.
			For more information on poll() visit
			http://www.tutorialspoint.com/java/
			util/linkedlist_poll.htm */
			Node tempNode = queue.poll();
			System.out.print(tempNode.data + " ");

			/*Enqueue left child */
			if (tempNode.left != null) {
				queue.add(tempNode.left);
			}

			/*Enqueue right child */
			if (tempNode.right != null) {
				queue.add(tempNode.right);
			}
		}
	}

	public static void main(String args[])
	{
		/* creating a binary tree and entering
		the nodes */
		BinaryTree tree_level = new BinaryTree();
		tree_level.root = new Node(1);
		tree_level.root.left = new Node(2);
		tree_level.root.right = new Node(3);
		tree_level.root.left.left = new Node(4);
		tree_level.root.left.right = new Node(5);

		System.out.println("Level order traversal
							of binary tree is - ");
		tree_level.printLevelOrder();
	}
}
//src- g4g

/*Function to print level order traversal of tree*/
printLevelorder(tree)
for d = 1 to height(tree)
   printCurrentLevel(tree, d);

/*Function to print all nodes at a current level*/
printCurrentLevel(tree, level)
if tree is NULL then return;
if level is 1, then
    print(tree->data);
else if level greater than 1, then
    printCurrentLevel(tree->left, level-1);
    printCurrentLevel(tree->right, level-1);