DS REC Rajkumar

Reg No: 310114405010

PROGRAM:

import java.io.*;

class BFS

{

public static void main(String args[]) throws IOException

{

int i,j,k,n,ch;

System.out.println("No of vertices:");

BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

n=Integer.parseInt(br.readLine());

int q[]=new int[10];

int m[]=new int[10];

int a[][]=new int[10][10];

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

m[i]=0;

System.out.println("1. DIRECTED GRAPH\n2.UNDIRECTED GRAPH");

ch=Integer.parseInt(br.readLine());

System.out.println("\n\n enter 1 if edge is present, else 0");

if(ch==1)

{

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

{

System.out.println("\n");

for(j=0;j<n;j++)

{

if(i!=j)

{

System.out.println("Edge between"+(i+1)+" and "+(j+1)+":");

a[i][j]=Integer.parseInt(br.readLine());

}

}

a[i][i]=0;

}

}

else if(ch==2)

{

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

{


for(j=i;j<n;j++)

{

Reg No: 310114405010

if(i!=j)

{

System.out.println("Edge between"+(i+1)+" and "+(j+1)+":");


a[j][i]=a[i][j];

}

}

a[i][i]=0;

}

}

else

System.out.println("Enter a valid choice.....");

System.out.println("\n Order of the accessed nodes:\n");

q[0]=0;m[0]=1;

int u;

int node=1;

int beg1=1,beg=0;

while(node>0)

{

u=q[beg];

beg++;

System.out.println(" "+(u+1));

node--;

for(j=0;j<n;j++)

{

if(a[u][j]==1)

{

if(m[j]==0)

{

m[j]=1;

q[beg1]=j;

node++;

beg1++;

}

}

}

}

}

}

Reg No: 310114405010

OUTPUT:

No of vertices: 5

1. DIRECTED GRAPH

2. UNDIRECTED GRAPH

2

Enter 1 if edge is present, else 0

Edge between 1 and 2: 1










Order of accessed nodes:

1

2

3

4

5

Reg No: 310114405010

PROGRAM:

import java.io.*;

class DFS

{

static void dfs(int a[][],int m[],int i,int n)

{

int j;

System.out.println("\t"+(i+1));

m[i]=1;

for(j=0;j<n;j++)

if(a[i][j]==1&& m[j]==0)

dfs(a,m,j,n);

}


{

int n,i,j;

System.out.println("No of vertices");



int m[]=new int[n];

int a[][]=new int[n][n];

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

{

m[i]=0;

}

System.out.println("\n \n Enter 1 if edge is present, else 0");

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

{


for(j=0;j<n;j++)

{

if(i!=j)

{

System.out.println("Edge between"+(i+1)+" and"+(j+1)+":");


}

}

a[i][i]=0;

}

System.out.println("\n order of accesed nodes:\n");

Reg No: 310114405010

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

if(m[i]==0)

dfs(a,m,i,n);

}

}

Reg No: 310114405010

OUTPUT:

Enter the no of vertices: 7

Enter 1 if edge is present, else 0

































Reg No: 310114405010











Order of accessed nodes:

1

2

3

4

6

5

7

Reg No: 310114405010

PROGRAM:

import java.util.PriorityQueue;

import java.util.List;

import java.util.ArrayList;

import java.util.Collections;

class Vertex implements Comparable<Vertex>

{

public final String name;

public Edge[] adjacencies;

public double minDistance = Double.POSITIVE_INFINITY;

public Vertex previous;

public Vertex(String argName) { name = argName; }

public String toString() { return name; }

public int compareTo(Vertex other)

{

return Double.compare(minDistance, other.minDistance);

}

}

class Edge

{

public final Vertex target;

public final double weight;

public Edge(Vertex argTarget, double argWeight)

{ target = argTarget; weight = argWeight; }

}

public class Dijkstra1

{

public static void computePaths(Vertex source)

{

source.minDistance = 0.;

PriorityQueue<Vertex> vertexQueue = new PriorityQueue<Vertex>();

vertexQueue.add(source);

while (!vertexQueue.isEmpty())

{

Vertex u = vertexQueue.poll();

for (Edge e : u.adjacencies)

{

Vertex v = e.target;

double weight = e.weight;

double distanceThroughU = u.minDistance + weight;

Reg No: 310114405010

if (distanceThroughU < v.minDistance)

{

vertexQueue.remove(v);

v.minDistance = distanceThroughU ;

v.previous = u;

vertexQueue.add(v);

}

}

}

}

public static List<Vertex> getShortestPathTo(Vertex target)

{

List<Vertex> path = new ArrayList<Vertex>();

for (Vertex vertex = target; vertex != null; vertex = vertex.previous)

path.add(vertex);

Collections.reverse(path);

return path;

}

public static void main(String[] args)

{

Vertex v0 = new Vertex("Redvile");

Vertex v1 = new Vertex("Blueville");

Vertex v2 = new Vertex("Greenville");

Vertex v3 = new Vertex("Orangeville");

Vertex v4 = new Vertex("Purpleville");

v0.adjacencies = new Edge[]{ new Edge(v1, 5),new Edge(v2, 10),new Edge(v3, 8) };

v1.adjacencies = new Edge[]{ new Edge(v0, 5),new Edge(v2, 3),new Edge(v4, 7) };

v2.adjacencies = new Edge[]{ new Edge(v0, 10),new Edge(v1, 3) };



Vertex[] vertices = { v0, v1, v2, v3, v4 };

computePaths(v0);

for (Vertex v : vertices)

{

System.out.println("Distance to " + v + ": " + v.minDistance);

List<Vertex> path = getShortestPathTo(v);

System.out.println("Path: " + path);

}

}

}

Reg No: 310114405010

OUTPUT:

Distance to Redville: 0.0

Path: [Redville]

Distance to Blueville: 0.0

Path: [Redville, Blueville]

Distance to Greenville: 0.0

Path: [Redville, Blueville, Greenville]

Distance to Orangeville: 0.0

Path: [Redville,Orangeville]

Distance to Purpleville: 0.0

Path: [Redville,Orangeville,Purpleville]

Reg No: 310114405010

PROGRAM:

import java.io.*;

public class Kruskal1

{

static int path[];

static int n,m,mincost,i,j;

public static void main(String args[])throws Exception

{


System.out.println("Enter yhe no of vertices in graph");


System.out.println("Enter the no of edges in graph:");

m=Integer.parseInt(br.readLine());

path=new int[n+1];

Edge e[]=new Edge[m];

Edge t=new Edge();

System.out.println("Enter 2 vertices and weight of the edge");

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

{

e[i]=new Edge();

System.out.println("First vertex:");

e[i].u=Integer.parseInt(br.readLine());

System.out.println("Second vertex:");

e[i].v=Integer.parseInt(br.readLine());

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

e[i].wt=Integer.parseInt(br.readLine());

}

for(i=0;i<=m-1;i++)

{

for(j=0;j<m-i-1;j++)

{

if(e[j].wt>e[j+1].wt)

{

t=e[j];

e[j]=e[j+1];

e[j+1]=t;

}

}

}

for(i=1;i<=n;i++)

Reg No: 310114405010

{

path[i]=0;

}

i=0;j=0;mincost=0;

System.out.println();

while((i!=n-1)&&(j!=m))

{

System.out.print("Edge("+e[i].u+","+e[i].v+")with weight"+e[i].wt+" ");

if(checkCycle(e[i]))

{

mincost=mincost+e[i].wt;

i++;

System.out.print("is selected");

}

else

{

System.out.print("is discared");

}

j++;


}

if(i!=n-1)

{

System.out.println("Minimum spanning tree cannot be formed");

}

System.out.println("Minimum cost id:"+mincost);

}

public static boolean checkCycle(Edge e)

{

int u=e.u,v=e.v;

while(path[u]>0)

u=path[u];

while(path[v]>0)

v=path[v];

if(u!=v)

{

path[u]=v;

return true;

}

return false;

}

Reg No: 310114405010

static class Edge

{

int u,v,wt;

}

}

Reg No: 310114405010

OUTPUT:

Enter the no of vertices in graph: 4

Enter the no of edges in graph: 5

Enter 2 vertices and weight of the graph:

First vertex: 1

Second vertex: 2

Weight: 2

First vertex: 1

Second vertex: 3

Weight: 3

First vertex: 1

Second vertex: 4

Weight: 1

First vertex: 2

Second vertex: 4

Weight: 2

First vertex: 3

Second vertex: 4

Weight: 1

Edge (3,4) with weight 1 is selected



Minimum cost is: 4

Reg No: 310114405010

PROGRAM:

import java.util.*;

class Graph

{

int g[][];

int v,e;

int d[],p[],visited[];

void createGraph()

{

int a,b,w;

Scanner s=new Scanner(System.in);

System.out.println("Enter the no of vertices:");

v=s.nextInt();

System.out.println("Enter the no of edges:");

e=s.nextInt();

g=new int[v+1][v+1];

for(int i=1;i<=v;i++)

for(int j=1;j<=v;j++)

g[i][j]=0;

for(int i=1;i<=e;i++)

{

System.out.println("Enter edge information");

a=s.nextInt();

b=s.nextInt();

System.out.println("Enter the weight of this edge:");

w=s.nextInt();

g[a][b]=g[b][a]=w;

}

}

void callPrim()

{

visited=new int[v+1];

d=new int[v+1];

p=new int[v+1];


p[i]=visited[i]=0;


d[i]=32767;

prim();

}

Reg No: 310114405010

void prim()

{

int c=1,current=1,mincost=0;

visited[current]=1;

d[current]=0;

while(c!=v)

{


{

if(g[current][i]!=0&&visited[i]!=1)

if(g[current][i]<d[i])

{

d[i]=g[current][i];

p[i]=current;

}

}

int min=32767;


{

if(visited[i]!=1&&d[i]<min)

{

min=d[i];

current=i;

}

}

visited[current]=1;

c=c+1;

}


mincost+=d[i];

System.out.println("minimum cost:"+mincost);

}

}

public class Prim

{

public static void main(String args[])

{

Graph g=new Graph();

g.createGraph();

g.callPrim();

}}

Reg No: 310114405010

OUTPUT:


Enter the no of edges: 9

Enter edge information:

1

2

Enter the weight of this edge:

1


2

4


15


4

5


6


5

3


6


3

1


10


6

1


2


6

2


2


6

Reg No: 310114405010

5


4


6

4


8

Minimum cost: 19

Reg No: 310114405010

PROGRAM:

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=i;j<n;j++)

{

if(i!=j)

{

System.out.print("Enter weight of "+(i+1)+" to "+(j+1)+":=>");

weight[i][j]=s.nextInt();

weight[j][i]=weight[i][j];

}

}

}

System.out.println("Starting node assumed to be node 1.");

eval();

}

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++)

{

Reg No: 310114405010

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()

{

int dummySet[]=new int[n-1];


dummySet[i-1]=i;

finalCost=COST(0,dummySet,n-1);

Reg No: 310114405010

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[i-1],nextSet,setSize);


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();

}}

Reg No: 310114405010

OUTPUT:

Enter no of nodes:

4

Enter weight of 1 to 2:=>2






Starting node assumed to be 1

The tour is 1-2-3-4-1

Final cost: 7

Reg No: 310114405010

PROGRAM:

import java.io.*;

class knapo

{

void knapsack(int w[],int p[],int n,int m)

{

int s[][]=new int[n+1][m+1];

for(int wt=0;wt<=m;wt++)

s[0][wt]=0;

for(int i=0;i<=n;i++)

s[i][0]=0;


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

{

if(w[i]<=j)

{

if((p[i]+s[i-1][j-w[i]])>s[i-1][j])

s[i][j]=p[i]+s[i-1][j-w[i]];

else

s[i][j]=s[i-1][j];

}

else

s[i][j]=s[i-1][j];

}

knapsack_items(s,n,m,w,p);

}

void knapsack_items(int s[][],int n,int m,int w[],int p[])

{

int ans[]=new int[n+1];

int i=n;

int k=m;

int profit=0;

while(i>0&&k>0)

{

if(s[i][k]!=s[i-1][k])

{

ans[i]=1;

profit+=p[i];

k=k-w[i];

}

Reg No: 310114405010

i--;

}

System.out.println("values of the element");

for(i=1;i<=n;i++)

System.out.println("Element"+i+":"+ans[i]);

System.out.println("profit="+profit);

}

}

class knapmain

{


{

knapo ob=new knapo();

BufferedReader obj=new BufferedReader(new InputStreamReader(System.in));

System.out.print("How many object");

int n=Integer.parseInt(obj.readLine());

System.out.print("enter the capacity of the bag");

int m=Integer.parseInt(obj.readLine());

int p[],w[];

p=new int[n+1];

w=new int[m+1];

System.out.println("enter the profit and weight");


{

System.out.print("P"+i+":");

p[i]=Integer.parseInt(obj.readLine());

System.out.print("W"+i+":");

w[i]=Integer.parseInt(obj.readLine());


}

ob.knapsack(w,p,n,m);

}

}

Reg No: 310114405010

OUTPUT:

How many object?

3

Enter the capacity of the bag:10

Enter the profit and weight

P1: 2

W1: 3

P2: 4

W2: 5

P3: 6

W3: 8

Values of the element

Element 1: 1

Element 2: 1

Element 3: 0

Profit: 6

Reg No: 310114405010

PROGRAM:

import java.io.*;

import java.util.*;

public class Queens

{

public static boolean isConsistent(int [] q,int n)

{


{

if(q[i]==q[n])

return false;

if((q[i]-q[n])==(n-i))

return false;

if((q[n]-q[i])==(n-i))

return false;

}

return true;

}

public static void printQueens(int[] q)

{

int N=q.length;

for(int i=0;i<N;i++)

{

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

{

if(q[i]==j)

System.out.print("Q");

else

System.out.print("* ");

}


}


}

public static void enumerate(int N)

{

int[] a=new int[N];

enumerate(a,0);

}

public static void enumerate(int[] q,int n)

Reg No: 310114405010

{

int N=q.length;

if(n==N)

printQueens(q);

else

{

for(int i=0;i<N;i++)

{

q[n]=i;

if(isConsistent(q,n))

enumerate(q,n+1);

}

}

}


{

Scanner S=new Scanner(System.in);

System.out.print("Enter the no of Queens:");

int N=S.nextInt();

enumerate(N);

}

}

Reg No: 310114405010

OUTPUT:

Enter the no of Queens:4

*Q**

***Q

Q***

**Q*

**Q*

Q***

***Q

*Q**

Reg No: 310114405010

PROGRAM:

import java.io.*;

public class GraphColoring

{

static int G[][];

static int x[];

static int n,m;

static boolean found=false;

public static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));


{

System.out.println("\t\t\t\tGRAPH COLORING");

System.out.print("Enter the no of vertices:");


G=new int[n+1][n+1];

x=new int[n+1];

System.out.println("if edge b/w the foll vertices enter 1 else enter 0:\n");


{

for(int j=1;j<=n;j++)

{

if((i!=j)&&(i<j))

{

System.out.print(i+" and "+j+":");

G[i][j]=G[j][i]=Integer.parseInt(br.readLine());

}

if(i==j)

G[i][j]=0;

}

}

System.out.println("Enter the no of colors available:");

m=Integer.parseInt(br.readLine());

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

mColoring(1);

if(found==false)

System.out.println("Noo solution possible:");

}

static void mColoring(int k)

{

while(true)

Reg No: 310114405010

{

nextValue(k);

if(x[k]==0)

return;

if(k==n)

{

for(int i=1;i<=k;i++)

System.out.print(x[i]+" ");


found=true;

return;

}

else

mColoring(k+1);

}

}

static void nextValue(int k)

{

int j;

while(true)

{

x[k]=(x[k]+1)%(m+1);

if(x[k]==0)

return;

for(j=1;j<=n;j++)

if((G[k][j]!=0)&&(x[k]==x[j]))

break;

if(j==n+1)

return;

}

}

}

Reg No: 310114405010

OUTPUT:


If edge between the foll vertices, enter 1 else enter 0:

1 and 2: 1

1 and 3: 1

1 and 4: 0

1 and 5: 1

2 and 3: 1

2 and 4: 0

2 and 5: 1

3 and 4: 1

3 and 5: 0

4 and 5: 1

Enter the no of colors available: 3

Solution:

1 2 3 1 3

1 3 2 1 2

2 1 3 1 3

2 3 1 2 1

3 1 2 1 2

3 2 1 2 1

Reg No: 310114405010

PROGRAM:

import java.util.*;

public class Quicksort

{

static void dispaly(int x[],int n)

{

int i;

System.out.println(" ");

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

{

System.out.println("\t"+x[i]);

}

System.out.println(" ");

}

static int partition(int x[],int lb,int ub)

{

int a,down,temp,up,pj;

a=x[lb];

up=ub;

down=lb;

while(down<up)

{

while(x[down]<=a&&down<up)

down=down+1;

while(x[up]>a)

up=up-1;

if(down<up)

{

temp=x[down];

x[down]=x[up];

x[up]=temp;

}

}

x[lb]=x[up];

x[up]=a;

pj=up;

return (pj);

}

static void quick(int a[],int lb,int ub)

{

Reg No: 310114405010

Stack s=new Stack();

s.push(lb);

s.push(ub);

while(!s.empty())

{

ub=(Integer)s.pop();

lb=(Integer)s.pop();

if(ub<=lb)

continue;

int i=partition(a,lb,ub);

if(i-lb>ub-i)

{

s.push(lb);

s.push(i-1);

}

s.push(i+1);

s.push(ub);

if(ub-i>=i-lb)

{

s.push(lb);

s.push(i-1);

}

}

}


{

int i,n=10;

int x[]=new int[10];

Scanner in=new Scanner(System.in);

System.out.println("Enter the 10 elementes to be sorted:");

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

x[i]=in.nextInt();

quick(x,0,n-1);

System.out.println("The sorted elements are:");

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

System.out.print(x[i]+" ");

}

}

Reg No: 310114405010

OUTPUT:

Enter 10 elements to sort:

10 9 8 7 6 5 4 3 2 1

The sorted elements are:

1 2 3 4 5 6 7 8 9 10

Reg No: 310114405010

PROGRAM:

import java.util.LinkedList;

import java.util.ListIterator;

import java.util.Scanner;

public class ConcurrentList

{


{

LinkedList ll=new LinkedList();

System.out.println("Enter the element to push(max sixe=5)");

Scanner scan=new Scanner(System.in);

int scaninput[]=new int[10];

for(int i=0;i<5;i++)

ll.add(scan.nextInt());

for(int p=0;p<5;p++)

System.out.println("Element in["+p+"] index:"+ll.get(p));

ll.addFirst("0");

System.out.println("After inserting 0 at the beginning, the linked list contains\n:"+ll);

ll.add(2,"2.5");

System.out.println("After inserting 2.5 in the second index, the linked list contains\n:"+ll);

ll.addLast("6");

System.out.println("After inserting 6 an the end, the linked list contains\n:"+ll);

ListIterator itr=ll.listIterator();

System.out.println("Iterating the elements of linked ilst in forward direction");

while(itr.hasNext())

System.out.println(itr.next());

System.out.println("Iterating the elements of Linked List in reverse direction:");

while(itr.hasPrevious())

System.out.println(itr.previous());

System.out.println("deleting the element which is not on the list:");

boolean isRemoved=ll.remove("50");

System.out.println("Is 50 removed from the list?:"+isRemoved);

System.out.println("Now the linked list contains:"+ll);

Object obj=ll.remove(2);

System.out.println(obj+"has been removed from linket list");

System.out.print("After clearing the linked list:");

ll.clear();

System.out.println("Linked list contains:"+ll);

}

}

Reg No: 310114405010

OUTPUT:

Enter the element u want to insert (max size=5)

1 2 3 4 5

Element in [0] index: 1





After inserting 0 at the beginning, the linked list contains: [0, 1, 2, 3, 4, 5]

After inserting 2.5in the second index, the linked list contains: [0, 1, 2.5, 2, 3, 4, 5]

After inserting 6 at the end, the linked list contains: [0, 1, 2.5, 2, 3, 4, 5, 6]

Iterating the elements of the linked list in forward direction:

0

1

2.5

2

3

4

5

6

Iterating the elements of the linked list in reverse direction:

6

5

4

3

2

2.5

1

0

Deleting the element which is not in the list:

Is 50 removed from the list?: false

Now linked list contains: [0, 1, 2.5, 2, 3, 4, 5, 6]

2.5 has been removed from the lined list

After clearing the linked list:

Lined list contains: []

Reg No: 310114405010

PROGRAM:

import java.io.DataInputStream;

import java.io.IOException;


class QueueNext

{

int arr[],size;

public QueueNext(int maxsize)

{

size=maxsize;

this.arr=new int[maxsize];

}

int front=-1;

int rear=0;

public void enqueue(int data)

{

this.arr[rear]=data;

rear=rear+1;

}

public int dequeue()

{

front=front+1;

if(front==0)

return -1;

return this.arr[front];

}

public int queueSize()

{

return size;

}

}

class QueueOperation implements Runnable

{

int size;

QueueNext myqueue;

String name;

int option;

int input[];

public QueueOperation(QueueNext que,String name,int option,int input[])

{

Reg No: 310114405010

this.myqueue=que;

this.name=name;

this.option=option;

if(option==1)

this.input=input;

}

public void run()

{

synchronized(myqueue)

{

if(option==1)

enqueue();

else

dequeue();

}

}

public void enqueue()

{

System.out.println("***********************************************");

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

{

myqueue.enqueue(input[i]);

System.out.println("Enqueue(insert) input to the "+name+":"+input[i]);

}

}

public void dequeue()

{

int data,count=0;

System.out.println("************************************************");

while(count<myqueue.size)

{

data=myqueue.dequeue();

if(data!=-1)

System.out.println("Dequeue(delete) input from the "+name+":"+data);

count++;

}

}

}

public class ConcurrentQueue

{


Reg No: 310114405010

{

int queuesize=5;

DataInputStream get=new DataInputStream(System.in);

int ch;

System.out.println("Enter the elements you want to enqueue(max size=5): ");



int input2[]=new int[5];


{

scaninput[i]=scan.nextInt();

}


{

System.out.println("Element in the ["+p+"] index is:"+scaninput[p]);

}

QueueNext que1=new QueueNext(queuesize);

QueueOperation stop=new QueueOperation(que1,"Concurrent Queue",1,scaninput);

QueueOperation stop1=new QueueOperation(que1,"Concurrent Queue 1",0,scaninput);

Thread t=new Thread(stop);

Thread t1=new Thread(stop1);

t.start();

t1.start();

}

}

Reg No: 310114405010

OUTPUT:

Enter the elements you want to insert (mx size=5):

1 2 3 4 5

Element in the [0] index: 1





***************************************************

Enqueue(insert) input to the Concurrent Queue: 1





***************************************************

After dequeue(delete),front element from the Concurrent Queue1: 2




Reg No: 310114405010

PROGRAM:



class StackNext

{

int arr[],size;

public StackNext(int maxsize)

{

size=maxsize;


}

int top=0;

public void push(int data)

{

this.arr[top]=data;

top=top+1;

}

public int pop()

{

if(top==0)

return -1;

top=top-1;

return this.arr[top];

}

public int stacksize()

{

return size;

}

}

class StackOperation implements Runnable

{

int size;

StackNext mystack;

String name;

int option;

int input[];

public StackOperation(StackNext stk,String name,int option,int input[])

{

this.mystack=stk;

this.name=name;

Reg No: 310114405010

this.option=option;

if(option==1)

this.input=input;

}

public void run()

{

synchronized(mystack)

{

if(option==1)

pushData();

else

popData();

}

}

public void pushData()

{


{

mystack.push(input[i]);

System.out.println("Stack====>"+name+"push input====>"+input[i]);

}

}

public void popData()

{

int data,count=0;

while(count<mystack.size)

{

data=mystack.pop();

if(data!=-1)

{

System.out.println("Stack===>"+name+"pop out===>"+data);

count++;

}

}

}

}

public class ConcurrentStack

{


{

int stacksize=10;

Reg No: 310114405010

int input[]={1,2,3,4,5,6,7,8,9,10};

int input1[]={1,2,3,4,5};

int input2[]={6,7,8,9,10};


int ch;

System.out.println("Enter the element u want to push=max size=10");




{


}


{

System.out.println("This is "+p+"th element that you entered "+scaninput[p]);

}

StackNext stk1=new StackNext(stacksize);

StackOperation stop=new StackOperation(stk1,"TestStack",1,scaninput);

StackOperation stop1=new StackOperation(stk1,"TestStack1",0,input2);



t.start();

t1.start();

}

}

Reg No: 310114405010

OUTPUT:

Enter the element you want to push (max size=10):

1 2 3 4 5 6 7 8 9 10

0 th element that you entered: 1










Stack --> TestStack push input--->1










Stack --> TestStack1 pop output--->10

Stack --> TestStack1pop output--->9









Reg No: 310114405010

PROGRAM:


import java.io.IOException;


class QueueNext

{

int arr[],size;

public QueueNext(int maxsize)

{

size=maxsize;


}

int front=-1;

int rear=0;

public void enqueue(int data)

{

this.arr[rear]=data;

rear=rear+1;

}

public int dequeue()

{

front=front+1;

if(front==0)

return -1;

return this.arr[front];

}

public int queueSize()

{

return size;

}

}

class QueueOperation implements Runnable

{

int size;

QueueNext myqueue;

String name;

int option;

int input[];

public QueueOperation(QueueNext que,String name,int option,int input[])

{

Reg No: 310114405010

this.myqueue=que;

this.name=name;

this.option=option;

if(option==1)

this.input=input;

}

public void run()

{

synchronized(myqueue)

{

if(option==1)

enqueue();

else

dequeue();

}

}

public void enqueue()

{

System.out.println("***************************************************");


{

myqueue.enqueue(input[i]);

System.out.println("queue=====>"+name+"enqueue input====>:"+input[i]);

}

}

public void dequeue()

{

int data,count=0;

System.out.println("***************************************************");

while(count<myqueue.size)

{

data=myqueue.dequeue();

if(data!=-1)

System.out.println("queue=====>"+name+"dequeue output=====>:"+data);

count++;

}

}

}

public class QueueThread

{


Reg No: 310114405010

{

int queuesize=10;


int ch;

System.out.println("Enter the elements you want to enqueue=max size 10:");



int input2[]=new int[10];


{


}


{

System.out.println("This is ["+p+"]th element that u have enetered:"+scaninput[p]);

}

QueueNext que1=new QueueNext(queuesize);

QueueOperation stop=new QueueOperation(que1,"Test Queue",1,scaninput);

QueueOperation stop1=new QueueOperation(que1,"Test Queue 1",0,input2);



t.start();

t1.start();

}

}

Reg No: 310114405010

OUTPUT:

Enter the elements you want to enqueue (max size=10):

1 2 3 4 5 6 7 8 9 10











Queue--> TestQueue enqueue input--->1

Queue--> TestQueue enqueue input--->2

Queue --> TestQueue enqueue input--->3








Queue --> TestQueue1 dequeue output--->1










DS REC Rajkumar

Documents

Transcript of DS REC Rajkumar