Add files via upload

Author: rishabhsdev

HashMaps/Chaining.java

@@ -0,0 +1,66 @@
+package DataStructures.HashMaps;
+
+import java.util.LinkedList;
+
+public class Chaining {
+
+    public class Entry {
+
+        int key;
+        String value;
+
+        public Entry(int key, String value) {
+            this.key = key;
+            this.value = value;
+        }
+
+    }
+
+    LinkedList<Entry>[] entries = new LinkedList[5];
+
+    public void put(int key, String value) {
+
+        int index = hash(key);
+
+        if (entries[index] == null) {
+            entries[index] = new LinkedList<Entry>();
+        }
+
+        for (Entry entry : entries[index]) {
+            if (entry.key == key) {
+                entry.value = value;
+            }
+        }
+
+        Entry entry = new Entry(key, value);
+        entries[index].addLast(entry);
+    }
+
+    public String get(int key) {
+
+        int index = hash(key);
+
+        for (Entry entry : entries[index]) {
+            if (entry.key == key) {
+                return entry.value;
+            }
+        }
+
+        return "Not Found";
+    }
+
+    public void remove(int key) {
+        int index = hash(key);
+
+        for (Entry entry : entries[index]) {
+            if (entry.key == key) {
+                entries[index].remove(entry);
+                return;
+            }
+        }
+    }
+
+    private int hash(int key) {
+        return key % entries.length;
+    }
+}

HashMaps/LinearProbing.java

@@ -0,0 +1,79 @@
+package DataStructures.HashMaps;
+
+import java.util.LinkedList;
+
+public class LinearProbing {
+    public class Entry {
+
+        int key;
+        String value;
+
+        public Entry() {
+        }
+
+        public Entry(int key, String value) {
+            this.key = key;
+            this.value = value;
+        }
+
+    }
+
+    Entry[] entries = new Entry[5];
+
+    public void put(int key, String value) {
+
+        int index = hash(key);
+        int previous = index - 1;
+
+        while (entries[index] != null) {
+            if (index > previous) {
+                System.out.println("List full");
+                break;
+            } else if (index >= entries.length) {
+                index = 0;
+            }
+            index++;
+        }
+
+        Entry entry = new Entry(key, value);
+        entries[index] = entry;
+    }
+
+    public String get(int key) {
+
+        int index = hash(key);
+        int previous = index - 1;
+
+        while (entries[index].key != key) {
+            if (index > previous) {
+                return "Not Found";
+            } else if (index >= entries.length) {
+                index = 0;
+            }
+            index++;
+        }
+
+        return entries[index].value;
+
+    }
+
+    public void remove(int key) {
+        int index = hash(key);
+        int previous = index - 1;
+
+        while (entries[index].key != key) {
+            if (index > previous) {
+                return;
+            } else if (index >= entries.length) {
+                index = 0;
+            }
+            index++;
+        }
+
+        entries[index] = null;
+    }
+
+    private int hash(int key) {
+        return key % entries.length;
+    }
+}

HashMapsExample.java

@@ -0,0 +1,41 @@
+package DataStructures;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class HashMapsExample {
+
+    Map<Character, Integer> map = new HashMap<>();
+
+    public Character findFirstNonRepeating(String input) {
+
+        for (char ch : input.toCharArray()) {
+
+            if (ch == ' ') {
+                continue;
+            } else if (!map.containsKey(ch)) {
+                map.put(ch, 1);
+            } else {
+                map.put(ch, map.get(ch) + 1);
+            }
+
+        }
+
+        for (char ch : input.toCharArray()) {
+
+            if (ch == ' ' || map.get(ch) > 1) {
+                continue;
+            } else {
+                return ch;
+            }
+        }
+
+        return '0';
+    }
+
+    @Override
+    public String toString() {
+        return "HashMaps [map=" + map + "]";
+    }
+
+}

LinkedList.java

@@ -0,0 +1,150 @@
+package DataStructures;
+
+public class LinkedList {
+
+    private class Node {
+
+        private int value;
+        private Node next;
+
+        public Node(int value) {
+            this.value = value;
+        }
+
+    }
+
+    private Node first;
+    private Node last;
+    private int size = 0;
+
+    public void addFirst(int value) {
+        Node currentNode = first;
+        first = new Node(value);
+        first.next = currentNode;
+
+        if (last == null) {
+            last = first;
+        }
+
+        size++;
+    }
+
+    public void addLast(int value) {
+        if (first == null) {
+            last = new Node(value);
+            first = last;
+        } else {
+            last.next = new Node(value);
+
+            last = last.next;
+        }
+
+        size++;
+
+    }
+
+    public int indexOf(int value) {
+        return indexOf(first, value);
+    }
+
+    int index = 0;
+
+    public int indexOf(Node node, int value) {
+        if (node.value == value) {
+            return index;
+        } else if (node.next == null) {
+            return -1;
+        }
+
+        index++;
+        return indexOf(node.next, value);
+    }
+
+    public boolean contains(int value) {
+        if (indexOf(value) > -1) {
+            return true;
+        }
+        return false;
+    }
+
+    public void deleteFirst() {
+        first = first.next;
+    }
+
+    public void deleteLast() {
+        deleteLast(first);
+        size--;
+    }
+
+    public Node deleteLast(Node node) {
+        if (node.next.next == null) {
+            return node;
+        }
+
+        last = deleteLast(node.next);
+        last.next = null;
+        return last;
+    }
+
+    public int size() {
+        return size;
+    }
+
+    public int[] toArray() {
+        int[] array = new int[size];
+        int index = 0;
+        return toArray(first, array, index);
+    }
+
+    public int[] toArray(Node node, int[] array, int index) {
+
+        if (node == null) {
+            return array; // 0 -1, 1 - 2, 2 - 3, 3 - 4
+        }
+
+        array[index++] = node.value;
+        toArray(node.next, array, index);
+
+        return array;
+
+    }
+
+    public void reverse() {
+        // Node previous = first;
+        Node newFirst = reverse(first.next, first);
+        last = first;
+        last.next = null;
+
+        first = newFirst;
+    }
+
+    public Node reverse(Node node, Node previous) {
+
+        if (node == null) {
+            return previous;
+        }
+
+        Node current = node.next;
+        node.next = previous;
+        previous = node;
+        return reverse(current, previous);
+
+    }
+
+    public int getKthFromEnd(int k) {
+        Node slow = first;
+        Node fast = first;
+
+        for (int i = 1; i < k; i++) {
+            fast = fast.next;
+        }
+
+        while (fast != last) {
+            slow = slow.next;
+            fast = fast.next;
+        }
+
+        return slow.value;
+    }
+
+}

Queues/ArrayQueue.java

@@ -0,0 +1,39 @@
+package DataStructures.Queues;
+
+public class ArrayQueue {
+
+    public int[] queue = new int[5];
+
+    int front = 0;
+    int rear = -1;
+
+    public void add(int value) {
+        rear++;
+        if (rear > queue.length - 1) {
+            if (queue[0] == 0) {
+                rear = 0;
+            } else {
+                System.out.println("Queue is full");
+                return;
+            }
+        } else if (rear == front && front != 0) {
+            System.out.println("Queue is full");
+            return;
+        }
+
+        queue[rear] = value;
+
+    }
+
+    public void remove() {
+        if (front > queue.length - 1) {
+            front = 0;
+        }
+        queue[front] = 0;
+        front++;
+    }
+
+    public int peek() {
+        return queue[front];
+    }
+}