LRU vs LFU

Least Recently Used ( LRU) 

 

The eldest element, is the Least Recently Used (LRU). The last used timestamp is updated when an element is put into the cache or an element is retrieved from the cache with a get call.

Less Frequently Used ( LFU)

For each get call on the element the number of hits is updated. When a put call is made for a new element (and assuming that the max limit is reached for the memory store) the element with least number of hits, the Less Frequently Used element, is evicted.

Difference between “on-heap” and “off-heap”

The on-heap store refers to objects that will be present in the Java heap (and also subject to GC). On the other hand, the off-heap store refers to (serialized) objects that are managed by EHCache, but stored outside the heap (and also not subject to GC).

Algorithm for finding the maximum element in binary tree without recursion java

public void findMax(Node node) {
        int root_val,max_val=0;
        if(null!=node) {
              Queue<Node> queue = new LinkedBlockingQueue<>();
              queue.add(node);
             
              while(!queue.isEmpty()) {
                  Node temp = queue.remove();
                  root_val = temp.value;
                  max_val = max_val<root_val ? root_val :max_val;
                 
                  if(null!=temp.left) {
                      queue.add(temp.left);
                  }
                  if(null!=temp.right) {
                      queue.add(temp.right);
                  }
              }
             
        }
       
        System.out.println(max_val);
    }

Algorithm for finding maximum element in binary tree java

public int findMax(Node node) {
        int maxVal = 0, root_val ,left_val,right_val;
       
        if(null!=node) {
            root_val = node.value;
            left_val = findMax(node.left);
            right_val = findMax(node.right);   
            maxVal = left_val>right_val ? left_val :right_val;
            maxVal = maxVal>root_val ? maxVal : root_val;
        }
       
       
        return maxVal;
    }

Algorithm for searching an element in binary tree java

public class SearchANodeUsingRecusrtion {
    public static void main(String args[]) {
        Node node = new Node(1);
        node.left = new Node(2);
        node.right = new Node(3);
        node.left.left = new Node(4);
        node.left.right = new Node(5);
        node.right.left = new Node(6);
        node.right.right = new Node(7);
        SearchANodeUsingRecusrtion searchANodeUsingRecusrtion = new SearchANodeUsingRecusrtion();
        int output = searchANodeUsingRecusrtion.searchNode(node,6);
        if(output==1)
            System.out.println("found");
        else
            System.out.println("not found");
    }
   
    public int searchNode(Node node,int key) {
        if(null!=node) {
            if(node.value==key) {
                return 1;
            }else {
                int temp = searchNode(node.left,key);
                if(temp!=0) {
                    return 1;
                }else {
                 temp =    searchNode(node.right,key);
                 return temp;
                }
               
            }
       
        }else {
            return 0;
        }
       
    }
   
}


class BinayTree{
    static class Node{
        String value;
        Node left;
        Node right;
       
        Node(String val){
            value = val;
            left = right = null;
        }
       
    }
   
}

algorithm for searching an element in binary tree without recursion java

public class SearchNodewithoutRecursion {
    public static void main(String args[]) {
        Node node = new Node(1);
        node.left = new Node(2);
        node.right = new Node(3);
        node.left.left = new Node(4);
        node.left.right = new Node(5);
        node.right.left = new Node(6);
        node.right.right = new Node(7);
        SearchNodewithoutRecursion searchANodeUsingRecusrsion = new SearchNodewithoutRecursion();
        int val = searchANodeUsingRecusrsion.findNode(node, 4);
        if(val==1)
            System.out.println("found");
        else
            System.out.println("not found");
    }
   
    public int findNode(Node node, int key) {
        if(null!=node) {
            Queue<Node> queue = new LinkedBlockingQueue<>();
            queue.add(node);
            while(!queue.isEmpty()) {
                Node temp = queue.remove();
                System.out.println(temp.value);
                if(temp.value == key) {
                    return 1;
                }
                if(null!=temp.left) {
                    queue.add(temp.left);
                }
                if(null!=temp.right) {
                    queue.add(temp.right);
                }
            }
        }
            return 0;
       
    }
}

class BinayTree{
    static class Node{
        String value;
        Node left;
        Node right;
       
        Node(String val){
            value = val;
            left = right = null;
        }
       
    }
   
}

TreeTraversal(InOrder,PreOrder,PostOrder) with recursion and without recursion

public class TreeTraversal {
    public static void main(String args[]) {
         Node rootNode = new Node("4");
         rootNode.left = new Node("2");
         rootNode.left.left = new Node("1");
         rootNode.left.right = new Node("3");
         rootNode.right = new Node("6");
         rootNode.right.right = new Node("7");
         rootNode.right.left = new Node("5");
        // System.out.println(rootNode);
         System.out.println("********pre order*********");
         preorderTraversal(rootNode);
         System.out.println("\n\n********in order*********");
         inorderTraversal(rootNode);
         System.out.println("\n\n********post order*********");
         postorderTraversal(rootNode);
         System.out.println("\n\n********* pre order without recursion******");
         preOrderWithoutRecursion(rootNode);
         System.out.println("\n\n********in order without recursion********");
         inOrderWithoutRecursion(rootNode);
         System.out.println("\n\n*******post without recursion****");
         postOrderWithoutRecursion(rootNode);
    }
   
    public static void preorderTraversal(Node rootNode) {
        if(null!=rootNode) {
            System.out.print(rootNode.value);
             preorderTraversal(rootNode.left);
             preorderTraversal(rootNode.right);
        }
    }
    public static void inorderTraversal(Node rootNode) {
        if(null!=rootNode) {
            inorderTraversal(rootNode.left);
             System.out.print(rootNode.value);
             inorderTraversal(rootNode.right);
        }
    }
    public static void postorderTraversal(Node rootNode) {
        if(null!=rootNode) {
            postorderTraversal(rootNode.left);
            postorderTraversal(rootNode.right);
             System.out.print(rootNode.value);
        }
    }
   
    public static void preOrderWithoutRecursion(Node root) {
        Stack<Node> stNodes = new Stack<>();
        Node current = root;
        while(!stNodes.isEmpty() || current!=null) {
            if(null!=current) {
                stNodes.push(current);
                System.out.print(current.value);
                current = current.left;
            }else {
                Node node = stNodes.pop();
               
                current = node.right;
            }
        }
    }
   
    public static void inOrderWithoutRecursion(Node root) {
        Stack<Node> stNodes = new Stack<>();
        Node current = root;
        while(!stNodes.isEmpty() || current!=null) {
            if(null!=current) {
                stNodes.push(current);
                current = current.left;
            }else {
                Node node = stNodes.pop();
                System.out.print(node.value);
                current = node.right;
            }
        }
    }
    public static void postOrderWithoutRecursion(Node root) {
        Stack<Node> stack1 = new Stack<>();
        Stack<Node> stack2 = new Stack<>();
        Node current = root;
        stack1.push(root);
   
        while(!stack1.isEmpty() ) {
             Node node =  stack1.pop();
             stack2.push(node);
             if(null!=node.left) {
             stack1.push(node.left);
             }if(null!=node.right) {
                 stack1.push(node.right);
             }   
        }
       
        while(!stack2.isEmpty()) {
            System.out.print(stack2.pop().value);
        }
       
    }
   
}


class BinayTree{
    static class Node{
        String value;
        Node left;
        Node right;
       
        Node(String val){
            value = val;
            left = right = null;
        }
       
    }
   
}


output:
********pre order*********
4213657

********in order*********
1234567

********post order*********
1325764

********* pre order without recursion******
4213657

********in order without recursion********
1234567

*******post without recursion****
1325764

Delete gridfs file mongo db shell script

if we want to delete gridfs file from mongo db with chunks and file then use below script:

mydoc: is my collection that contain the reference of gridFsFileId for each document

as i want to delete all document below or equal from a particular date:


db.mydoc.find({ "creationTime": { $lte: NumberLong(1485172670719)}}).forEach(
function(mydoc){
  if(mydoc!==null){
    //remove chunk in loop
      db.fs.chunks.remove({
    "files_id": ObjectId(mydoc.gridFsFileId)
    });
    //remove file
        db.fs.files.remove({
           "_id": ObjectId(mydoc.gridFsFileId)
        });
      
      
        //remove from mydoc
      
        db.mydoc.remove({
                "gridFsFileId":  mydoc.gridFsFileId
        });
  }
}
);