Merge remote-tracking branch 'origin/master'

Author: shashank-vishwakarma-rl

src/main/java/misc/DepthFirstSearchUsingStack.java renamed to src/main/java/dsa/graphs/DepthFirstSearchUsingStack.java

@@ -1,4 +1,4 @@
-package misc;
+package dsa.graphs;
 
 import java.util.Stack;
 

src/main/java/dsa/hashmap/CustomHashMap.java

@@ -0,0 +1,140 @@
+package dsa.hashmap;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+
+public class CustomHashMap {
+    static class HashMap<K, V> { //generics
+        private class Node {
+            K key;
+            V value;
+
+            public Node(K key, V value) {
+                this.key = key;
+                this.value = value;
+            }
+        }
+
+        private int nodeLength; //nodeLength - nodes
+        private int bucketSize = 4; //bucketSize - buckets
+        private LinkedList<Node>[] buckets; //bucketSize = buckets.length
+
+        @SuppressWarnings("unchecked")
+        public HashMap() {
+            this.buckets = new LinkedList[this.bucketSize];
+            for (int i = 0; i < this.bucketSize; i++) {
+                this.buckets[i] = new LinkedList<>();
+            }
+        }
+
+        private int hashFunction(K key) {
+            int bucketIndex = key.hashCode();
+            return Math.abs(bucketIndex) % bucketSize;
+        }
+
+        private int searchInLinkedList(K key, int bucketIndex) {
+            LinkedList<Node> ll = buckets[bucketIndex];
+
+            for (int i = 0; i < ll.size(); i++) {
+                if (ll.get(i).key == key) {
+                    return i; //dataIndex
+                }
+            }
+
+            return -1;
+        }
+
+        @SuppressWarnings("unchecked")
+        private void rehash() {
+            LinkedList<Node>[] oldBucket = buckets;
+            bucketSize = bucketSize * 2;
+            buckets = new LinkedList[bucketSize];
+            for (int i = 0; i < bucketSize; i++) {
+                buckets[i] = new LinkedList<>();
+            }
+            for (LinkedList<Node> ll : oldBucket) {
+                for (Node node : ll) {
+                    put(node.key, node.value);
+                }
+            }
+        }
+
+        public void put(K key, V value) {
+            int bucketIndex = hashFunction(key);
+            int dataIndex = searchInLinkedList(key, bucketIndex); //dataIndex = -1
+            if (dataIndex == -1) { //key doesn't exist
+                buckets[bucketIndex].add(new Node(key, value));
+                nodeLength++;
+            } else { //key exists
+                Node node = buckets[bucketIndex].get(dataIndex);
+                node.value = value;
+            }
+            double lambda = (double) nodeLength / bucketSize;
+
+            if (lambda > 2.0) {
+                rehash();
+            }
+        }
+
+        public boolean containsKey(K key) {
+            int bucketIndex = hashFunction(key);
+            int dataIndex = searchInLinkedList(key, bucketIndex); //dataIndex = -1
+            if (dataIndex == -1) { //key doesn't exist
+                return false;
+            } else { //key exists
+                return true;
+            }
+        }
+
+        public V remove(K key) {
+            int bucketIndex = hashFunction(key);
+            int dataIndex = searchInLinkedList(key, bucketIndex); //dataIndex = -1
+            if (dataIndex == -1) { //key doesn't exist
+                return null;
+            } else { //key exists
+                Node node = buckets[bucketIndex].remove(dataIndex);
+                nodeLength--;
+                return node.value;
+            }
+        }
+
+        public V get(K key) {
+            int bucketIndex = hashFunction(key);
+            int dataIndex = searchInLinkedList(key, bucketIndex); //dataIndex = -1
+            if (dataIndex == -1) { //key doesn't exist
+                return null;
+            } else { //key exists
+                Node node = buckets[bucketIndex].get(dataIndex);
+                return node.value;
+            }
+        }
+
+        public ArrayList<K> keySet() {
+            ArrayList<K> keys = new ArrayList<>();
+            for (LinkedList<Node> ll : buckets) {
+                for (Node node : ll) { //dataIndex
+                    keys.add(node.key);
+                }
+            }
+            return keys;
+        }
+
+        public boolean isEmpty() {
+            return nodeLength == 0;
+        }
+    }
+
+    public static void main(String[] args) {
+        HashMap<String, Integer> map = new HashMap<>();
+        map.put("India", 190);
+        map.put("China", 200);
+        map.put("US", 50);
+        ArrayList<String> keys = map.keySet();
+        for (String key : keys) {
+            System.out.println(key + " " + map.get(key));
+        }
+
+        map.remove("India");
+        System.out.println(map.get("India"));
+    }
+}

src/main/java/dsa/stacksqueues/CircularQueue.java renamed to src/main/java/dsa/queue/CircularQueue.java

@@ -1,4 +1,4 @@
-package dsa.stacksqueues;
+package dsa.queue;
 
 public class CircularQueue {
     protected int[] data;

src/main/java/dsa/stacksqueues/CustomQueue.java renamed to src/main/java/dsa/queue/CustomQueue.java

@@ -1,4 +1,4 @@
-package dsa.stacksqueues;
+package dsa.queue;
 
 import java.util.NoSuchElementException;
 

src/main/java/dsa/stacksqueues/DynamicQueue.java renamed to src/main/java/dsa/queue/DynamicQueue.java

@@ -1,4 +1,4 @@
-package dsa.stacksqueues;
+package dsa.queue;
 
 public class DynamicQueue extends CircularQueue {
     public DynamicQueue() {

src/main/java/dsa/queue/QueueUsingArrayList.java

@@ -0,0 +1,71 @@
+package dsa.queue;
+
+public class QueueUsingArrayList {
+    public static void main(String args[]) {
+        Queue q = new Queue(5);
+        q.add(1);
+        q.add(2);
+        q.add(3);
+        System.out.println(q.remove());
+        System.out.println(q.peek());
+    }
+
+    static class Queue {
+        static int[] arr;
+        static int size;
+        static int rear;
+
+
+        Queue(int size) {
+            Queue.size = size;
+            arr = new int[size];
+            rear = -1;
+        }
+
+
+        public static boolean isEmpty() {
+            return rear == -1;
+        }
+
+
+        public static boolean isFull() {
+            return rear == size - 1;
+        }
+
+
+        public static void add(int data) {
+            if (isFull()) {
+                System.out.println("Queue Overflow");
+                return;
+            }
+            arr[++rear] = data;
+        }
+
+
+        //O(n)
+        public static int remove() {
+            if (isEmpty()) {
+                System.out.println("Queue is empty");
+                return -1;
+            }
+            int front = arr[0];
+            for (int i = 0; i < rear; i++) {
+                arr[i] = arr[i + 1];
+            }
+            rear--;
+            return front;
+        }
+
+
+        public static int peek() {
+            if (isEmpty()) {
+                System.out.println("empty queue");
+                return -1;
+            }
+
+            return arr[0];
+        }
+    }
+
+
+}

src/main/java/dsa/queue/QueueUsingLinkedList.java

@@ -0,0 +1,70 @@
+package dsa.queue;
+
+public class QueueUsingLinkedList {
+    public static void main(String[] args) {
+        Queue q = new Queue();
+        q.add(1);
+        q.add(2);
+        q.add(3);
+        q.add(4);
+        q.add(5);
+
+
+        while (!q.isEmpty()) {
+            System.out.println(q.peek());
+            q.remove();
+        }
+    }
+
+    static class Node {
+        int data;
+        Node next;
+
+        Node(int data) {
+            this.data = data;
+            next = null;
+        }
+    }
+
+    static class Queue {
+        static Node head = null;
+        static Node tail = null;
+
+        public static boolean isEmpty() {
+            return head == null && tail == null;
+        }
+
+        public static void add(int data) {
+            Node newNode = new Node(data);
+            if (isEmpty()) {
+                tail = head = newNode;
+            } else {
+                tail.next = newNode;
+                tail = newNode;
+            }
+        }
+
+        public static int remove() {
+            if (isEmpty()) {
+                System.out.println("empty queue");
+                return -1;
+            }
+            int front = head.data;
+            //single node
+            if (head == tail) {
+                tail = null;
+            }
+            head = head.next;
+            return front;
+        }
+
+        public static int peek() {
+            if (isEmpty()) {
+                System.out.println("empty queue");
+                return -1;
+            }
+
+            return head.data;
+        }
+    }
+}

src/main/java/dsa/stacksqueues/CustomStack.java renamed to src/main/java/dsa/stack/CustomStack.java

@@ -1,4 +1,4 @@
-package dsa.stacksqueues;
+package dsa.stack;
 
 import java.util.EmptyStackException;
 

src/main/java/dsa/stacksqueues/DynamicStack.java renamed to src/main/java/dsa/stack/DynamicStack.java

@@ -1,4 +1,4 @@
-package dsa.stacksqueues;
+package dsa.stack;
 
 public class DynamicStack extends CustomStack {
 

src/main/java/dsa/stack/StackUsingArrayList.java

@@ -0,0 +1,46 @@
+package dsa.stack;
+
+import java.util.ArrayList;
+
+public class StackUsingArrayList {
+    public static void main(String[] args) {
+        Stack stack = new Stack();
+        stack.push(1);
+        stack.push(2);
+        stack.push(3);
+        stack.push(4);
+
+        while (!stack.isEmpty()) {
+            System.out.println(stack.peek());
+            stack.pop();
+        }
+    }
+
+    static class Stack {
+        ArrayList<Integer> list = new ArrayList<>();
+
+        public void push(int data) {
+            list.add(data);
+        }
+
+        public boolean isEmpty() {
+            return list.size() == 0;
+        }
+
+        public int pop() {
+            if (isEmpty()) {
+                return -1;
+            }
+            int top = list.remove(list.size() - 1);
+            return top;
+        }
+
+        public int peek() {
+            if (isEmpty()) {
+                return -1;
+            }
+            return list.get(list.size() - 1);
+        }
+    }
+
+}