CODING :

import [Link].*;

public class Quicksort

public static void main(String []args)

int[]arr={5,2,8,3,1,6,4};

int n=[Link];

long start=[Link]();

quicksort(arr,0,n-1);

long end=[Link]();

[Link]("Sorted Array:"+[Link](arr));

[Link]("Time taken:"+(end-start)+"milliseconds");

public static void quicksort(int[]arr,int low,int high)

if(low<high)

int pi=partition(arr,low,high);

quicksort(arr,low,pi-1);

quicksort(arr,pi+1,high);

public static int partition(int[]arr,int low,int high)

int pivot=arr[high];

int i=(low-1);

for(int j=low;j<high;j++)

{
if(arr[j]<= pivot)

i++;

int temp=arr[i];

arr[i]=arr[j];

arr[j]=temp;

int temp=arr[i+1];

arr[i+1]=arr[high];

arr[high]=temp;

return i+1;

OUTPUT :

Sorted Array:[1, 2, 3, 4, 5, 6, 8]

Time taken:0milliseconds
CODING :

import [Link].*;

public class Mergesort

public static void main(String args[])

int[] arr = {5, 2, 8, 3, 1, 6, 4};

int n = [Link];

long start = [Link]();

mergesort(arr, 0, n - 1);

long end = [Link]();

[Link]("***********************");

[Link]("Sorted array: " + [Link](arr));

[Link]("Time taken: " + (end - start) + " milliseconds");

[Link]("***********************");

public static void mergesort(int[] arr, int low, int high)

if (low < high)

int mid = (low + high) / 2;

mergesort(arr, low, mid);

mergesort(arr, mid + 1, high);

merge(arr, low, mid, high);

public static void merge(int[] arr, int low, int mid, int high)

int[] left = [Link](arr, low, mid + 1);

int[] right = [Link](arr, mid + 1, high + 1);

int i = 0, j = 0, k = low;

while (i<[Link]&& j <[Link])

if (left[i] <= right[j])

arr[k] = left[i];

i++;

else

arr[k] = right[j]; // Fixed the typo here (was 'rigth')

j++;

k++;

while (i<[Link])

arr[k] = left[i];

i++;

k++;

while (j <[Link])

arr[k] = right[j];

j++;

k++;

}}}
OUTPUT :

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

Sorted array: [1, 2, 3, 4, 5, 6, 8]

Time taken: 0 milliseconds

***********************
CODING :

import [Link].*;

public class Knapsack

public static int knapsack(int[]v,int[]w,int c)

int n=[Link];

int[][] dp=new int[n+1][c+1];

for(int i=1;i&amp;lt;=n;i++)

for(int j=1;j&amp;lt;=c;j++)

if(w[i-1]&amp;lt;=j)

dp[i][j]=[Link](dp[i-1][j],v[i-1]+dp[i-1][j-w[i-1]]);

else

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

return dp[n][c];

public static void main(String[] args)

int[]v={60,100,120};

int[]w={10,20,30};

int c=50;
int maxValue=knapsack(v,w,c);

[Link](&amp;quot;Maximum value in KnapSack:&amp;quot;+maxValue);

OUTPUT:

Maximum value in KnapSack:220

CODING :
import [Link].*;

class Graph {

int V;

List<List<Edge>> adj;

int[] dist;

boolean[] visited;

Graph(int V) {

this.V = V;

adj = new ArrayList<>(V);

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

[Link](new ArrayList<>());

dist = new int[V];

visited = new boolean[V];

[Link](dist, Integer.MAX_VALUE);

void addEdge(int u, int v, int weight) {

[Link](u).add(new Edge(v, weight));

void dijkstra(int src) {

dist[src] = 0;

PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> {

if (dist[a] == dist[b]) {

return a - b;

} else {

return [Link](dist[a], dist[b]);

});

[Link](src);

while (![Link]()) {
int u = [Link]();

if (visited[u])

continue;

visited[u] = true;

for (Edge e : [Link](u)) {

int v = e.v;

int weight = [Link];

if (!visited[v] && (dist[v] == Integer.MAX_VALUE || dist[u] + weight <

dist[v])) {

dist[v] = dist[u] + weight;

[Link](v);

[Link]("\nShortest paths from node " + src + ":");

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

[Link]("Node " + i + ": " + dist[i]);

[Link]("Shortest path from node " + src + " to node 4: " +

dist[4]);

class Edge {

int v, weight;

Edge(int v, int weight) {

this.v = v;

[Link] = weight;

}
}

public class Main{

public static void main(String[] args) {

Graph g = new Graph(5);

[Link](0, 1, 2);

[Link](0, 2, 4);

[Link](1, 2, 1);

[Link](1, 3, 7);

[Link](2, 4, 3);

[Link](3, 4, 2);

[Link](0);

OUTPUT :

Shortest paths from node 0:

Node 0: 0

Node 1: 2

Node 2: 3

Node 3: 9

Node 4: 6

Shortest path from node 0 to node 4: 6

CODING :

class Node
{

int value;

Node left,right;

public Node(int value)

[Link]=value;

left=right=null;

public class BinaryTreeTraversal

void inOrder(Node node)

if(node==null)

return;

inOrder([Link]);

[Link]([Link]+"");

inOrder([Link]);

void preOrder(Node node)

if(node==null)

return;

preOrder([Link]);

preOrder([Link]);

[Link]([Link]+"");

void postOrder(Node node)

{
if(node==null)

return;

postOrder([Link]);

postOrder([Link]);

[Link]([Link]+"");

public static void main(String[] args)

BinaryTreeTraversal tree=new BinaryTreeTraversal();

Node root=new Node(1);

[Link]=new Node(2);

[Link]=new Node(3);

[Link]=new Node(4);

[Link]=new Node(5);

[Link]("In-order traversal:");

[Link](root);

[Link]("\n pre-order traversal:");

[Link](root);

[Link]("\n post-order traversal:");

[Link](root);

OUTPUT :
In-order traversal:

42513

pre-order traversal:

45231

post-order traversal:

45231

CODING :
import [Link].*;

import [Link].*;

class Edge

int destination;

int weight;

public Edge(int destination, int weight)

[Link] = destination;

[Link] = weight;

public class PrimMST

public static void primMST(List<List<Edge>> graph)

int vertices = [Link]();

int[] minWeight = new int[vertices];

boolean[] inMST = new boolean[vertices];

int[] parent = new int[vertices];

[Link](minWeight, Integer.MAX_VALUE);

minWeight[0] = 0;

parent[0] = -1;

PriorityQueue<int[]> pq = new PriorityQueue<>([Link](a -> a[1]));

[Link](new int[]{0, 0});

while (![Link]())

int[] nodeInfo = [Link]();

int node = nodeInfo[0];

if (inMST[node])

continue;

inMST[node] = true;

for (Edge edge : [Link](node))

if (!inMST[[Link]] && [Link] <

minWeight[[Link]])

minWeight[[Link]] = [Link];

parent[[Link]] = node;

[Link](new int[]{[Link], minWeight[[Link]]});

[Link]("Edge \tWeight");

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

[Link](parent[i] + " -- " + i + "\t" + minWeight[i]);

public static void main(String[] args)

int vertices = 5;

List<List<Edge>> graph = new ArrayList<>();

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

[Link](new ArrayList<>());

[Link](0).add(new Edge(1, 2));

[Link](0).add(new Edge(3, 6));

[Link](1).add(new Edge(0, 2));

[Link](1).add(new Edge(2, 3));

[Link](1).add(new Edge(3, 8));

[Link](1).add(new Edge(4, 5));

[Link](2).add(new Edge(1, 3));

[Link](2).add(new Edge(4, 7));

[Link](3).add(new Edge(0, 6));

[Link](3).add(new Edge(1, 8));

[Link](4).add(new Edge(1, 5));

[Link](4).add(new Edge(2, 7));

primMST(graph);

OUTPUT :

Edge Weight

0 -- 1 2

1 -- 2 3

0 -- 3 6

1 -- 4 5
CODING :

public class NQueens

private static boolean isSafe(int[][] board, int row, int col, int n)

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

if (board[row][i] == 1)

return false;

for (int i = row, j = col; i >= 0 && j >= 0; i--, j--)

if (board[i][j] == 1)

return false;

for (int i = row, j = col; i < n && j >= 0; i++, j--)

if (board[i][j] == 1)

return false;

return true;

private static boolean solveNQueens(int[][] board, int col, int n)

{

if (col >= n)

return true;

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

if (isSafe(board, i, col, n))

board[i][col] = 1;

if (solveNQueens(board, col + 1, n))

return true;

board[i][col] = 0;

return false;

private static void printSolution(int[][] board, int n)

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

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

[Link](board[i][j] + " ");

[Link]();

}
}

public static void main(String[] args)

int n = 8;

int[][] board = new int[n][n];

if (solveNQueens(board, 0, n))

printSolution(board, n);

else

[Link]("Solution does not exist.");

OUTPUT :

10000000

00000010

00001000

00000001

01000000

00010000

00000100

00100000