problem solving start

Author: rupesh-singh

Algorithms/KadaneAlgorithmMaxSubarray.java

@@ -0,0 +1,20 @@
+/*
+Given an integer array nums, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.
+*/
+class KadaneAlgorithmMaxSubarray {
+public static void main(String args[]){
+
+    System.out.println(maxSubArray(new int[]{-2,1,-3,4,-1,2,1,-5,4}));
+}
+    public static int maxSubArray(int[] nums) {
+        int prev_sum = nums[0], max_global = nums[0];
+        for (int i = 1; i < nums.length; i++ ){
+            prev_sum = (nums[i] > (prev_sum + nums[i]))?nums[i]:(prev_sum + nums[i]);
+            
+           if(prev_sum > max_global)
+                max_global = prev_sum;
+        }
+        
+        return max_global;
+    }
+}

data-structures/BinaryTreeCreator.java

@@ -0,0 +1,142 @@
+import java.util.*;
+
+class Node{
+int value;
+Node left;
+Node right;
+
+Node(int value){
+this.value = value;
+this.left=null;
+this.right=null;
+    }
+
+}
+
+class MinStack {
+
+    List<Integer> list;
+    int item = 0;
+    /** initialize your data structure here. */
+    public MinStack() {
+        list = new ArrayList<Integer>();
+    }
+    
+    public void push(int x) {
+        list.add(x);
+        item++;
+    }
+    
+    public void pop() {
+     list.remove(item);   
+        item--;
+    }
+    
+    public int top() {
+        return list.get(item);
+    }
+    
+    public int getMin() {
+        int min = list.get(0);
+        for(int i =0;i<list.size();i++){
+            if(min>list.get(i))
+                min=list.get(i);
+        }
+        return min;
+    }
+}
+
+class BinaryTree{
+
+Node root;
+
+private Node addrecursively(Node current, int value){
+    if(current == null)
+    return new Node(value);
+
+    else if(value < current.value)
+        current.left = addrecursively(current.left, value);
+    else if(value > current.value)
+        current.right =  addrecursively(current.right, value);
+    else
+    return current;
+    return current;
+
+    }
+
+public void add(int value){
+    root = addrecursively(root, value);
+}
+
+public void traverseDfsInorder(Node node){
+
+    if(node!=null){
+        traverseDfsInorder(node.left);
+        System.out.print(" "+node.value);
+        traverseDfsInorder(node.right);
+    }
+
+}
+
+public void traverseDfsPreorder(Node node){
+
+    if(node!=null){
+        System.out.print(" "+node.value);
+        traverseDfsInorder(node.left);
+        traverseDfsInorder(node.right);
+    }
+
+}
+
+public void traverseDfsPostorder(Node node){
+
+    if(node!=null){
+        traverseDfsInorder(node.left);
+        traverseDfsInorder(node.right);
+        System.out.print(" "+node.value);
+    }
+
+}
+
+public void printTree(){
+    System.out.println("Inorder: ");
+    traverseDfsInorder(root);
+
+    System.out.println("\nPreorder: ");
+    traverseDfsPreorder(root);
+
+    System.out.println("\nPostorder: ");
+    traverseDfsPostorder(root);
+}
+
+}
+
+
+
+public class BinaryTreeCreator {
+   
+    public static void main(String args[]){
+        BinaryTree tree = new BinaryTree();
+        tree.add(11);
+        tree.add(15);
+        tree.add(41);
+        tree.add(8);
+        tree.add(6);
+        tree.add(45);
+        tree.add(75);
+        tree.add(23);
+        tree.add(3);
+        tree.add(9);
+
+        System.out.println("-----Traversing order----");
+        tree.printTree();
+
+        MinStack min = new MinStack();
+        min.push(-1);
+        // min.pop();
+        min.push(2);
+        min.push(6);
+        System.out.println(min.getMin());
+    }
+
+}

data-structures/JavaLearningLinks.txt

@@ -0,0 +1,107 @@
+Data Structures and Algorithms Topics:
+https://www.codechef.com/certification/prepare#foundation
+https://medium.com/basecs
+(I read from the second link)
+
+
+Java Topics : http://javahungry.blogspot.com/2013/08/hashing-how-hash-map-works-in-java-or.html
+
+http://javahungry.blogspot.com/2014/06/how-treemap-works-ten-treemap-java-interview-questions.html
+
+http://javahungry.blogspot.com/2015/02/how-concurrenthashmap-works-in-java-internal-implementation.html
+
+http://javahungry.blogspot.com/2015/10/how-treeset-works-internally-in-java-interview-questions.html
+
+http://javahungry.blogspot.com/p/threads.html
+
+
+http://javarevisited.blogspot.in/2011/04/synchronization-in-java-synchronized.html
+
+http://javarevisited.blogspot.in/2011/06/volatile-keyword-java-example-tutorial.html
+
+http://mrbool.com/working-with-java-executor-framework-in-multithreaded-application/27560
+
+http://stackoverflow.com/questions/10828863/what-the-use-of-custom-class-loader
+
+http://stackoverflow.com/questions/10901752/what-is-the-significance-of-load-factor-in-hashmap
+
+http://stackoverflow.com/questions/11011291/treeset-internally-uses-treemap-so-is-it-required-to-implement-hashcode-method
+
+http://stackoverflow.com/questions/137975/what-is-so-bad-about-singletons
+
+http://stackoverflow.com/questions/13855013/understanding-java-memory-management
+
+http://stackoverflow.com/questions/2087469/sort-a-file-with-huge-volume-of-data-given-memory-constraint
+
+http://stackoverflow.com/questions/27325997/how-does-countdownlatch-works-in-java
+
+http://stackoverflow.com/questions/56860/what-is-the-liskov-substitution-principle
+
+http://stackoverflow.com/questions/8161896/example-code-to-show-how-java-synchronized-block-works
+
+http://tutorials.jenkov.com/java-concurrency/synchronized.html
+
+http://tutorials.jenkov.com/java-util-concurrent/cyclicbarrier.html
+
+http://www.dynatrace.com/en/javabook/how-garbage-collection-works.html
+
+http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/G1GettingStarted/index.html
+
+http://www.programcreek.com/2013/03/hashmap-vs-treemap-vs-hashtable-vs-linkedhashmap/
+
+https://docs.oracle.com/cd/E13150_01/jrockit_jvm/jrockit/geninfo/diagnos/garbage_collect.html
+
+https://en.m.wikipedia.org/wiki/Creational_pattern
+
+https://en.wikipedia.org/wiki/SOLID_(object-oriented_design)
+
+https://lostechies.com/derickbailey/2009/02/11/solid-development-principles-in-motivational-pictures/
+
+https://scotch.io/bar-talk/s-o-l-i-d-the-first-five-principles-of-object-oriented-design
+
+https://www.pluralsight.com/courses/introduction-to-sql 
+
+http://www.programmerinterview.com/index.php/database-sql/sql-having-vs-group-by/
+
+http://www.programmerinterview.com/index.php/database-sql/inner-vs-outer-joins/
+
+https://www.essentialsql.com/what-is-a-query-plan/
+
+http://www.dotnettricks.com/learn/sqlserver/understanding-case-expression-in-sql-server-with-example
+
+
+
+---------------------------------------------------------------------------------------------
+
+
+Self Added Topics:
+
+Garbage Collection :
+https://betsol.com/tag/garbage-collection/
+
+Executor Services :
+http://www.baeldung.com/java-executor-service-tutorial
+
+Atomic Variables:
+http://www.baeldung.com/java-atomic-variables
+
+Thread Pools:
+http://www.baeldung.com/thread-pool-java-and-guava
+
+Fork Join:
+http://www.baeldung.com/java-fork-join
+
+Complete Thread Articles:
+http://tutorials.jenkov.com/java-util-concurrent/index.html
+(Refer codes)
+
+Fair knowledge of Thread and Heap Dump.
+Knowledge of various garbage collection algorithms
+
+
+
+singleton
+    https://javarevisited.blogspot.com/2011/03/10-interview-questions-on-singleton.html
+
+Reflection: How to Call private method 
+    https://javarevisited.blogspot.com/2012/05/how-to-access-private-field-and-method.html