diff --git a/Data Structures/Binary Tree/java/BinaryTree.java b/Data Structures/Binary Tree/java/BinaryTree.java new file mode 100644 index 00000000..097bff3b --- /dev/null +++ b/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'); + } + } diff --git a/Data Structures/priority queue/priorityQueue.js b/Data Structures/priority queue/priorityQueue.js new file mode 100644 index 00000000..fa699962 --- /dev/null +++ b/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));