Question

USING JAVA:

Create a class: AdjListGraph.java, and just submit AdjListGraph.java. where

-Step 1(1 credit):

Please implement a graph by adjacency list.

-Step 2(1 credit):

Write a method: void dfs(){\\ TO-DO}; which can traverse a graph by DFS(stack based or recursive)

Answer 1

(i) Implementing Adjacency list graph.

class AdjListNode //create a class for adj list node

{

    int dest;

    AdjListNode next;

    public AdjListNode(int dest)

{

        this.dest = dest;

        this.next = null;

    }

}

class AdjListGraph

{

    AdjListNode head;

}

public class graph

{

    int V;

    AdjListNode newNode;

    AdjList array[];

    public graph(int V)

{

    this.V = V;

    this.array = new AdjList[V];

    int i;

    for(i=0;i<V;++i)

{

        this.array[i] = new AdjList();

    }

}

   

void addEdge(graph g, int src, int dest)

{

        newNode = new AdjListNode(dest);

        newNode.next = g.array[src].head;

        g.array[src].head = newNode;

        newNode = new AdjListNode(src);

        newNode.next = g.array[dest].head;

        g.array[dest].head = newNode;

    }

    void printGraph(graph g)

{

        int v;

        for(v=0;v < g.V;++v)

{

            AdjListNode pCrawl = g.array[v].head;

            System.out.println();

            System.out.println("Adjacency list of vertex "+v);

            System.out.print("head");

            while(pCrawl != null)

{

                System.out.print(pCrawl.dest);

                pCrawl = pCrawl.next;

            }

            System.out.println();

        }

    }

    public static void main(String[] args)

{

        int V = 5;

       graph g = new graph(V);

        g.addEdge(g,0,1);

        g.addEdge(g,0,4);

        g.addEdge(g,1,2);

        g.addEdge(g,1,3);

        g.addEdge(g,1,4);

        g.addEdge(g,2,3);

        g.addEdge(g,3,4);

        g.printGraph(g);

    }

}

(ii) DFS traversal of a graph (stack based)

class StackX

{

            private final int SIZE = 20;

            private int[] st;

            private int top;

            // constructor

            public StackX()

            {

                        st = new int[SIZE];     //make array

                        top = -1;

            }

            //push item into stack

            public void push(int j)

            { st[++top] = j; }

            //pop item from stack

            public int pop()

            { return st[top--]; }

            //peek at top of stack

            public int peek()

            { return st[top]; }

            //true if nothing on stack

            public boolean isEmpty()

            {

return top == -1; }

} // end class StackX

//

class DFSLink

{

            public int vertex;

            public DFSLink next;            

}

class DFSList

{

            public DFSLink head;

            public DFSList()

            {

                        head = new DFSLink();

                        //head is given a dummy value so searches

                        //don't necessarily include vertex A (0)

                        head.vertex = -1;

            }

           

            public void insert(int v)

            {

                        DFSLink cur = head;

                        while(cur.next != null)

                                    cur = cur.next;

                        cur.next = new DFSLink();

                        cur.next.vertex = v;

            }

           

            public DFSLink deleteFromEnd()

            {

                        if(head == null) return null;

                        DFSLink cur = head;

                        while(cur.next.next != null)

                                    cur = cur.next;

                        DFSLink temp = cur.next;

                        cur.next = null;

                        return temp;

            }

           

            public boolean contains(int j)

            {

                        DFSLink cur = head;

                        while(cur != null)

                        {

                                    if(cur.vertex == j) return true;

                                    cur = cur.next;

                        }

                        return false;

            }

}

class DFSGraph

{

            private final int MAX_VERTS = 20;

            private Vertex[] vertexList;   //list of vertices

            private DFSList[] adjMat;      //adjacency matrix

            private int nVerts;                   //current number of vertices

            private StackX theStack;

            //Constructor

            public DFSGraph()

            {

                        vertexList = new Vertex[MAX_VERTS];     //adjacency matrix

                        adjMat = new DFSList[MAX_VERTS];

                        nVerts = 0;

                         // set adjacency matrix to zero

                        for(int j = 0; j < MAX_VERTS; j++)

                                    adjMat[j] = new DFSList();

                        theStack = new StackX();

            }

            public void addVertex(char lab)

            {

                        vertexList[nVerts++] = new Vertex(lab);

            }

           

            //creates an edge from one vertex to another.

            //DIRECTED GRAPH, not undirected

            public void addEdge(int start, int end)

            {

                        adjMat[start].insert(end);

            }

           

            public void displayVertex(int j)

            {

                        System.out.print(vertexList[j].label);

            }

           

            //depth first search

            public void dfs(int start)

            {

                        vertexList[start].wasVisited = true; //begin

                        displayVertex(start);               //display it

                        theStack.push(start);               //push it

                       

                        while(!theStack.isEmpty())    //until stack is empty

                        {

                                // get an unvisited vertex adjacent to stack top

                                    int v = getAdjUnvisitedVertex(theStack.peek());

                                    if(v == -1)                   //if no such vertex

                                                theStack.pop();

                                    else                  //if it exists

                                    {

                                                vertexList[v].wasVisited = true;

                                                displayVertex(v);        //display it

                                                theStack.push(v);        //push it

                                    }

                        }

                        System.out.println();

                        for(int j = 0; j < nVerts; j++)

                                    vertexList[j].wasVisited = false;

            }

            //unvisited vertex

            public int getAdjUnvisitedVertex(int v)

            {

                        for(int j = 0; j < nVerts; j++)

                                    if(adjMat[v].contains(j) && vertexList[j].wasVisited == false)

                                                return j;

                        return -1;

            }

} // end class DFSGraph

class DFSApp

{

            public static void main(String[] args)

            {

                        DFSGraph theGraph = new DFSGraph();

                        theGraph.addVertex('A');

                        theGraph.addVertex('B');

                        theGraph.addVertex('C');

                        theGraph.addVertex('D');

                        theGraph.addVertex('E');

                       

                        theGraph.addEdge(0, 1);

                        theGraph.addEdge(2, 1);

                        theGraph.addEdge(2, 3);

                        theGraph.addEdge(3, 1);

                        theGraph.addEdge(4, 2);

                       

                        System.out.println("visits:");

                        theGraph.dfs ();

                        System.out.println();

            } //end main()

}