fibinocci

radha krishna valmiki · radha krishna valmiki · commit 757240c84cae · 2018-04-20T07:32:42.000-05:00
diff --git a/src/main/java/com/g/ds/datastructure/graph/BreadthFirstSearch.java b/src/main/java/com/g/ds/datastructure/graph/BreadthFirstSearch.java
@@ -0,0 +1,103 @@
+package com.g.ds.datastructure.graph;
+
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Stack;
+
+public class BreadthFirstSearch {
+    static class Node
+    {
+        int value;
+        Node next;
+        public Node(int value,Node next)
+        {
+            this.value=value;
+            this.next=next;
+        }
+
+    }
+    static class AdjList{
+        Node head;
+        public AdjList()
+        {
+
+        }
+    }
+    //same as DFSGraph in DepthFirstSearch
+    static class BFSGraph{
+        AdjList[] adjList;
+        int size;
+        public  BFSGraph(int size)
+        {
+            this.size=size;
+            adjList = new AdjList[this.size];
+            for(int i=0;i<this.size;i++)
+            {
+                adjList[i]=new AdjList();
+                adjList[i].head=null;
+            }
+        }
+        public void addNode(int src,int destination)
+        {
+            Node node = new Node(destination,null);
+            node.next = adjList[src].head;
+            adjList[src].head =node;
+        }
+        /*
+        do the depth first traverse
+        maintain the visited node
+         */
+        public void explore(int startIndex)
+        {
+          Boolean[] visited = new Boolean[this.size];
+          for(int i=0;i<this.size;i++)
+          {
+              visited[i]=false;
+          }
+            Queue<Integer> track = new LinkedList<>();
+          track.add(startIndex);
+          visited[startIndex]=true;
+          while(!track.isEmpty())
+          {
+              int element = track.poll();
+              visited[element]=true;
+              System.out.println("Visited the Node:"+element);
+              Node head = adjList[element].head;
+
+              while(head!=null)
+              {
+                  if(visited[head.value]==false)
+                  {
+
+                      track.add(head.value);
+                      visited[head.value]=true;
+
+                  }
+                  else
+                  {
+                      head =head.next;
+                  }
+              }
+
+          }
+
+        }
+    }
+    public static void main(String[] args)
+    {
+        BFSGraph bfsGraph = new BFSGraph(6);
+        bfsGraph.addNode(0,2);
+        bfsGraph.addNode(0,1);
+        bfsGraph.addNode(1,4);
+        bfsGraph.addNode(1,3);
+
+        bfsGraph.addNode(1,0);
+        bfsGraph.addNode(3,1);
+        bfsGraph.addNode(4,1);
+        bfsGraph.addNode(2,5);
+
+        bfsGraph.addNode(2,0);
+        bfsGraph.addNode(5,2);
+        bfsGraph.explore(0);
+    }
+}
diff --git a/src/main/java/com/g/ds/datastructure/graph/DepthFirstSearch.java b/src/main/java/com/g/ds/datastructure/graph/DepthFirstSearch.java
@@ -5,6 +5,9 @@
 
 /*
 1.Graph is stored using adjeceny list
+2.Visit the first node and the nodes linked to it
+if you hit the node linked to it then go the Node and traverse the list attached to Node
+and proceed subsequently.
  */
 public class DepthFirstSearch {
 
@@ -47,6 +50,7 @@ public void addNode(int src,int destination)
         }
         /*
         do the depth first traverse
+        maintain the visited node
          */
         public void explore(int startIndex)
         {
diff --git a/src/main/java/com/g/ds/sorting/MergeSort.java b/src/main/java/com/g/ds/sorting/MergeSort.java
@@ -22,6 +22,8 @@ public void sort(int[] array)
 
         if(array==null|| array.length==0)
         {
+
+
             return;
         }
         mergeSort(0,array.length-1);
diff --git a/src/main/java/com/g/ds/trivial/FibinocciNumbers.java b/src/main/java/com/g/ds/trivial/FibinocciNumbers.java
@@ -0,0 +1,71 @@
+package com.g.ds.trivial;
+
+public class FibinocciNumbers {
+
+    //Classic recursion Example
+    /*
+    Time Complexity: T(n) = T(n-1) + T(n-2) which is exponential.
+    We can observe that this implementation does a lot of repeated work
+    (see the following recursion tree). So this is a bad implementation for nth Fibonacci number.
+          fib(5)
+                     /
+               fib(4)                fib(3)
+             /                      /
+         fib(3)      fib(2)         fib(2)    fib(1)
+        /             /           /
+  fib(2)   fib(1)  fib(1) fib(0) fib(1) fib(0)
+  /
+fib(1) fib(0)
+     */
+    static class FibinocciRecursion
+    {
+        public int fibinocci(int n)
+        {
+            if(n<=1)
+            {
+                return n;
+            }
+
+            return fibinocci(n-1)+fibinocci(n-2);
+        }
+
+    }
+
+
+    //Fibiocci dynamic Programming
+    /*
+    We can avoid the repeated work done is the method 1 by storing the Fibonacci numbers calculated so far.
+    but we are allocating memory for every element that we are calculating
+     */
+    static class FibinocciDynamicProgramming {
+
+        public int fibinocci(int n)
+        {
+            int[] fib = new int[n+2];
+
+            fib[0]=0;
+            fib[1]=1;
+            for(int i=2;i<=n;i++)
+            {
+                fib[i]=fib[i-1]+fib[i-2];
+            }
+
+            for(int i=0;i<fib.length;i++)
+            {
+                System.out.println(i+" :  "+fib[i]);
+            }
+           return fib[n];
+        }
+
+    }
+
+    public static void main(String[] args)
+    {
+        FibinocciRecursion fr = new FibinocciRecursion();
+        System.out.println("Recursion:"+ fr.fibinocci(9));
+
+        FibinocciDynamicProgramming fd = new FibinocciDynamicProgramming();
+        System.out.println("Dynamic Programming:"+ fd.fibinocci(4));
+
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,8 @@ public void sort(int[] array)`
`22`	`22`
`23`	`23`	`if(array==null\|\| array.length==0)`
`24`	`24`	`{`
	`25`	`+`
	`26`	`+`
`25`	`27`	`return;`
`26`	`28`	`}`
`27`	`29`	`mergeSort(0,array.length-1);`