Implemented Binary tree in java

Data Structures/Binary Tree/java/BinaryTree.java

@@ -0,0 +1,221 @@
+import java.util.Scanner;
+
+ /* Class BTNode */
+ class BTNode
+ {    
+     BTNode left, right;
+     int data;
+
+     /* Constructor */
+     public BTNode()
+     {
+         left = null;
+         right = null;
+         data = 0;
+     }
+     /* Constructor */
+     public BTNode(int n)
+     {
+         left = null;
+         right = null;
+         data = n;
+     }
+     /* Function to set left node */
+     public void setLeft(BTNode n)
+     {
+         left = n;
+     }
+     /* Function to set right node */ 
+     public void setRight(BTNode n)
+     {
+         right = n;
+     }
+     /* Function to get left node */
+     public BTNode getLeft()
+     {
+         return left;
+     }
+     /* Function to get right node */
+     public BTNode getRight()
+     {
+         return right;
+     }
+     /* Function to set data to node */
+     public void setData(int d)
+     {
+         data = d;
+     }
+     /* Function to get data from node */
+     public int getData()
+     {
+         return data;
+     }     
+ }
+
+ /* Class BT */
+ class BT
+ {
+     private BTNode root;
+
+     /* Constructor */
+     public BT()
+     {
+         root = null;
+     }
+     /* Function to check if tree is empty */
+     public boolean isEmpty()
+     {
+         return root == null;
+     }
+     /* Functions to insert data */
+     public void insert(int data)
+     {
+         root = insert(root, data);
+     }
+     /* Function to insert data recursively */
+     private BTNode insert(BTNode node, int data)
+     {
+         if (node == null)
+             node = new BTNode(data);
+         else
+         {
+             if (node.getRight() == null)
+                 node.right = insert(node.right, data);
+             else
+                 node.left = insert(node.left, data);             
+         }
+         return node;
+     }     
+     /* Function to count number of nodes */
+     public int countNodes()
+     {
+         return countNodes(root);
+     }
+     /* Function to count number of nodes recursively */
+     private int countNodes(BTNode r)
+     {
+         if (r == null)
+             return 0;
+         else
+         {
+             int l = 1;
+             l += countNodes(r.getLeft());
+             l += countNodes(r.getRight());
+             return l;
+         }
+     }
+     /* Function to search for an element */
+     public boolean search(int val)
+     {
+         return search(root, val);
+     }
+     /* Function to search for an element recursively */
+     private boolean search(BTNode r, int val)
+     {
+         if (r.getData() == val)
+             return true;
+         if (r.getLeft() != null)
+             if (search(r.getLeft(), val))
+                 return true;
+         if (r.getRight() != null)
+             if (search(r.getRight(), val))
+                 return true;
+         return false;         
+     }
+     /* Function for inorder traversal */
+     public void inorder()
+     {
+         inorder(root);
+     }
+     private void inorder(BTNode r)
+     {
+         if (r != null)
+         {
+             inorder(r.getLeft());
+             System.out.print(r.getData() +" ");
+             inorder(r.getRight());
+         }
+     }
+     /* Function for preorder traversal */
+     public void preorder()
+     {
+         preorder(root);
+     }
+     private void preorder(BTNode r)
+     {
+         if (r != null)
+         {
+             System.out.print(r.getData() +" ");
+             preorder(r.getLeft());             
+             preorder(r.getRight());
+         }
+     }
+     /* Function for postorder traversal */
+     public void postorder()
+     {
+         postorder(root);
+     }
+     private void postorder(BTNode r)
+     {
+         if (r != null)
+         {
+             postorder(r.getLeft());             
+             postorder(r.getRight());
+             System.out.print(r.getData() +" ");
+         }
+     }     
+ }
+
+ /* Class BinaryTree */
+ public class BinaryTree
+ {
+     public static void main(String[] args)
+    {            
+        Scanner scan = new Scanner(System.in);
+        /* Creating object of BT */
+        BT bt = new BT(); 
+        /*  Perform tree operations  */
+        System.out.println("Binary Tree Test\n");          
+        char ch;        
+        do    
+        {
+            System.out.println("\nBinary Tree Operations\n");
+            System.out.println("1. insert ");
+            System.out.println("2. search");
+            System.out.println("3. count nodes");
+            System.out.println("4. check empty");
+
+            int choice = scan.nextInt();            
+            switch (choice)
+            {
+            case 1 : 
+                System.out.println("Enter integer element to insert");
+                bt.insert( scan.nextInt() );                     
+                break;                          
+            case 2 : 
+                System.out.println("Enter integer element to search");
+                System.out.println("Search result : "+ bt.search( scan.nextInt() ));
+                break;                                          
+            case 3 : 
+                System.out.println("Nodes = "+ bt.countNodes());
+                break;     
+            case 4 : 
+                System.out.println("Empty status = "+ bt.isEmpty());
+                break;            
+            default : 
+                System.out.println("Wrong Entry \n ");
+                break;   
+            }
+            /*  Display tree  */ 
+            System.out.print("\nPost order : ");
+            bt.postorder();
+            System.out.print("\nPre order : ");
+            bt.preorder();
+            System.out.print("\nIn order : ");
+            bt.inorder();
+
+            System.out.println("\n\nDo you want to continue (Type y or n) \n");
+            ch = scan.next().charAt(0);                        
+        } while (ch == 'Y'|| ch == 'y');               
+    }
+ }

Data Structures/priority queue/priorityQueue.js

@@ -0,0 +1,123 @@
+(function (exports) {
+
+  var MaxHeap = {	
+    h: [],
+
+    last: function () {
+      return this.h.pop();
+    },
+
+    size: function () {
+      return this.h.length;
+    },
+
+    push: function (e) {
+      var i = this.size(),
+
+      parent = Math.ceil(i / 2) - 1;
+      this.h[i] = e;
+      this.bubbleUp(i);
+		},
+
+    bubbleUp: function (i) {
+      var parent;
+
+      while (i > 0) {
+        parent = Math.ceil(i / 2) - 1;
+        if (this.h[parent] < this.h[i]) {
+          this.swap(this.h, parent, i);
+          i = parent;
+        } else {
+          return;
+        }
+      }
+    },
+
+    pop: function () {
+      var head = this.h[0];
+
+      this.h[0] = this.last();
+      this.h.splice(this.size() - 1, 1);
+      this.heapify(0);
+
+      return head;
+    },
+
+    peek: function () {
+      return this.h[0];
+    },
+
+    swap: function (a, i , j) {
+      var tmp = a[i];
+
+      a[i] = a[j];
+      a[j] = tmp;
+    },
+
+    sinkDown:  function (i, a) {
+      var left = 2 * i + 1,
+          right = left + 1,
+          largest = i,
+          len = a.length;
+      a = a || this.h;
+
+      if (left < len && a[left] > a[largest]) {
+        largest = left;
+      }
+
+      if (right < len && a[right] > a[largest]) {
+        largest = right;
+      }
+
+      if (largest !== i) {
+        this.swap(a, i, largest);
+        this.sinkDown(largest, a);
+      }
+    },
+
+    remove: function (e) {
+      var i = -1,
+          len = this.size(),
+          parent;
+
+      while (++i < len) {
+        if (this.h[i] === e) {
+          e = this.last();
+
+          if (i !== len - 1) {
+            this.h[i] = e;
+            parent = this.h[Math.ceil(i / 2 - 1)];
+            (parent > e)?  this.sinkDown(i) : this.bubbleUp(i);
+          }
+
+          return;
+        }
+      };
+    },
+
+    buildHeap: function (a) {
+      var i = Math.floor(a.length / 2);
+
+      while (i-- >= 0) {
+        this.sinkDown(i, a);
+      }
+    },
+
+    create: function (a) {
+      var o = Object.create(this);
+
+      if (a && (a instanceof Array)) {
+        o.buildHeap(o.h = a);
+      }
+
+      return o;
+    },
+
+    toSortedArray: function () {
+      ///TODO needs to implemented
+      return false;
+    }
+  };
+
+  exports.MaxHeap = MaxHeap;
+}(this));