added Programs to all categories

Author: abhiabhi

src/main/java/com/arrays/SearchInRotatedSortedArray_BitonicArray.java

@@ -0,0 +1,44 @@
+package com.arrays;
+
+/**
+ * An array is called Bitonic if it is comprises of an increasing sequence of integers followed immediately
+ * by a decreasing sequence of integers.
+ * Given a bitonic array A of N distinct integers. Find a element X in it.
+ */
+public class SearchInRotatedSortedArray_BitonicArray {
+
+    public static int search(int[] nums, int target) {
+        int left = 0;
+        int right = nums.length - 1;
+
+        while (left <= right) {
+
+            int mid = left + (right - left) / 2;
+            if (target == nums[mid])
+                return mid;
+
+            if (nums[left] <= nums[mid]) {
+                if (nums[left] <= target && target < nums[mid]) {
+                    right = mid - 1;
+                } else {
+                    left = mid + 1;
+                }
+            }
+
+            if (nums[mid] <= nums[right]) {
+                if (nums[mid] < target && target <= nums[right]) {
+                    left = mid + 1;
+                } else {
+                    right = mid - 1;
+                }
+            }
+        }
+
+        return -1;
+    }
+
+    public static void main(String args[]) {
+        int[] arr = {4, 5, 6, 7, 0, 1, 2};
+        System.out.println("Element found at index : " + search(arr, 6));
+    }
+}

src/main/java/com/graph/DijkstraShortestPath.java

@@ -0,0 +1,36 @@
+//package com.graph;
+//
+//public class DijkstraShortestPath {
+//
+//
+//    public static void main(String args[]){
+//        Graph<Integer> graph = new Graph<>(false);
+//        /*graph.addEdge(0, 1, 4);
+//        graph.addEdge(1, 2, 8);
+//        graph.addEdge(2, 3, 7);
+//        graph.addEdge(3, 4, 9);
+//        graph.addEdge(4, 5, 10);
+//        graph.addEdge(2, 5, 4);
+//        graph.addEdge(1, 7, 11);
+//        graph.addEdge(0, 7, 8);
+//        graph.addEdge(2, 8, 2);
+//        graph.addEdge(3, 5, 14);
+//        graph.addEdge(5, 6, 2);
+//        graph.addEdge(6, 8, 6);
+//        graph.addEdge(6, 7, 1);
+//        graph.addEdge(7, 8, 7);*/
+//
+//        graph.addEdge(1, 2, 5);
+//        graph.addEdge(2, 3, 2);
+//        graph.addEdge(1, 4, 9);
+//        graph.addEdge(1, 5, 3);
+//        graph.addEdge(5, 6, 2);
+//        graph.addEdge(6, 4, 2);
+//        graph.addEdge(3, 4, 3);
+//
+//        DijkstraShortestPath dsp = new DijkstraShortestPath();
+//        Vertex<Integer> sourceVertex = graph.getVertex(1);
+//        Map<Vertex<Integer>,Integer> distance = dsp.shortestPath(graph, sourceVertex);
+//        System.out.print(distance);
+//    }
+//}

src/main/java/com/heaps/FindMedianFromDataStream.java

@@ -0,0 +1,59 @@
+package com.heaps;
+
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.PriorityQueue;
+
+/**
+ * Median is the middle value in an ordered integer list.
+ * If the size of the list is even, there is no middle value. So the median is the mean of the two middle value.
+ * <p>
+ * First of all, it seems that the best time complexity we can get for this problem is O(log(n)) of add() and O(1) of getMedian().
+ * This data structure seems highly likely to be a tree.
+ * O(log(n)) of add() and O(1) of getMedian()
+ */
+class FindMedianFromDataStream {
+
+    PriorityQueue<Integer> minHeap = null;
+    PriorityQueue<Integer> maxHeap = null;
+
+    /**
+     * initialize your data structure here.
+     */
+    public FindMedianFromDataStream() {
+        minHeap = new PriorityQueue<>();
+        maxHeap = new PriorityQueue<>(Comparator.reverseOrder());
+    }
+
+    public void addNum(int num) {
+        minHeap.offer(num); /** Step 1- Each element is first added to minHeap First */
+        maxHeap.offer(minHeap.poll()); /** Step 2- Minimum element is poped put and offered to MaxHeap .
+                                           This assures all the elements in minHeap are greater than maxHeap */
+
+        if (minHeap.size() < maxHeap.size()) {  /** Step 3- The two heaps need to be laod balanced */
+            minHeap.offer(maxHeap.poll());
+        }
+    }
+
+    public double findMedian() {
+        if (minHeap.size() > maxHeap.size()) {  /** Odd num of total elements */
+            return minHeap.peek();
+        } else {
+            return (minHeap.peek() + maxHeap.peek()) / 2.0; /** Even  num of total elements */
+        }
+    }
+
+    public static void main(String[] args) {
+        FindMedianFromDataStream stream = new FindMedianFromDataStream();
+
+        stream.addNum(2);
+        stream.addNum(5);
+        stream.addNum(8);
+        stream.addNum(18);
+        stream.addNum(20);
+        stream.addNum(28);
+
+        System.out.println("Median " + stream.findMedian());
+    }
+}
+

src/main/java/com/heaps/FindMedianFromDataStream.jpg

@@ -0,0 +1,45 @@
+package com.linkedlist;
+
+import com.linkedlist.model.Node;
+
+/**
+ * For Reversing a linked list we update
+ * the pointer of each node to point to previous node instead of next node
+ */
+public class ReverseLinkedList {
+
+    public static void main(String args[]) {
+        Node targetList = new Node(4);
+        targetList.setNext(new Node(8));
+        targetList.getNext().setNext(new Node(10));
+        targetList.getNext().getNext().setNext(new Node(12));
+
+        Node headOfReverseList = reverseLinkedList(targetList);
+
+        while (headOfReverseList != null) {
+            System.out.println(headOfReverseList.getData());
+            headOfReverseList = headOfReverseList.getNext();
+        }
+
+    }
+
+    private static Node reverseLinkedList(Node head) {
+        /** Initialize 3 pointers */
+        Node previous = null;
+        Node current = head;
+        Node next = null;
+
+        while (current != null) {
+
+            next = current.getNext(); /**save next */
+            current.setNext(previous); /** reverse */
+
+            /** Advance prev and current */
+            previous = current;
+            current = next;
+        }
+
+        return previous; /** return ne head at the end */
+
+    }
+}

src/main/java/com/linkedlist/ReverseLinkedList.java

@@ -0,0 +1,45 @@
+package com.stack;
+
+import java.util.HashMap;
+import java.util.Stack;
+
+/**
+ * Given a string containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.
+ * <p>
+ * The brackets must close in the correct order, "()" and "()[]{}" are all valid but "(]" and "([)]" are not.
+ * <p>
+ * Analysis
+ * <p>
+ * A typical problem which can be solved by using a stack data structure.
+ */
+public class ParenthesisChecker {
+
+    public static boolean isValid(String s) {
+        HashMap<Character, Character> map = new HashMap<>();
+        map.put('(', ')');
+        map.put('[', ']');
+        map.put('{', '}');
+
+        Stack<Character> stack = new Stack<>();
+
+        for (int i = 0; i < s.length(); i++) {
+            char curr = s.charAt(i);
+
+            if (map.keySet().contains(curr)) {
+                stack.push(curr);
+            } else if (map.values().contains(curr)) {
+                if (!stack.empty() && map.get(stack.peek()) == curr) {
+                    stack.pop();
+                } else {
+                    return false;
+                }
+            }
+        }
+        return stack.empty();
+    }
+
+    public static void main (String args[]){
+       String input = "[()]{}{[()()]()}";
+        System.out.println("isValid : "+isValid(input));
+    }
+}

src/main/java/com/stack/ParenthesisChecker.java

@@ -0,0 +1,44 @@
+package com.string;
+
+
+/**
+ * https://www.youtube.com/watch?v=b6AGUjqIPsA
+ *
+ */
+public class EditDistanceBetween2Strings_DynamicProgramming {
+
+    public static void main (String args[]){
+        String from = "YELLOW";
+        String to = "HELLO";
+        System.out.println("MinEditDistance:" +editDist(from,to,from.length(),to.length()));
+    }
+
+    static int editDist(String from, String to, int m, int n)
+    {
+        // If first string is empty, the only option is to
+        // insert all characters of second string into first
+        if (m == 0)
+            return n;
+
+        // If second string is empty, the only option is to
+        // remove all characters of first string
+        if (n == 0)
+            return m;
+
+        // If last characters of two strings are same, nothing
+        // much to do. Ignore last characters and get count for
+        // remaining strings.
+        if (from.charAt(m - 1) == to.charAt(n - 1))
+            return editDist(from, to, m - 1, n - 1); /** diagonal - blind copy*/
+
+        // If last characters are not same, consider all three
+        // operations on last character of first string, recursively
+        // compute minimum cost for all three operations and take
+        // minimum of three values.
+
+        return 1 + Integer.min(Integer.min(editDist(from, to, m, n - 1), // Insert --just left
+                editDist(from, to, m - 1, n)),// Remove  --just above
+                editDist(from, to, m - 1, n - 1)); // Replace --just diagonal
+
+    }
+}

src/main/java/com/string/EditDistanceBetween2Strings_DynamicProgramming.JPG

@@ -0,0 +1,41 @@
+package com.string;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * Given a string S consisting of lowercase Latin Letters. Find the first non repeating character in S.
+ */
+public class FindFirstNonRepeatingCharacter {
+
+    public static void main(String args[]) {
+        String input = "ABCDHJACDHJ";
+        int c = findFirstNonRepeatingChar(input);
+        if (c == -1) {
+            System.out.println("findFirstNonRepeatingChar : " + "Not Found");
+        } else {
+            System.out.println("findFirstNonRepeatingChar : " + (char) c);
+        }
+    }
+
+    private static int findFirstNonRepeatingChar(String input) {
+        /**insertion order will preserved as we are using linkedHashMap */
+        Map<Character, Integer> map = new LinkedHashMap<>();
+
+        /** store frequency of each character in map*/
+        for (char c : input.toCharArray()) {
+            if (map.containsKey(c)) {
+                map.put(c, map.get(c) + 1);
+            } else {
+                map.put(c, 1);
+            }
+        }
+
+        for (char c : map.keySet()) {
+            if (map.get(c) == 1) {
+                return c;
+            }
+        }
+        return -1;
+    }
+}