summary

Author: Blooverh

DataAndAlgoL/Chp3LinkedLists/ExchangeAdjacenNodes.java

@@ -0,0 +1,19 @@
+package DataAndAlgoL.Chp3LinkedLists;
+
+//PROBLEM 40 EXCHANGE THE ADJACEN ELEMENTS
+public class ExchangeAdjacenNodes {
+    public ListNode exchangeAdjNode(ListNode head){
+        ListNode temp = new ListNode(0); //temporary node to point to head
+        temp.next = head; //temp points its next node as head
+        ListNode prev = temp, curr = head; // prev is temp node and current is the head 
+        while(curr != null && curr.next != null){ //while current has a head and current.next has a pointer to head's next node
+            ListNode tmp = curr.next.next; //tmp becomes the 2 next nodes to curr 
+            curr.next.next = prev.next; //
+            prev.next = curr.next;
+            curr.next = tmp;
+            prev = curr;
+            curr = prev.next;
+        }
+        return temp.next;
+    }
+}

DataAndAlgoL/Chpt9GraphAlgorithms/DFSGraph.java renamed to DataAndAlgoL/Chpt9GraphAlgorithms/DFSandBFSGraph.java

@@ -1,5 +1,6 @@
 package DataAndAlgoL.Chpt9GraphAlgorithms;
 
+import java.util.Queue;
 import java.util.Stack;
 
 class Vertex{
@@ -10,15 +11,16 @@ public Vertex(char lab){
         visited=false;
     }
 }
-public class DFSGraph {
+public class DFSandBFSGraph {
     final int maxVertices=20; //max number of vertices in the graph
     Vertex[] vertexList; //array of vertices 
     int[][] adjMatrix; //matrix that will hold the vertices 
-    int vertexCount;
-    Stack theStack;
+    static int vertexCount;
+    Stack theStack; //for dfs
+    Queue theQueue;
 
 
-    public DFSGraph(){
+    public DFSandBFSGraph(){
         vertexList= new Vertex[maxVertices]; //new array of vertices of size maxVertices (20)
         adjMatrix= new int[maxVertices][maxVertices];// matrix that will contain the vertices with matrix size 20x20 
         vertexCount=0; 
@@ -67,6 +69,26 @@ public void dfs(){
         }
     }
 
+    public void bfs(){
+        vertexList[0].visited=true; //first vertex assign visited in vertexList 
+        displayVertex(0); //displays the first vertex 
+        theQueue.add(0); //inserts 1st vertex in queue so we can go to next vertex and explore
+        int v2;
+        while(!theQueue.isEmpty()){
+            int v1= (int) theQueue.remove();
+            while((v2=getAdjUnvisitedVertex(v1)) !=1){
+                vertexList[v2].visited=true;
+                displayVertex(v2);
+                theQueue.add(v2);
+            }
+        }
+
+        for(int j=0; j< vertexCount; j++){
+            vertexList[j].visited=false;
+        }
+
+    }
+
     public int getAdjUnvisitedVertex(int v){
         for(int i=0; i< vertexCount; i++){
             if(adjMatrix[v][i]==1 && vertexList[i].visited==false){

DataAndAlgoL/Chpt9GraphAlgorithms/Graph.java

@@ -127,7 +127,7 @@ void clearVisited(){
             visited[i] = false;
     }
 
-    //ALGORITHM IMPORTANT PART
+    //ALGORITHM IMPORTANT PART DFS ALGORITHM 
     public void dfs(){
         //visit nodes using a stack to store "to visit" nodes 
         Stack<Integer> s= new Stack<>();
@@ -151,11 +151,36 @@ public void dfs(){
         }
     }
 
+    //BFS ALGORITHM IMPORTANT 
+    public void bfs(){
+        Queue<Integer> q = new LinkedList<>(); //BFS USES QUEUE DATA SRUCTURE
+        clearVisited();
+        q.add(0);
+
+        //LOOP AS LONG AS THERE IS AN ACTIVE NODE
+        while(!q.isEmpty()){
+            int nextNode =q.remove(); // NEXT NODE TO VISIT
+            if(!visited[nextNode]){
+                visited[nextNode]=true; //MARK NODE/VERTEX AS VISITED
+                System.out.println("nextNode= "+nextNode); //PRINT CURRENT NODE STARTING FROM FIRST NODE/VERTEX
+                for(int i=0; i< V; i++){
+                    if(adjMatrix[nextNode][i] ==true && !visited[i]){ //IF NEXTNODE ON THE SAME ROW BUT NEXT COLUMN IS TRUE AND NOT VISITED ADD THAT NODE TO THE QUEUE TO EXPLORE THE NEXT VERTICES
+                        q.add(i);
+                    }
+                }
+            }
+        }
+    }
+
     public static void main(String[] args) {
-        int V =10;
-        int E =13;
+        int V =5;
+        int E =7;
         Graph G= new Graph(V,E);
         System.out.println(G.toString());
+        System.out.println("DFS ALGORITHM");
         G.dfs();
+        System.out.println();
+        System.out.println("BFS ALGORITHM");
+        G.bfs();
     }
 }

DataAndAlgoL/Chpt9GraphAlgorithms/topologicalSort.java

@@ -0,0 +1,34 @@
+package DataAndAlgoL.Chpt9GraphAlgorithms;
+import java.util.*;
+import DataAndAlgoL.Chpt9GraphAlgorithms.DFSandBFSGraph;
+//sole purpose of avoiding the error, still needs implementation
+class LLQueue{
+
+}
+public class topologicalSort {
+    // public void TopologicalSort(DFSandBFSGraph G){
+    //     LLQueue Q= new LLQueue(); //linked list queue
+    //     int counter=0;
+    //     int v, w;
+
+    //     for(int i =0; i< DFSandBFSGraph.vertexCount; i++){
+    //         if(indegree[v]==0){
+    //             Q.deQueue(v);
+    //         }
+    //     }
+
+    //     while(!Q.isEmpty()){
+    //         v=Q.deQueue();
+    //         topologicalOrder[v]=counter++;
+    //         for each w adjacent to v
+    //             if(--indegree[w]==0){
+    //                 Q.enQueue(w);
+    //             }
+    //     }
+    //     if(counter != G.vertexCount){
+    //         System.out.println("Graph has a cycle");
+    //     }
+
+    //     Q.deleteQueue();
+    // }    
+}