Ads Lab Record

CP7111 Advanced Data Structures Lab Record
Implementation of Graph Search Algorithm

Ex.No:1
Breadth First Search and Depth First Search
Aim:
To write a java program for the implementation of graph search algorithm using the concept
Breadth First Search and Depth First Search.
Algorithm:
Step1: Start the program.
Step2: Enter the number of vertices and edges.
Step3: Give the edge information.
Step4: Push the root node in the Stack or Queue.
Step5: Loop until the Stack or queue is empty.
Step6: Remove the node from the stack or Queue.
Step7: Then find the path from source to destination.
Step8: Stop the program.
Source Code:
import java.io.*;
class Node
{
int data;
Node link;
}
class QueueBFS
{
Node front,rear;
QueueBFS()
{
front=rear=null;
}
void insert(int x)
{
Node newrec=new Node();
newrec.data=x;
newrec.link=null;
if(front==null)
{
front=newrec;
}
else
P a g e 1 | 54

{
rear.link=newrec;
}
rear=newrec;
}
int delete()
{
if(front!=null)
{
int temp;
temp=front.data;
front=front.link;
return temp;
}
else
{
System.out.println("Empty
queuebfs"); return -1;
} }}
class Graph
{
int g[][];
int v,e;
int visited[];
int a,b;
QueueBFS q=new QueueBFS();
void createGraph()throws IOException
{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter the number of vertices:");
v=Integer.parseInt(br.readLine());
System.out.println("Enter the number of edges:");
e=Integer.parseInt(br.readLine());
g=new int[v+1][v+1];
for(int i=1;i<=e;i++)
{
System.out.println("Enter the Edge
information:"); System.out.println("From=");
a=Integer.parseInt(br.readLine());
System.out.println("To=");
b=Integer.parseInt(br.readLine()); g[a][b]=g[b]
[a]=1;
}
}
P a g e 2 | 54

void callBfs()
{
visited=new int[v+1];
bfs(1);
}
void bfs(int k)
{
q.insert(k);
while(q.front!=null)
{ k=q.delete();
visited[k]=1;
System.out.print(k+"\t");
for(int i=1;i<=v;i++)
{
if(g[k][i]!=0 && visited[i]!=1)
{
q.insert(i);
visited[i]=1;
}
}
}
}
}
class Graph1
{
int g[][];
int v,e;
int visited[];
void createGraph1()throws IOException
{
int a,b;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.print("\n Enter Number Of Vertices = ");
v=Integer.parseInt(br.readLine());
System.out.print("\n Enter Number Of Edges = ");
e=Integer.parseInt(br.readLine());
g=new int[v+1][v+1];
for(int i=1;i<=e;i++)
{
System.out.print("\n Enter Edge Infomation ");
System.out.print("\n From =");
a=Integer.parseInt(br.readLine());
System.out.print("\n To =");
b=Integer.parseInt(br.readLine()); g[a][b]=g[b]
[a]=1;
}}
P a g e 3 | 54

void callDFS()
{
visited = new int[v+1];
dfs(1);
}
void dfs(int k)
{
System.out.print(k + "\t");
visited[k]=1;
for(int i=1;i<=v;i++)
{
if(g[k][i] !=0 && visited[i]!
=1) dfs(i);
} }}
class Graphsearch
{
public static void main(String args[])throws IOException
{ BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); int c;
boolean i=true;
while(i)
{
System.out.println("\n\n MAIN MENU");
System.out.println("\n 1.BFS \t 2.DFS \t
3.EXIT"); System.out.println("\n Enter ur
Choice:"); c=Integer.parseInt(br.readLine());
switch(c)
{
case 1:
Graph g=new Graph();
g.createGraph();
g.callBfs();
break;
case 2:
Graph1 g1 = new Graph1();
g1.createGraph1();
g1.callDFS();
break;
case 3:
i=false;
break;
}
}
}
}
P a g e 4 | 54
OUTPUT:
P a g e 5 | 54
RESULT:
Thus the java program for the implementation of graph search algorithm using the concept
Breadth First and Depth First search has been executed successfully.
P a g e 6 | 54
Ex.No:2
Prims Algorithm
Aim:
Prims Algorithm.
Algorithm:
Step1: Start the program
Step2: Enter the number of vertices and edges .
Step3: Give the edge information.
Step4: Enter the weight for each edge.
Step5: Then calculate minimum cost.
Step6: Find the Minimum Spanning Tree.
Source Code:
import java.io.*;
import java.util.*;
class Graph
{
int weight[][]=new int[20][20];
int visited[]=new int [20];
int d[]=new int[20];
int p[]=new int[20];
int v,e;
void creategraph()throws IOException
{
int i,j,a,b,w;
BufferedReader in=new BufferedReader( new InputStreamReader(System.in));
System.out.print("\nEnter number of vertices :");
v=Integer.parseInt(in.readLine());
System.out.print("\nEnter number of
Edges :"); e=Integer.parseInt(in.readLine());
for ( i=1;i<=v;i++)
for( j=1;j<=v;j++)
weight[i][j]=0;
for (i=1;i<=v;i++)
{
p[i]=visited[i]=0;
d[i]=32767;
}
P a g e 7 | 54

for ( i=1;i<=e;i++)
{
System.out.print("\nEnter edge a,b and weight w :");
a=Integer.parseInt(in.readLine());
b=Integer.parseInt(in.readLine());
w=Integer.parseInt(in.readLine()); weight[a]
[b]=weight[b][a]=w;
}
}
void algo ()throws IOException
{
creategraph();
int current,total,mincost,i;
current=1;d[current]=0;
total=1;
visited[current]=1;
while(total!=v)
{
for (i=1;i<=v;i++)
{
if(weight[current][i]!=0)
if(visited[i]==0)
if(d[i]>weight[current][i])
{
d[i]=weight[current][i];
p[i]=current;
}
}
mincost=32767;
for (i=1;i<=v;i++)
{
if(visited[i]==0)
if(d[i]<mincost)
{
mincost=d[i];
current=i;
}
}
visited[current]=1;
total++;
}
mincost=0;
for(i=1;i<=v;i++)
mincost=mincost+d[i];
P a g e 8 | 54

System.out.print("\n Minimum cost="+mincost);
System.out.print("\n Minimum Spanning tree is");
for(i=1;i<=v;i++)
System.out.print("\n vertex" +i+"is connected to"+p[i]);
}
}
class prims
{
public static void main(String args[])throws IOException
{
Graph g=new
Graph(); g.algo();
}
}
P a g e 9 | 54
OUTPUT:
RESULT:
prims algorithm has been executed successfully.
P a g e 10 | 54
Ex.No:3
Kruskals Algorithm
Aim:
Kruskals Algorithm.
Algorithm:
Step2: Enter the number of nodes in the undirected weighted graph.
Step3: Give weight for each edge.
Step4: Find the minimum spanning tree, which node forms a cycle it is
removed. Step5: Then find the cost for spanning tree.
Source Code:
import java.io.*;
import java.util.*;
class Graphs
{
int i,n;
int noe;
int graph_edge[][]=new int[100][4];
int tree[][]=new int [10][10];
int sets[][]=new int[100][10];
int top[]=new int[100];
int cost=0;
int getNumber()
{
String str;
int ne=0;
InputStreamReader input=new InputStreamReader(System.in);
BufferedReader in=new BufferedReader(input);
try
{
str=in.readLine();
ne=Integer.parseInt(str);
}
catch(Exception e)
{
System.out.println("I/O Error");
}
return ne;
P a g e 11 | 54

}
void read_graph()
{
System.out.print("Enter the no. of nodes in the undirected weighted graph ::");
n=getNumber();
noe=0;
System.out.println("Enter the weights for the following edges
::\n"); for(int i=1;i<=n;i++)
{
for(int j=i+1;j<=n;j++)
{
System.out.print(" < "+i+" , "+j+"
> ::"); int w;
w=getNumber();
if(w!=0)
{
noe++;
graph_edge[noe][1]=i;
graph_edge[noe][2]=j;
graph_edge[noe][3]=w;
}
}
}
}
void sort_edges()
{
for(int i=1;i<=noe-1;i++)
{
for(int j=1;j<=noe-i;j++)
{
if(graph_edge[j][3]>graph_edge[j+1][3])
{
int t=graph_edge[j][1]; graph_edge[j]
[1]=graph_edge[j+1][1];
graph_edge[j+1][1]=t;
t=graph_edge[j][2]; graph_edge[j]
t=graph_edge[j][3]; graph_edge[j]
P a g e 12 | 54

}
}
}
}void algorithm()
{
for(int i=1;i<=n;i++)
{
sets[i][1]=i;
top[i]=1;
}
System.out.println("\nThe algorithm starts
::\n\n"); for(i=1;i<=noe;i++)
{
int p1=find_node(graph_edge[i][1]);
int p2=find_node(graph_edge[i][2]);
if(p1!=p2)
{
System.out.print("The edge included in the tree is ::");
System.out.print("< "+graph_edge[i][1]+" , ");
System.out.println(graph_edge[i][2]+" > ");;
cost=cost+graph_edge[i][3]; tree[graph_edge[i][1]]
[graph_edge[i][2]]=graph_edge[i][3]; tree[graph_edge[i]
[2]][graph_edge[i][1]]=graph_edge[i][3]; for(int
j=1;j<=top[p2];j++)
{
top[p1]++;
sets[p1][top[p1]]=sets[p2][j];
}
top[p2]=0;
}
else
{
System.out.println("Inclusion of the edge ");
System.out.print(" < "+graph_edge[i][1]+" , ");
System.out.println(graph_edge[i][2]+"> forms a cycle so it is
removed\n\n"); }
}
System.out.println("Cost of the spanning tree : "+cost);
}
int find_node(int n)
{
for(int i=1;i<=noe;i++)
{
for(int j=1;j<=top[i];j++)
{
P a g e 13 | 54

if(n==sets[i][j])
return i;
}
}
return -1;
}
}
class Kruskal1
{
public static void main(String args[])
{
Graphs obj=new Graphs();
obj.read_graph();
obj.sort_edges();
obj.algorithm();
}
}
P a g e 14 | 54
OUTPUT:
RESULT:
kruskals algorithm has been executed successfully.
P a g e 15 | 54
Implementation and application of Network flow and linear

programming problems
Ex.No:4
Implementation of Maximum Flow and Minimum Cut
Aim:
To write a java program for the implementation of Network Flow by finding the maximum
flow and minimum cut of a network.
Algorithm:
Step2: Enter the number of nodes.
Step3: Determine the Graph matrix.
Step4: Enter the source and sink in the graph.
Step5: Find the Maximum flow and minimum Cut set in the graph.
Source Code:
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Set; public
class NetworkFlowProb
{
private int[] parent;
private Queue<Integer> queue;
private int numberOfVertices;
private boolean[] visited;
private Set<Pair> cutSet;
private ArrayList<Integer> reachable;
private ArrayList<Integer> unreachable;
public NetworkFlowProb (int numberOfVertices)
{
this.numberOfVertices = numberOfVertices;
this.queue = new LinkedList<Integer>();
parent = new int[numberOfVertices + 1];
visited = new boolean[numberOfVertices + 1];
cutSet = new HashSet<Pair>();
reachable = new ArrayList<Integer>();
unreachable = new ArrayList<Integer>();
P a g e 16 | 54

}
public boolean bfs (int source, int goal, int graph[][])
{
boolean pathFound = false;
int destination, element;
for (int vertex = 1; vertex <= numberOfVertices; vertex++)
{
parent[vertex] = -1;
visited[vertex] = false;
}
queue.add(source);
parent[source] = -1;
visited[source] = true;
while (!queue.isEmpty())
{
element = queue.remove();
destination = 1;
while (destination <= numberOfVertices)
{
if (graph[element][destination] > 0 && !visited[destination])
{
parent[destination] = element;
queue.add(destination);
visited[destination] = true;
}
destination++;
}}
if (visited[goal])
{
pathFound = true;
}
return pathFound;
}
public int networkFlow (int graph[][], int source, int destination)
{
int u, v;
int maxFlow =
0; int pathFlow;
int[][] residualGraph = new int[numberOfVertices + 1][numberOfVertices + 1]; for
(int sourceVertex = 1; sourceVertex <= numberOfVertices; sourceVertex++)
{
for (int destinationVertex = 1; destinationVertex <= numberOfVertices;
destinationVertex++)
{
residualGraph[sourceVertex][destinationVertex] =
graph[sourceVertex][destinationVertex];
P a g e 17 | 54

}
}
/*max flow*/
while (bfs(source, destination, residualGraph))
{
pathFlow = Integer.MAX_VALUE;
for (v = destination; v != source; v = parent[v])
{
u = parent[v];
pathFlow = Math.min(pathFlow, residualGraph[u][v]);
}
for (v = destination; v != source; v = parent[v])
{
u = parent[v]; residualGraph[u][v]
-= pathFlow; residualGraph[v][u]
+= pathFlow;
} maxFlow += pathFlow;
}
/*calculate the cut set*/
for (int vertex = 1; vertex <= numberOfVertices; vertex++)
{
if (bfs(source, vertex, residualGraph))
{
reachable.add(vertex);
}
else
{
unreachable.add(vertex);
}}
for (int i = 0; i < reachable.size(); i++)
{
for (int j = 0; j < unreachable.size(); j++)
{
if (graph[reachable.get(i)][unreachable.get(j)] > 0)
{
cutSet.add (new Pair(reachable.get(i), unreachable.get(j)));
}}
}
return maxFlow;
}
public void printCutSet ()
{
Iterator<Pair> iterator = cutSet.iterator();
while (iterator.hasNext())
{
Pair pair = iterator.next();
System.out.println(pair.source + "-" + pair.destination);
P a g e 18 | 54

} }
public static void main (String...arg)
{
int[][] graph;
int numberOfNodes;
int source;
int sink;
int maxFlow;
Scanner scanner = new Scanner(System.in);
System.out.println("Enter the number of nodes");
numberOfNodes = scanner.nextInt();
graph = new int[numberOfNodes + 1][numberOfNodes +
1]; System.out.println("Enter the graph matrix");
for (int sourceVertex = 1; sourceVertex <= numberOfNodes; sourceVertex++)
{
for (int destinationVertex = 1; destinationVertex <= numberOfNodes; destinationVertex++)
{
graph[sourceVertex][destinationVertex] = scanner.nextInt();
}}
System.out.println("Enter the source of the graph");
source= scanner.nextInt();
System.out.println("Enter the sink of the graph");
sink = scanner.nextInt();
NetworkFlowProb networkFlowProb = new
NetworkFlowProb(numberOfNodes); maxFlow =
networkFlowProb.networkFlow(graph, source, sink); System.out.println("The
Max flow in the graph is " + maxFlow); System.out.println("The Minimum Cut
Set in the Graph is "); networkFlowProb.printCutSet();
scanner.close();
}}
class Pair
{
public int source;
public int destination;
public Pair(int source, int destination)
{
this.source = source;
this.destination = destination;
}
public Pair()
{
}}
P a g e 19 | 54
OUTPUT:
RESULT:
Thus the java program for the implementation of Network Flow by finding the maximum
flow and minimum cut of a network has been successfully executed.
P a g e 20 | 54
Implementation of Algorithm using Hill Climbing and Dynamic Programming

Design Technique
Ex.No:5
Travelling Salesman Problem
Aim:
To write a java program for the Implementation of hill climbing using travelling salesman
problem.
Algorithm:
Step1: Start the program
Step2: Enter the number of nodes.
Step3: Specify the weight for each edge.
Step4: Assume the starting node.
Step5: Find the tour and its cost.
Source Code:
import java.util.*;
import java.text.*;
class TSP
{
int weight[][],n,tour[],finalCost;
final int INF=1000;
public TSP()
{
Scanner s=new Scanner(System.in);
System.out.println("Enter no. of
nodes:=>"); n=s.nextInt();
weight=new int[n][n];
tour=new int[n-1];
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
if(i!=j)
{
System.out.print("Enter weight of "+(i+1)+" to "+
(j+1)+":=>"); weight[i][j]=s.nextInt();
}}}
System.out.println();
System.out.println("Starting node assumed to be node
1."); eval();
P a g e 21 | 54

}
public int COST(int currentNode,int inputSet[],int setSize)
{
if(setSize==0)
return weight[currentNode][0];
int min=INF,minindex=0;
int setToBePassedOnToNextCallOfCOST[]=new int[n-1];
for(int i=0;i<setSize;i++)
{
int k=0;//initialise new set
for(int j=0;j<setSize;j++)
{
if(inputSet[i]!=inputSet[j])
setToBePassedOnToNextCallOfCOST[k++]=inputSet[j];
}
int temp=COST(inputSet[i],setToBePassedOnToNextCallOfCOST,setSize-1);
if((weight[currentNode][inputSet[i]]+temp) < min)
{ min=weight[currentNode][inputSet[i]]+temp;
minindex=inputSet[i];
}}
return min;
}
public int MIN(int currentNode,int inputSet[],int setSize)
{
if(setSize==0)
return weight[currentNode][0];
int min=INF,minindex=0;
int setToBePassedOnToNextCallOfCOST[]=new int[n-1];
for(int i=0;i<setSize;i++)//considers each node of inputSet
{
int k=0;
{
if(inputSet[i]!=inputSet[j])
setToBePassedOnToNextCallOfCOST[k++]=inputSet[j];
}
int temp=COST(inputSet[i],setToBePassedOnToNextCallOfCOST,setSize-1);
if((weight[currentNode][inputSet[i]]+temp) < min)
{
min=weight[currentNode][inputSet[i]]+temp;
minindex=inputSet[i];
}}
return minindex; }
public void eval()
{
P a g e 22 | 54

int dummySet[]=new int[n-1];
for(int i=1;i<n;i++) dummySet[i1]=i;
finalCost=COST(0,dummySet,n-1);
constructTour();
}
public void constructTour()
{
int previousSet[]=new int[n-1];
int nextSet[]=new int[n-2]; for(int i=1;i<n;i++)
previousSet[i-1]=i;
int setSize=n-1;
tour[0]=MIN(0,previousSet,setSize);
for(int i=1;i<n-1;i++)
{
int k=0;
{
if(tour[i-1]!=previousSet[j])
nextSet[k++]=previousSet[j];
}
--setSize; tour[i]=MIN(tour[i1],nextSet,setSize); for(int
j=0;j<setSize;j++)
previousSet[j]=nextSet[j];
}
display();
}
public void display()
{
System.out.print("The tour is
1-"); for(int i=0;i<n-1;i++)
System.out.print((tour[i]+1)+"-");
System.out.print("1");
System.out.println("The final cost is "+finalCost);
}}
class TSPExp
{
{
TSP obj=new TSP();
}
}
P a g e 23 | 54
OUTPUT:
RESULT:
Thus the java program for the implementation of Hill climbing algorithm using travelling
salesman problem has been executed successfully.
P a g e 24 | 54
Ex.No:6
Longest Common Subsequences
Aim:
To write a java program for the Implementation of dynamic programming using longest
common subsequences problem.
Algorithm:
Step2: Enter the string1 and string2.
Step3: Determine the common sequence by matching the strings.
Step4: Find the length of longest common subsequence.
Step5: Display the common sequence between the given input strings.
Source Code:
import java.util.*;
class lcs
{
static class cell
{
int cost, parent;
}
static final int MAXLEN = 100;
static cell m[][] = new cell[MAXLEN][MAXLEN];
static final int MATCH = 0;
static final int INSERT = 1;
static final int DELETE =
2; static int indel(char c)
{return 1;}
static int match(char c, char d)
{
if(c==d) return 0;
return MAXLEN;
}
static void row_init(int i)
{
m[0][i].cost = i;
if (i>0) m[0][i].parent = INSERT;
else m[0][i].parent = -1; }
static void column_init(int i)
{
m[i][0].cost = i;
P a g e 25 | 54

if (i>0) m[i][0].parent = DELETE;
else m[0][i].parent = -1;
}
static int string_compare(String s, String t)
{
for(int i=0;i<MAXLEN;i++)
{
row_init(i);
column_init(i);
} int k,
lowest_cost;
int opt[] = new int [3];
for(int i=1;i<s.length();i++)
for(int j=1;j<t.length();j++)
{
opt[MATCH] = m[i-1][j-1].cost + match(s.charAt(i),t.charAt(j));
opt[INSERT] = m[i][j-1].cost + indel(t.charAt(j)); opt[DELETE] =
m[i-1][j].cost + indel(s.charAt(i));
m[i][j].cost = opt[MATCH];
m[i][j].parent = MATCH;
for (k=INSERT; k<=DELETE; k++)
if (opt[k] < m[i][j].cost)
{
m[i][j].cost = opt[k];
m[i][j].parent = k;
}}
return m[s.length()-1][t.length()-1].cost;
}
static void print_matrix(String s, String t, boolean costQ)
{
int x = s.length();
int y = t.length();
System.out.printf(" ");
for(int i=0;i<y;i++)
System.out.printf(" %c",t.charAt(i));
System.out.printf("\n");
for(int i=0; i<x; i++)
{ System.out.printf("%c:
",s.charAt(i)); for(int j=0; j<y; j++) {
if(costQ)
System.out.printf(" %2d",m[i][j].cost);
else
System.out.printf(" %2d",m[i][j].parent);
}
}}static void reconstruct_path(String s, String t, int i, int j)
P a g e 26 | 54

{
if(m[i][j].parent == -1) return;
if (m[i][j].parent == MATCH) {
reconstruct_path(s,t,i-1,j-1);
match_out(s, t, i, j);
return;
}
if (m[i][j].parent == INSERT)
{ reconstruct_path(s,t,i,j1);
insert_out(t,j);
return;
}
if (m[i][j].parent == DELETE)
{ reconstruct_path(s,t,i1,j); delete_out(s,i);
return;
}return;}
static void match_out(String s, String t, int i, int j)
{
if(s.charAt(i) == t.charAt(j)) System.out.printf("%c",s.charAt(i));
}
static void insert_out(String t, int
j) {}
static void delete_out(String s, int i)
{}
static public void main(String[] args)
{
for(int i=0;i<MAXLEN;i++)
for(int j=0;j<MAXLEN;j++)
m[i][j]=new cell();
String s = new String();
String t = new String();
Scanner sc = new Scanner(System.in);
System.out.println("Enter the
String1:"); s=sc.next();
System.out.println("Enter the
String2:"); t=sc.next();
s=" " + s; t=" " + t;
int complen = string_compare(s,t);
int lcslen = (s.length() + t.length() - 2 - complen) / 2;
System.out.printf("length of longest common subsequence = %d\n", lcslen);
System.out.printf("Common Sequence:",complen);
reconstruct_path(s,t,s.length()-1,t.length()-1);
}}
P a g e 27 | 54
OUTPUT:
RESULT:
Thus the java program for the implementation of Dynamic Programming using longest
common subsequences problem has been executed successfully.
P a g e 28 | 54
Implementation of Recursive Backtracking Algorithms

Ex.No:7
N Queens Problem
Aim:
To write a java program for implementation of Recursive Backtracking Algorithms using N
Queens Problem.
Algorithm:
Step2: Enter the board size.
Step3: Then place the queen based on board size.
Step4: Find the solution for given board size.
Step5: Check the condition board size less than or equal to row and column the print
Q. Step6: Otherwise print dot(.).
Step7: Repeat Step5 until there is no solution possible.
Source Code:
public class Queens
{
protected int boardSize;
protected boolean[][] board;
public Queens (int boardSize)
{
this.boardSize = boardSize;
board = new boolean[boardSize][boardSize];
for (int row = 0; row < boardSize; row++)
for (int column = 0; column < boardSize; column+
+) board[row][column] = false;
}
protected boolean placeQueen (int column)
{
int row;
if (column == boardSize)
{
return true;
}
else
{
boolean successful =
false; row = 0;
P a g e 29 | 54

while ((row < boardSize) && !successful)
{
if (threat (row, column))
{
row++;
}
else
{
board[row][column] = true;
successful = placeQueen (column + 1);
if (!successful)
{
board[row][column] = false;
row++;
}}}
return successful;
}}
protected boolean threat (int row, int column)
{
for (int c = 0; c < column; c++)
{
if (board[row][c])
{
return true;
}}
for (int c = 1; c <= column; c++)
{
if (row < c)
{
break;
}
if (board[row - c][column - c])
{
return true;
}}
for (int c = 1; c <= column; c++)
{
if (row + c >= boardSize)
{
break;
}
if (board[row + c][column - c])
{
return true;
P a g e 30 | 54

}
}
return false;
}
protected void outputBoard()
{
System.out.println("Solution for board of size " + boardSize +
":"); for (int row = 0; row < boardSize; row++)
{
for (int column = 0; column < boardSize; column++)
{
if (board[row][column])
{
System.out.print("Q ");
}
else
{
System.out.print(". ");
}}
}
}
public void solve()
{
if (placeQueen(0))
{
outputBoard();
}
else
{
System.out.println("There is no solution possible");
}}
public static void main (String[] args)
{
Queens board;
Scanner input = new Scanner (System.in);
System.out.print("Enter the board Size: "); //Gain Size of board from user
int boardSize = input.nextInt();
input.close();
board = new Queens(boardSize);
board.solve();
}
}
P a g e 31 | 54
OUTPUT:
RESULT:
Thus the java program for the implementation of recursive backtracking algorithm using
NQueens problem has been executed successfully.
P a g e 32 | 54
Ex.No:8
Permutations
Aim:
To write a java program for implementation of Recursive Backtracking Algorithms using
Permutation Problem.
Algorithm:
Step2: Enter the initial string.
Step3: Find the permutation for given string.
Step4: Check the condition for ending string which is less than or equal to value
1. Step5: Print the string.
Source Code:
import java.io.*; public
class permutation
{
public static void main(String args[]) throws IOException
{
String str;
System.out.println("Enter the initial string");
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
str=br.readLine();
System.out.println("Permutations
are :"); permute("", str);
}
public static void permute(String beginningString, String endingString)
{
if (endingString.length() <= 1)
System.out.println(beginningString + endingString);
else
for (int i = 0; i < endingString.length(); i++)
{
try {
String newString = endingString.substring(0, i) + endingString.substring(i + 1);
permute(beginningString + endingString.charAt(i), newString);
} catch (StringIndexOutOfBoundsException exception)
{
exception.printStackTrace() } }}}
P a g e 33 | 54
OUTPUT:
RESULT:
Thus the java program for the implementation of recursive backtracking algorithm using
Permutation problem has been executed successfully.
P a g e 34 | 54
Implementation of Randomized Algorithms

Ex.No:9
Quick Sort
Aim:
To write a java program for the implementation of Randomized Algorithms using Quick
Sort problem.
Algorithm:
Step2: Enter the limit for its elements.
Step3: Check if low is less than or equal to high then, temp=a[low];
a[low]=a[high]; a[high]=temp;
Step4: Then increment low and decrement high.
Step5: Display the sorted array elements in ascending order.
Source Code:
import java.io.*; import
java.util.Scanner;
import java.util.Random;
public class quicksort{
private static final Random rnd =new Random();
public static void main(String[] args){
int i;
Scanner in=new Scanner(System.in);
System.out.println(" Quick Sort\n");
System.out.println("Enter the no. of elements in the
array:\n"); int arr_val=in.nextInt();
int array[]=new
int[arr_val]; try
{
BufferedReaderbr=new BufferedReader(new InputStreamReader(System.in));
System.out.println("\nEnter the Array Elements:\n");
for(i=0;i<arr_val;i++)
{
array[i]=Integer.parseInt(br.readLine());
}
}
catch(Exception ex)
{
}
P a g e 35 | 54

System.out.println("\nValues Before the sort:\n");
for(i = 0; i < array.length; i++)
System.out.print( array[i]+" ");
System.out.println("\n");
System.out.println("Pivot Values\n");
quickSort(array,0,array.length-1);
System.out.print("\nValues after the sort:\n");
for(i = 0; i <array.length; i++){
System.out.print(array[i]+" ");
}
System.out.println("\n");
}
public static int partition(int arr[], int left, int right)
{ int i = left, j = right;
int tmp;
int pivot = arr[left + rnd.nextInt(right left)]; System.out.println(+pivot);
while (i <= j)
{ while (arr[i] <
pivot)
i++;
while (arr[j] > pivot)
j--;
if (i <= j)
{ tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp; i++;
j--;
}
};
return i;
}
public static void quickSort(int arr[], int left, int right)

{ int index = partition(arr, left, right);
if (left < index - 1)
quickSort(arr, left, index - 1);
if (index < right)
quickSort(arr, index, right);
}
}
OUTPUT:
P a g e 36 | 54
RESULT:
Thus the java program for the implementation of randomized algorithm using quick sort
problem has been executed successfully.
P a g e 37 | 54
Matrix Multiplication
Ex.No:10
Aim:
To write a java program for the implementation of Randomized Algorithms using Matrix
Multiplication problem.
Algorithm:
Step2: Enter the matrix dimension.
Step3: Then create a matrices function.
Step4: Fill the first matrix with the random numbers.
Step5: Check the condition for the first matrix that number less than dimension.
Step6: Then fill the second matrix with the random numbers.
Step7: Check the condition for the second matrix that number less than dimension.
Step8: Multiplying the matrices.
Step9: Display the resulting matrix.
Source Code:
import java.util.Random;
public class Matrix

{
public static void main(String[]args)
{
Scanner keyboard = new Scanner(System.in);
System.out.printf("Type in the matrix dimension.\n");
int dimension = keyboard.nextInt();
int matrix1[][] = new int[dimension][dimension];
int matrix2[][] = new int[dimension][dimension];
int result[][] = new int[dimension][dimension];
for (int i = 0; i < dimension; i++){
for (int j = 0; j < dimension; j++)
{ Random rand = new
Random(); int r =
rand.nextInt(9);
matrix1 [i][j] = r;
}
}
System.out.printf("\nMatrix One:\n");
P a g e 38 | 54

for (int i = 0; i < dimension; i ++)
{ System.out.printf("\n");
{ System.out.printf("%d ", matrix1[i]
[j]); System.out.printf("\t");
}
}
for (int i = 0; i < dimension; i++){
{ Random rand1 = new
Random(); int r1 =
rand1.nextInt(9); matrix2 [i][j] =
r1;
}
}
System.out.printf("\n\nMatrix Two:\n");
for (int i = 0; i < dimension; i ++){
{ System.out.printf("%d ", matrix2[i]
}
}
for (int i = 0; i < matrix1.length;i++){

for (int j = 0; j < matrix2.length; j++){
for (int k = 0; k < matrix2.length; k++){ result[i][j]
+= matrix1[i][k] * matrix2[k][j];
}
}
} System.out.printf("\n\nMultiplied
Matrix:\n");
for (int i = 0; i < dimension; i++)
{ System.out.printf("\n");
{ System.out.printf("%d ", result[i]
}
}
}
}
P a g e 39 | 54
OUTPUT:
RESULT:
Thus the java program for the implementation of randomized algorithm using matrix
multiplication problem has been executed successfully.
P a g e 40 | 54
Implementation of various Locking and Synchronization Mechanisms for

Concurrent Linked Lists, Concurrent Queues, and Concurrent Stacks.
Ex.No : 11
Concurrent Linked List
Aim:
To write a java program to implement the various locking and synchronization mechanisms for
Concurrent Linked List.
Algorithm:
Step 1: Start the program.
Step 2: Include the necessary packages.
Step 3: Define the Linked Node definition.
Step 4: Create a constructor to build a node with null and specified constructor.
Step 5: Create a linked list class.
Step 6: Check for assertion if the assertion is not true then it throws java.lang.assertion error.
Step 7: Create a function to check if the list is empty or not.
Step 8: Display the result.
Step 9: Stop the program.
Source Code:
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
public class EarlyNotify extends Object

{ private List list;
public EarlyNotify() {
list = Collections.synchronizedList(new LinkedList());
}
public String removeItem() throws
InterruptedException {
synchronized (list) {
while (list.isEmpty())
{ print("wait()");
list.wait();
print("done with wait()");
}
String item = (String) list.remove(0);
P a g e 41 | 54
return item;
}
}
public void addItem(String item)
{ print("entering");
synchronized (list)
{ list.add(item);
print("added: '" + item + "'");
list.notifyAll();
print("notified");
}
print("leaving");
}
private static void print(String msg) {
String name = Thread.currentThread().getName();
System.out.println(name + ": " + msg);
}
public static void main(String[] args) { final
EarlyNotify enf = new EarlyNotify();
Runnable runA = new Runnable() {

public void run() {
try {
String item = enf.removeItem();
print("returned: '" + item + "'");
} catch (InterruptedException ix)
{ print("interrupted!");
} catch (Exception x) {
print("threw an Exception!!!\n" + x);
}
}
};
Runnable runB = new Runnable()
{ public void run() {
enf.addItem("Hello!");
}
};
try {
Thread threadA1 = new Thread(runA, "A");
P a g e 42 | 54

threadA1.start();
Thread.sleep(500);
Thread threadA2 = new Thread(runA, "B");
threadA2.start();
Thread.sleep(500);
Thread threadB = new Thread(runB, "C");
threadB.start();
Thread.sleep(1000);
threadA1.interrupt();
threadA2.interrupt();
} catch (InterruptedException x) {
}
}
}
P a g e 43 | 54
OUTPUT :
RESULT :
Thus a java program to implement the various locking and synchronization mechanisms for
Concurrent Linked List has been executed successfully.
P a g e 44 | 54
Ex.No : 12
Concurrent Queue
Aim:
To write a java program to implement producer consumer problem using concurrent blocking
Queue.
Algorithm:
Step 3: Create the shared object for the class using blocking queue.
Step 4: Create producer class in java.
Step 5: Create consumer class in java.
Step 6: Display the result.
Step 7: Stop the program.
Source Code:
import java.io.*; import
java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.logging.Level;
import java.util.logging.Logger;
public class ProducerConsumerPattern
{
{
BlockingQueue sharedQueue = new LinkedBlockingQueue();
Thread prodThread = new Thread(new Producer(sharedQueue));
Thread consThread = new Thread(new Consumer(sharedQueue));
prodThread.start();
consThread.start();
}
}
class Producer implements Runnable
{
private final BlockingQueue sharedQueue;
public Producer(BlockingQueue sharedQueue)
{
this.sharedQueue = sharedQueue;
}
public void run()
{
for(int i=0; i<10; i++)
P a g e 45 | 54

{
try {
System.out.println("Produced: " +
i); sharedQueue.put(i);
}
catch (InterruptedException ex)
{
Logger.getLogger(Producer.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
}
class Consumer implements Runnable
{
private final BlockingQueue sharedQueue;
Consumer (BlockingQueue sharedQueue)
{ this.sharedQueue = sharedQueue;
}
public void run()
{
while(true)
{
try
{
System.out.println("Consumed: "+ sharedQueue.take());
}
catch (InterruptedException ex)
{
Logger.getLogger(Consumer.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
}
P a g e 46 | 54
OUTPUT :
RESULT :
Thus a java program to implement producer consumer problem using concurrent blocking Queue
has been successfully executed.
P a g e 47 | 54
Ex.No : 13
Concurrent Stack
Aim:
To write a java program to implement concurrent stack using push and pop.
Algorithm:
Step 3: Create a class stackimpl2
Step 4: Initialize the stack using push and pop.
Step 5: Create a wait() method that is called to pop the waiting element.
Step 6: Create a notify() method to notify the popped elements.
Step 7: Stackuser class has been created to extends thread.
Step 8: Start Daemon thread using set daemon.
Step 9: Start this thread.
Step10: Display the result.
Source Code:
Import java.io.*;
class StackImpl2
{
private Object[] stackArray;
private volatile int topOfStack;
StackImpl2 (int capacity)
{
stackArray = new
Object[capacity]; topOfStack = -1;
}
public synchronized Object pop()
{
System.out.println(Thread.currentThread() + ":
popping"); while (isEmpty())
try
{
System.out.println(Thread.currentThread() + ": waiting to
pop"); wait(); // (1)
}
catch (InterruptedException
e) { }
Object obj = stackArray[topOfStack];
stackArray[topOfStack--] = null;
System.out.println(Thread.currentThread() + ": notifying after pop");
P a g e 48 | 54
notify();
return obj;
// (2)
P a g e 49 | 54
}
public synchronized void push(Object element)
{
System.out.println(Thread.currentThread() + ": pushing");
while (isFull())
try
{
System.out.println(Thread.currentThread() + ": waiting to push");
wait(); // (3)
}
catch (InterruptedException e)
{}
stackArray[++topOfStack] = element;
System.out.println(Thread.currentThread() + ": notifying after push");
notify(); // (4)
} public boolean
isFull()
{
return topOfStack >= stackArray.length -1;
}
public boolean isEmpty()
{
return topOfStack < 0;
}
}
abstract class StackUser extends Thread
{ // (5) Stack user protected StackImpl2 stack; // (6)
StackUser(String threadName, StackImpl2 stack)
{
super(threadName);
this.stack = stack;
System.out.println(this);
setDaemon(true); start();
// (7) Daemon
thread // (8) Start this thread
}
}
class StackPopper extends StackUser
{ // (9) Popper
StackPopper(String threadName, StackImpl2 stack)
{
super(threadName, stack);
}
public void run()

{
while (true) stack.pop();
}
}
class StackPusher extends StackUser
{ // (10) Pusher
StackPusher(String threadName, StackImpl2 stack)
{
super(threadName, stack);
}
public void run()
{
while (true) stack.push(new Integer(1));
}
}
public class WaitAndNotifyClient
{
public static void main(String[] args)throws InterruptedException
{ // (11)
StackImpl2 stack = new StackImpl2(5);
new StackPusher("A", stack);
new StackPusher("B", stack);
new StackPopper("C", stack);
System.out.println("Main Thread sleeping.");
Thread.sleep(10);
System.out.println("Exit from Main Thread.");
}
}
P a g e 50 | 54
OUTPUT :
RESULT :
Thus to write a java program to implement concurrent stack using push and pop has been
executed successfully.
P a g e 51 | 54
Developing applications involving concurrency.

Ex.No : 14
Sleeping Barber Problem
Aim:
To write a java program to implement Sleeping Barber problem using Concurrency.
Algorithm:
Step 1: Import the header files.
Step 2: Declare the number of chairs and barbers in the
shop Step 3: Enter the number of customer.
Step 4: If there is no customer to be served, the barber goes to sleep.
Step 5:If a customer enters the barber shop whole chairs are occupied, then the customer
leaves the Shop.
Step 6: If the barber is busy, but chairs are available in waiting room then the customer sits
in one of the free chairs until the barber is idle.
Step 7: Barber class which extends threads is used to simulate multiple sleeping barbers
Source Code:
import java.io.*;
import java.lang.*;
class cust
{
public int disp(int cn)
{
return(cn);
}
}
class em1 extends
Thread{ Barber m=new
Barber(); cust c=new
cust();
public synchronized void run()
{
try
{
while(m.cnum<=m.n)
{
int t=c.disp(m.cnum++);
System.out.println("Barber2 serves Customer
"+t); Thread.sleep(2000);
}
P a g e 52 | 54

System.out.println("Barber2 sleeps ");
}
catch(Exception e){}
}
}
public class Barber
{
static int cnum=1,n,ch,n1;
public static void main(String[] args)
{ try
{
BufferedReaderbr=newBufferedReader(new InputStreamReader(System.in));
em1 e=new em1();
cust c=new
cust(); int j;
System.out.println("Enter no of Chairs including two barber Chairs: ");
ch=Integer.parseInt(br.readLine()); System.out.println("Enter no of
Customers : "); n=Integer.parseInt(br.readLine());
e.start();
if(ch<n)
{
n1=n-ch;
System.out.println(n1+" Customers Leaved from the Shop");
n=n-n1;
while(cnum<=n)
{
int t=c.disp(cnum++);
System.out.println("Barber1 serves " +" Customer " + t);
Thread.sleep(1000);
}
}
else
{
while(cnum<=n)
{
int t=c.disp(cnum++);
System.out.println("Barber1 serves " +" Customer " + t);
Thread.sleep(1000);
}
}
System.out.println("Barber1 sleeps ");
}
catch(Exception e){}
}}
P a g e 53 | 54
OUTPUT :
RESULT :
Thus a java program to implement Sleeping Barber problem using Concurrency has been
executed successfully.
P a g e 54 | 54

Ads Lab Record

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Ads Lab Record

Încărcat de

Drepturi de autor:

Formate disponibile

CP7111 Advanced Data Structures Lab Record

Implementation of Graph Search Algorithm

Breadth First Search and Depth First Search

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

Implementation and application of Network flow and linear

Implementation of Maximum Flow and Minimum Cut

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

Implementation of Algorithm using Hill Climbing and Dynamic Programming

Travelling Salesman Problem

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

Longest Common Subsequences

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

Implementation of Recursive Backtracking Algorithms

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

Implementation of Randomized Algorithms

CP7111 Advanced Data Structures Lab Record

public static void quickSort(int arr[], int left, int right)

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

public class Matrix

CP7111 Advanced Data Structures Lab Record

for (int i = 0; i < matrix1.length;i++){

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

Implementation of various Locking and Synchronization Mechanisms for

Concurrent Linked List

public class EarlyNotify extends Object

CP7111 Advanced Data Structures Lab Record

Runnable runA = new Runnable() {

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record

CP7111 Advanced Data Structures Lab Record