/** Adjacency Matrix Class with time complexity = Ω(V2) **/
public class AdjacencyMatrix
{
private final int MAX_NO_OF_VERTICES;
private int adjacency_matrix[][];
public AdjacencyMatrix(int number_of_vertices)
{
MAX_NO_OF_VERTICES = number_of_vertices;
adjacency_matrix = new int[MAX_NO_OF_VERTICES + 1][MAX_NO_OF_VERTICES + 1];
}
public void setEdge(int from_vertex, int to_vertex, int edge)
{
try
{
adjacency_matrix[from_vertex][to_vertex] = edge;
} catch (ArrayIndexOutOfBoundsException indexBounce)
{
System.out.println("the vertex entered is not present");
}
}
public int getEdge(int from_vertex, int to_vertex)
{
try
{
return adjacency_matrix[from_vertex][to_vertex];
} catch (ArrayIndexOutOfBoundsException indexBounce)
{
System.out.println("the vertex entered is not present")
}
return -1;
}
public static void main(String... arg)
{
int number_of_vertices, count = 1;
int source = 0, destination = 0;
Scanner scan = new Scanner(System.in);
AdjacencyMatrix adjacencyMatrix;
try
{
System.out.println("Enter the Number of Vertices");
number_of_vertices = scan.nextInt();
System.out.println("Enter the Number of Edges");
int number_of_edges = scan.nextInt();
adjacencyMatrix = new AdjacencyMatrix(number_of_vertices);
System.out.println("Enter The Graph Egdes :<source> <destination>");
while (count <= number_of_edges)
{
source = scan.nextInt();
destination = scan.nextInt();
adjacencyMatrix.setEdge(source, destination, 1);
count++;
}
System.out.println("The adjacency matrix for given graph is");
for (int i = 1; i <= number_of_vertices; i++)
System.out.print(i);
System.out.println();
for (int i = 1; i <= number_of_vertices; i++)
{
System.out.print(i);
for (int j = 1; j <= number_of_vertices; j++)
{
System.out.print(adjacencyMatrix.getEdge(i, j));
}
System.out.println();
}
} catch (InputMismatchException inputMisMatch)
{
System.out.println("Error in Input Format.<source index> <destination index>");
}
scan.close();
}
}
/** Adjacency list Class with time complexity = O(V+E) **/
import java.util.HashMap;
import java.util.InputMismatchException;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
public class AdjacencyList
{
private Map<Integer,List<Integer>> Adjacency_List;
public AdjacencyList(int number_of_vertices)
{
Adjacency_List = new HashMap<Integer, List<Integer>>();
for (int i = 1; i <= number_of_vertices; i++)
{
Adjacency_List.put(i, new LinkedList<Integer>());
}
}
public void setEdge(int source, int destination)
{
if (source > Adjacency_List.size() || destination > Adjacency_List.size())
{
System.out.println("the vertex entered in not present ");
return;
}
List<Integer> slist = Adjacency_List.get(source);
slist.add(destination);
List<Integer> dlist = Adjacency_List.get(destination);
dlist.add(source);
}
public List<Integer> getEdge(int source)
{
if (source > Adjacency_List.size())
{
System.out.println("the vertex entered is not present");
return null;
}
return Adjacency_List.get(source);
}
public static void main(String...arg)
{
int source, destination;
int number_of_edges, number_of_vertices;
int count = 1;
Scanner scan = new Scanner(System.in);
try
{
System.out.println("Enter the number of vertices and edges in graph");
number_of_vertices = scan.nextInt();
number_of_edges = scan.nextInt();
AdjacencyList adjacencyList = new AdjacencyList(number_of_vertices);
System.out.println("Enter the edges in graph Format : <source index> <destination
index>");
while (count <= number_of_edges)
{
source = scan.nextInt();
destination = scan.nextInt();
adjacencyList.setEdge(source, destination);
count++;
}
System.out.println("the given Adjacency List for the graph \n");
for (int i = 1; i <= number_of_vertices; i++)
{
System.out.print(i+"->");
List<Integer> edgeList = adjacencyList.getEdge(i);
for (int j = 1; ; j++ )
{
if (j != edgeList.size())
System.out.print(edgeList.get(j - 1 ) + "->");
else
{
System.out.print(edgeList.get(j - 1 ));
break;
}
}
System.out.println();
}
}catch (InputMismatchException inputMismatch)
{
System.out.println("Error in Input Format. \nFormat : <source index> <destination
index>");
}
scan.close();
}
}
public class SearchTeq
{
private Stack<Integer> stack; //DFS + find a Cycle
private Queue<Integer> queue; //BFS
// Prim's privates
private boolean unsettled[];
private boolean settled[];
private int numberofvertices;
private int adjacencyMatrix[][];
private int key[];
public static final int INFINITE = 999;
private int parent[];
//Krusal's privates
private List<Edge> edges;
private int numberOfVertices;
public static final int MAX_VALUE = 999;
private int visited[];
private int spanning_tree[][];
//find a cycle privates
private int adjacencyMatrix[][];
/** BFS with comlexity = O(V+E) **/
public BFS()
{
queue = new LinkedList<Integer>();
}
public void bfs(int adjacency_matrix[][], int source)
{
int number_of_nodes = adjacency_matrix[source].length - 1;
int[] visited = new int[number_of_nodes + 1];
int i, element;
visited[source] = 1;
queue.add(source);
while (!queue.isEmpty())
{
element = queue.remove();
i = element;
System.out.print(i + "\t");
while (i <= number_of_nodes)
{
if (adjacency_matrix[element][i] == 1 && visited[i] == 0)
{
queue.add(i);
visited[i] = 1;
}
i++;
}
}
}
/** DFS with comlexity = O(V+E) **/
public DFS()
{
stack = new Stack<Integer>();
}
public void dfs(int adjacency_matrix[][], int source)
{
int number_of_nodes = adjacency_matrix[source].length - 1;
int visited[] = new int[number_of_nodes + 1];
int element = source;
int i = source;
System.out.print(element + "\t");
visited[source] = 1;
stack.push(source);
while (!stack.isEmpty())
{
element = stack.peek();
i = element;
while (i <= number_of_nodes)
{
if (adjacency_matrix[element][i] == 1 && visited[i] == 0)
{
stack.push(i);
visited[i] = 1;
element = i;
i = 1;
System.out.print(element + "\t");
continue;
}
i++;
}
stack.pop();
}
/** MST method using Prim-Jarnik's algorithm with time complexity = O(V2) **/
public Prims(int numberofvertices)
{
this.numberofvertices = numberofvertices;
unsettled = new boolean[numberofvertices + 1];
settled = new boolean[numberofvertices + 1];
adjacencyMatrix = new int[numberofvertices + 1][numberofvertices + 1];
key = new int[numberofvertices + 1];
parent = new int[numberofvertices + 1];
}
public int getUnsettledCount(boolean unsettled[])
{
int count = 0;
for (int index = 0; index < unsettled.length; index++)
{
if (unsettled[index])
{
count++;
}
}
return count;
}
public void primsAlgorithm(int adjacencyMatrix[][])
{
int evaluationVertex;
for (int source = 1; source <= numberofvertices; source++)
{
for (int destination = 1; destination <= numberofvertices; destination++)
{
this.adjacencyMatrix[source][destination] = adjacencyMatrix[source][destination];
}
}
for (int index = 1; index <= numberofvertices; index++)
{
key[index] = INFINITE;
}
key[1] = 0;
unsettled[1] = true;
parent[1] = 1;
while (getUnsettledCount(unsettled) != 0)
{
evaluationVertex = getMimumKeyVertexFromUnsettled(unsettled);
unsettled[evaluationVertex] = false;
settled[evaluationVertex] = true;
evaluateNeighbours(evaluationVertex);
}
}
private int getMimumKeyVertexFromUnsettled(boolean[] unsettled2)
{
int min = Integer.MAX_VALUE;
int node = 0;
for (int vertex = 1; vertex <= numberofvertices; vertex++)
{
if (unsettled[vertex] == true && key[vertex] < min)
{
node = vertex;
min = key[vertex];
}
}
return node;
}
public void evaluateNeighbours(int evaluationVertex)
{
for (int destinationvertex = 1; destinationvertex <= numberofvertices; destinationvertex++)
{
if (settled[destinationvertex] == false)
{
if (adjacencyMatrix[evaluationVertex][destinationvertex] != INFINITE)
{
if (adjacencyMatrix[evaluationVertex][destinationvertex] < key[destinationvertex])
{
key[destinationvertex] = adjacencyMatrix[evaluationVertex][destinationvertex];
parent[destinationvertex] = evaluationVertex;
}
unsettled[destinationvertex] = true;
}
}
}
/** MST method using Kruskal's algorithm with time complexity = O(E log V) **/
public KruskalAlgorithm(int numberOfVertices)
{
this.numberOfVertices = numberOfVertices;
edges = new LinkedList<Edge>();
visited = new int[this.numberOfVertices + 1];
spanning_tree = new int[numberOfVertices + 1][numberOfVertices + 1];
}
public void kruskalAlgorithm(int adjacencyMatrix[][])
{
boolean finished = false;
for (int source = 1; source <= numberOfVertices; source++)
{
for (int destination = 1; destination <= numberOfVertices; destination++)
{
if (adjacencyMatrix[source][destination] != MAX_VALUE && source != destination)
{
Edge edge = new Edge();
edge.sourcevertex = source;
edge.destinationvertex = destination;
edge.weight = adjacencyMatrix[source][destination];
adjacencyMatrix[destination][source] = MAX_VALUE;
edges.add(edge);
}
}
}
Collections.sort(edges, new EdgeComparator());
CheckCycle checkCycle = new CheckCycle();
for (Edge edge : edges)
{
spanning_tree[edge.sourcevertex][edge.destinationvertex] = edge.weight;
spanning_tree[edge.destinationvertex][edge.sourcevertex] = edge.weight;
if (checkCycle.checkCycle(spanning_tree, edge.sourcevertex))
{
spanning_tree[edge.sourcevertex][edge.destinationvertex] = 0;
spanning_tree[edge.destinationvertex][edge.sourcevertex] = 0;
edge.weight = -1;
continue;
}
visited[edge.sourcevertex] = 1;
visited[edge.destinationvertex] = 1;
for (int i = 0; i < visited.length; i++)
{
if (visited[i] == 0)
{
finished = false;
break;
} else
{
finished = true;
}
}
if (finished)
break;
}
System.out.println("The spanning tree is ");
for (int i = 1; i <= numberOfVertices; i++)
System.out.print("\t" + i);
System.out.println();
for (int source = 1; source <= numberOfVertices; source++)
{
System.out.print(source + "\t");
for (int destination = 1; destination <= numberOfVertices; destination++)
{
System.out.print(spanning_tree[source][destination] + "\t");
}
System.out.println();
}
}
/** Finding a cycle in a given graph using DFS method with complexity = O(V+E)**/
public CheckCycle()
{
stack = new Stack<Integer>();
}
public void cyc_dfs(int adjacency_matrix[][], int source)
{
int number_of_nodes = adjacency_matrix[source].length - 1;
adjacencyMatrix = new int[number_of_nodes + 1][number_of_nodes + 1];
for (int sourcevertex = 1; sourcevertex <= number_of_nodes; sourcevertex++)
{
for (int destinationvertex = 1; destinationvertex <= number_of_nodes;
destinationvertex++)
{
adjacencyMatrix[sourcevertex][destinationvertex] =
adjacency_matrix[sourcevertex][destinationvertex];
}
}
int visited[] = new int[number_of_nodes + 1];
int element = source;
int destination = source;
visited[source] = 1;
stack.push(source);
while (!stack.isEmpty())
{
element = stack.peek();
destination = element;
while (destination <= number_of_nodes)
{
if (adjacencyMatrix[element][destination] == 1 && visited[destination] == 1)
{
if (stack.contains(destination))
{
System.out.println("The Graph contains cycle");
return;
}
}
if (adjacencyMatrix[element][destination] == 1 && visited[destination] == 0)
{
stack.push(destination);
visited[destination] = 1;
adjacencyMatrix[element][destination] = 0;
element = destination;
destination = 1;
continue;
}
destination++;
}
stack.pop();
}
}
/** Finding the path between given nodes "list teq" with complexity = O(V2) **/
public static void node_path()
{
int label; // this node's label (parent node in path tree)
int weight; // weight of edge to this node (distance to start)
Node(int v, int w)
{
label = v;
weight = w;
}
boolean[] done = new boolean[n];
Node[] table = new Node[n];
for (int i = 0; i < n; i++)
table[i] = new Node(-1, Integer.MAX_VALUE);
table[start].weight = 0;
for (int count = 0; count < n; count++)
{
int min = Integer.MAX_VALUE;
int minNode = -1;
for (int i = 0; i < n; i++)
if (!done[i] && table[i].weight < min)
{
min = table[i].weight;
minNode = i;
}
done[minNode] = true;
ListIterator iter = graph[minNode].listIterator();
while (iter.hasNext())
{
Node nd = (Node) iter.next();
int v = nd.label;
int w = nd.weight;
if (!done[v] && table[minNode].weight + w < table[v].weight)
{
table[v].weight = table[minNode].weight + w;
table[v].label = minNode;
}
}
}
for (int i = 0; i < n; i++)
{
if (table[i].weight < Integer.MAX_VALUE)
{
System.out.print("Wire from " + i + " to " + start
+ " with length " + table[i].weight + ": ");
int next = table[i].label;
while (next >= 0)
{
System.out.print(next + " ");
next = table[next].label;
}
System.out.println();
} else
System.out.println("No wire from " + i + " to " + start);
}
}
}//searchTeq