1.

Merge sort using divide and conquer

/* Java program for Merge Sort */
class MergeSort
{
    // Merges two subarrays of arr[].
    // First subarray is arr[l..m]
    // Second subarray is arr[m+1..r]
    void merge(int arr[], int l, int m, int r)
    {
        // Find sizes of two subarrays to be merged
        int n1 = m - l + 1;
        int n2 = r - m;
  
        /* Create temp arrays */
        int L[] = new int [n1];
        int R[] = new int [n2];
  
        /*Copy data to temp arrays*/
        for (int i=0; i<n1; ++i)
            L[i] = arr[l + i];
        for (int j=0; j<n2; ++j)
            R[j] = arr[m + 1+ j];
  
  
        /* Merge the temp arrays */
  
        // Initial indexes of first and second subarrays
        int i = 0, j = 0;
  
        // Initial index of merged subarry array
        int k = l;
        while (i < n1 && j < n2)
        {
            if (L[i] <= R[j])
            {
                arr[k] = L[i];
                i++;
            }
            else
            {
                arr[k] = R[j];
                j++;
            }
            k++;
        }
  
        /* Copy remaining elements of L[] if any */
        while (i < n1)
        {
            arr[k] = L[i];
            i++;
            k++;
        }
  
        /* Copy remaining elements of R[] if any */
        while (j < n2)
        {
            arr[k] = R[j];
            j++;
            k++;
        }
    }
  
    // Main function that sorts arr[l..r] using
    // merge()
    void sort(int arr[], int l, int r)
    {
        if (l < r)
        {
            // Find the middle point
            int m = (l+r)/2;
  
            // Sort first and second halves
            sort(arr, l, m);
            sort(arr , m+1, r);
  
            // Merge the sorted halves
            merge(arr, l, m, r);
        }
    }
  
    /* A utility function to print array of size n */
    static void printArray(int arr[])
    {
        int n = arr.length;
        for (int i=0; i<n; ++i)
            System.out.print(arr[i] + " ");
        System.out.println();
    }
  
    // Driver method
    public static void main(String args[])
    {
        int arr[] = {12, 11, 13, 5, 6, 7};
  
        System.out.println("Given Array");
        printArray(arr);
  
        MergeSort ob = new MergeSort();
        ob.sort(arr, 0, arr.length-1);
  
        System.out.println("\nSorted array");
        printArray(arr);
    }
}

2.Binary search using divide and conquer

// Java implementation of iterative Binary Search
class BinarySearch {
    // Returns index of x if it is present in arr[],
    // else return -1
    int binarySearch(int arr[], int x)
    {
        int l = 0, r = arr.length - 1;
        while (l <= r) {
            int m = l + (r - l) / 2;
  
            // Check if x is present at mid
            if (arr[m] == x)
                return m;
  
            // If x greater, ignore left half
            if (arr[m] < x)
                l = m + 1;
  
            // If x is smaller, ignore right half
            else
                r = m - 1;
        }
  
        // if we reach here, then element was
        // not present
        return -1;
    }
  
    // Driver method to test above
    public static void main(String args[])
    {
        BinarySearch ob = new BinarySearch();
        int arr[] = { 2, 3, 4, 10, 40 };
        int n = arr.length;
        int x = 10;
        int result = ob.binarySearch(arr, x);
        if (result == -1)
            System.out.println("Element not present");
        else
            System.out.println("Element found at "
                               + "index " + result);
    }
}

3. Prim's algorithm using greedy method

https://codispatch.blogspot.com/2015/12/java-program-implement-prims-minimum-spanning-
tree-algorithm.html

import java.util.*;

public class Prims

public int isVisited[] = new int[15];

public int cost[][] = new int[10][10];

public int minimum_cost;

public void calc(int n)

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

int i,j,min=999,num_edges=1,a=1,b=1,minpos_i=1,minpos_j=1;
 while(num_edges < n)

for(i=1,min=999;i<=n;i++)

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

if(this.cost[i][j]<min)

if(this.isVisited[i]!=0)

min=this.cost[i][j];

a=minpos_i=i;

b=minpos_j=j;

if(this.isVisited[minpos_i]==0 || this.isVisited[minpos_j]==0)

System.out.println("Edge Number \t"+num_edges+"\t from Vertex \t"+a+"\t to Vertex

\t"+b+"-mincost:"+min+" \n");

this.minimum_cost=this.minimum_cost+min;

num_edges=num_edges+1;

this.isVisited[b]=1;

this.cost[a][b]=this.cost[b][a]=999;
}

public static void main(String args[])

int nodes,i,j;

Scanner in = new Scanner(System.in);

System.out.println("Enter the Number of Nodes \n");

nodes = in.nextInt();

Prims p = new Prims();

System.out.println("Enter the Cost Matrix Weights : \n");

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

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

p.cost[i][j]=in.nextInt();

if(p.cost[i][j]==0)

p.cost[i][j]=999;

p.isVisited[1]=1; // Initialization

p.calc(nodes);
 }

4.0/1 knapsack problem using dynamic programming

class Knapsack
{
  
    // A utility function that returns maximum of two integers
     static int max(int a, int b) { return (a > b)? a : b; }
       
     // Returns the maximum value that can be put in a knapsack of capacity W
     static int knapSack(int W, int wt[], int val[], int n)
     {
        // Base Case
    if (n == 0 || W == 0)
        return 0;
       
    // If weight of the nth item is more than Knapsack capacity W, then
    // this item cannot be included in the optimal solution
    if (wt[n-1] > W)
       return knapSack(W, wt, val, n-1);
       
    // Return the maximum of two cases: 
    // (1) nth item included 
    // (2) not included
    else return max( val[n-1] + knapSack(W-wt[n-1], wt, val, n-1),
                     knapSack(W, wt, val, n-1)
                      );
      }
  
    
   // Driver program to test above function
   public static void main(String args[])
   {
        int val[] = new int[]{60, 100, 120};
        int wt[] = new int[]{10, 20, 30};
    int  W = 50;
    int n = val.length;
    System.out.println(knapSack(W, wt, val, n));
    }
}
/*This code is contributed by Rajat Mishra */
5.Depth First Search

/ Java program to print DFS traversal from a given given graph

import java.io.*;
import java.util.*;
  
// This class represents a directed graph using adjacency list
// representation
class Graph
{
    private int V;   // No. of vertices
  
    // Array  of lists for Adjacency List Representation
    private LinkedList<Integer> adj[];
  
    // Constructor
    Graph(int v)
    {
        V = v;
        adj = new LinkedList[v];
        for (int i=0; i<v; ++i)
            adj[i] = new LinkedList();
    }
  
    //Function to add an edge into the graph
    void addEdge(int v, int w)
    {
        adj[v].add(w);  // Add w to v's list.
    }
  
    // A function used by DFS
    void DFSUtil(int v,boolean visited[])
    {
        // Mark the current node as visited and print it
        visited[v] = true;
        System.out.print(v+" ");
  
        // Recur for all the vertices adjacent to this vertex
        Iterator<Integer> i = adj[v].listIterator();
        while (i.hasNext())
        {
            int n = i.next();
            if (!visited[n])
                DFSUtil(n, visited);
        }
    }
  
    // The function to do DFS traversal. It uses recursive DFSUtil()
    void DFS(int v)
    {
        // Mark all the vertices as not visited(set as
        // false by default in java)
        boolean visited[] = new boolean[V];
  
        // Call the recursive helper function to print DFS traversal
        DFSUtil(v, visited);
    }
  
    public static void main(String args[])
    {
        Graph g = new Graph(4);
  
        g.addEdge(0, 1);
        g.addEdge(0, 2);
        g.addEdge(1, 2);
        g.addEdge(2, 0);
        g.addEdge(2, 3);
        g.addEdge(3, 3);
  
        System.out.println("Following is Depth First Traversal "+
                           "(starting from vertex 2)");
  
        g.DFS(2);
    }
}
// This code is contributed by Aakash Hasija

6. Cyclic Redundancy Check

import java.util.Scanner;
class CRC
{
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
int m,g[],n,d[],z[],r[],msb,i,j,k;
System.out.print(“Enter no. of data bits : “);
n=sc.nextInt();
System.out.print(“Enter no. of generator bits : “);
m=sc.nextInt();
d=new int[n+m];
g=new int[m];
System.out.print(“Enter data bits : “);
for(i=0;i<n;i++)
d[i]=sc.nextInt();
System.out.print(“Enter generator bits : “);
for(j=0;j<m;j++)
g[j]=sc.nextInt();
for(i=0;i<m-1;i++)
d[n+i]=0;
r=new int[m+n];
for(i=0;i<m;i++)
r[i]=d[i];
z=new int[m];
for(i=0;i<m;i++)
z[i]=0;
for(i=0;i<n;i++)
{
k=0;
msb=r[i];
for(j=i;j<m+i;j++)
{
if(msb==0)
r[j]=xor(r[j],z[k]);
else
r[j]=xor(r[j],g[k]);
k++;
}
r[m+i]=d[m+i];
}
System.out.print(“The code bits added are : “);
for(i=n;i<n+m-1;i++)
{
d[i]=r[i];
System.out.print(d[i]);
}
System.out.print(“\nThe code data is : “);
for(i=0;i<n+m-1;i++)
{
System.out.print(d[i]);
}
}
public static int xor(int x,int y)
{
if(x==y)
return(0);
else
return(1);
}
}

/*Output of crc cyclic redundancy check program:

Enter no. of data bits : 14
Enter no. of generator bits : 4
Enter data bits : 1
1
0
1
0
0
1
1
1
0
1
1
0
0

Enter generator bits :

1
0
1
1

The code bits added are : 100

The code data is : 11010011101100100

*/

7.Dijkstra's algorithm
import java.util.Scanner; //Scanner Function to take in the Input Values
  
public class Dijkstra
{
    static Scanner scan; // scan is a Scanner Object
  
    public static void main(String[] args)
    {
        int[] preD = new int[5];
        int min = 999, nextNode = 0; // min holds the minimum value, nextNode holds the value
for the next node.
        scan = new Scanner(System.in);
        int[] distance = new int[5]; // the distance matrix
        int[][] matrix = new int[5][5]; // the actual matrix
        int[] visited = new int[5]; // the visited array
  
        System.out.println("Enter the cost matrix");
  
        for (int i = 0; i < distance.length; i++)
        {
            visited[i] = 0; //initialize visited array to zeros
            preD[i] = 0;
  
            for (int j = 0; j < distance.length; j++)
            {
                matrix[i][j] = scan.nextInt(); //fill the matrix
                if (matrix[i][j]==0)
                    matrix[i][j] = 999; // make the zeros as 999
            }
        }
  
        distance = matrix[0]; //initialize the distance array
        visited[0] = 1; //set the source node as visited
        distance[0] = 0; //set the distance from source to source to zero which is the starting
point
  
        for (int counter = 0; counter < 5; counter++)
        {
            min = 999;
            for (int i = 0; i < 5; i++)
            {
                if (min > distance[i] && visited[i]!=1)
                {
                    min = distance[i];
                    nextNode = i;
                }
            }
  
            visited[nextNode] = 1;
            for (int i = 0; i < 5; i++)
            {
                if (visited[i]!=1)
                {
                    if (min+matrix[nextNode][i] < distance[i])
                    {
                        distance[i] = min+matrix[nextNode][i];
                        preD[i] = nextNode;
                    }
  
                }
  
            }
  
        }
  
        for(int i = 0; i < 5; i++)
            System.out.print("|" + distance[i]);
  
        System.out.println("|");
  
        int j;
        for (int i = 0; i < 5; i++)
        {
            if (i!=0)
            {
  
                System.out.print("Path = " + i);
                j = i;
                do
                {
                    j = preD[j];
                    System.out.print(" <- " + j);
                }
                while(j != 0);
            }
            System.out.println();
        }
    }
}

8.Distance vector routing algorithm

http://campuscoke.blogspot.com/2015/01/distance-vector-
routing-dvr-algorithm.html

import java.io.*;
public class DVR
{
static int graph[][];
static int via[][];
static int rt[][];
static int v;
static int e;

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

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

System.out.println("Please enter the number of Vertices: ");

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

System.out.println("Please enter the number of Edges: ");

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

graph = new int[v][v];

via = new int[v][v];
rt = new int[v][v];
for(int i = 0; i < v; i++)
for(int j = 0; j < v; j++)
{
if(i == j)
graph[i][j] = 0;
else
graph[i][j] = 9999;
}

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

{
System.out.println("Please enter data for Edge " + (i + 1) + ":");
System.out.print("Source: ");
int s = Integer.parseInt(br.readLine());
s--;
System.out.print("Destination: ");
int d = Integer.parseInt(br.readLine());
d--;
System.out.print("Cost: ");
int c = Integer.parseInt(br.readLine());
graph[s][d] = c;
graph[d][s] = c;
}

dvr_calc_disp("The initial Routing Tables are: ");

System.out.print("Please enter the Source Node for the edge whose cost has changed: ");
int s = Integer.parseInt(br.readLine());
s--;
System.out.print("Please enter the Destination Node for the edge whose cost has changed:
");
int d = Integer.parseInt(br.readLine());
d--;
System.out.print("Please enter the new cost: ");
int c = Integer.parseInt(br.readLine());
graph[s][d] = c;
graph[d][s] = c;

dvr_calc_disp("The new Routing Tables are: ");

}

static void dvr_calc_disp(String message)

{
System.out.println();
init_tables();
update_tables();
System.out.println(message);
print_tables();
System.out.println();
}

static void update_table(int source)

{
for(int i = 0; i < v; i++)
{
if(graph[source][i] != 9999)
{
int dist = graph[source][i];
for(int j = 0; j < v; j++)
{
int inter_dist = rt[i][j];
if(via[i][j] == source)
inter_dist = 9999;
if(dist + inter_dist < rt[source][j])
{
rt[source][j] = dist + inter_dist;
via[source][j] = i;
}
}
}
}
}

static void update_tables()

{
int k = 0;
for(int i = 0; i < 4*v; i++)
{
 update_table(k);
k++;
if(k == v)
k = 0;
}
}

static void init_tables()

{
for(int i = 0; i < v; i++)
{
for(int j = 0; j < v; j++)
{
if(i == j)
{
rt[i][j] = 0;
via[i][j] = i;
}
else
{
rt[i][j] = 9999;
via[i][j] = 100;
}
}
}
}

static void print_tables()

{
for(int i = 0; i < v; i++)
{
for(int j = 0; j < v; j++)
{
System.out.print("Dist: " + rt[i][j] + " ");
}
System.out.println();
}
}

}
output:-

Please enter the number of Vertices:

4
Please enter the number of Edges:
5
Please enter data for Edge 1:
Source: 1
Destination: 2
Cost: 1
Please enter data for Edge 2:
Source: 1
Destination: 3
Cost: 3
Please enter data for Edge 3:
Source: 2
Destination: 3
Cost: 1
Please enter data for Edge 4:
Source: 2
Destination: 4
Cost: 1
Please enter data for Edge 5:
Source: 3
Destination: 4
Cost: 4

The initial Routing Tables are:

Dist: 0 Dist: 1 Dist: 2 Dist: 2
Dist: 1 Dist: 0 Dist: 1 Dist: 1
Dist: 2 Dist: 1 Dist: 0 Dist: 2
Dist: 2 Dist: 1 Dist: 2 Dist: 0

Please enter the Source Node for the edge whose cost has changed: 2
Please enter the Destination Node for the edge whose cost has changed: 4
Please enter the new cost: 10

The new Routing Tables are:

Dist: 0 Dist: 1 Dist: 2 Dist: 6
Dist: 1 Dist: 0 Dist: 1 Dist: 5
Dist: 2 Dist: 1 Dist: 0 Dist: 4
Dist: 6 Dist: 5 Dist: 4 Dist: 0
--------------------------------

9. Link state routing

#include

#include

#define LIMIT 10
#define INFINITY 10000

int m,n,k,i,j,dist[LIMIT][LIMIT],sn,dn,min=0;

struct node { int hello[LIMIT],from,adj[LIMIT];

}node[LIMIT];

main()

clrscr();

printf("Enter how many nodes do u want::");

scanf("%d",&n);

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

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

dist[i][j]=-1; for(i=1;i<=n;i++)

printf("\nEnter distance for %d node:",i);

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

if(dist[i][j]==-1)

if(i==j)

dist[i][j]=0;

printf(" 0");

} else

scanf("%d",&m);

dist[i][j]=dist[j][i]=m;

Else

printf(" %d",dist[i][j]);

printf("\nDistance matrix is:");

for(i=1;i<=n;i++) { printf("\n");

node[i].from=0;
for(j=1;j<=n;j++)

printf("\t%d",dist[i][j]);

printf("\nSENDING HELLO PACKETS");

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

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

if(dist[i][j]>0)

node[i].from++;

if(dist[j][i]>0)

node[i].hello[k++]=j;

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

printf("\nHello packets to node %d:",i);

for(j=1;j<=node[i].from;j++)

printf("\n%d",node[i].hello[j]);

printf("\nSENDING ECHO PACKETS");

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

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

if(dist[i][j]>0)

printf("\nfrom %d to %d, the distance is:%d",i,j,dist[i][j]);

printf("\n CONSTRUCTION LINKSTATE PACKETS");

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

{
printf("\nLINK STATE PACKET FOR %d",i);

printf("\n|-------------|");

printf("\n| %d |",i);

printf("\n|-------------|");

printf("\n| seq |");

printf("\n|-------------|");

printf("\n| Age |");

printf("\n|-------------|");

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

if(dist[i][j]>0)

printf("\n| %d | %d |",j,dist[i][j]);

printf("\n|-------------|");

printf("\nDISTRIBUTING THE LINK STATE PACKETS");

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

printf("\nNeighbours for %d node are:",i);

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

if(dist[i][j]>0)

printf("%d",j);

for(j=1;j<=node[i].from;j++)

printf("\n the distance from %d to ",i);

printf("%d is %d",node[i].hello[j],dist[i][node[i].hello[j]]);

printf("\nCOMPUTING THE SHORTEST PATH");

printf("\nEnter source and destination:");

scanf("%d%d",&sn,&dn); min=spath(sn,dn,min);

printf("\n minimum distance:%d",min);

getch();

int spath(int s,int t,int min)

struct state

int pred; int len;

enum{permanent,tentative}label;

}state[LIMIT];

int i=1,k;

struct state *p;

for(p=&state[i];p<=&state[n];p++)

p->pred=0;

p->len=INFINITY;

p->label=tentative;

state[t].len=0;

state[t].label=permanent;

k=t;

do

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

if(dist[k][i]!=0 && state[i].label==tentative)

if(state[k].len+dist[k][i]

state[i].pred=k; state[i].len=state[k].len+dist[k][i];
}

k=0;

min=INFINITY;

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

if(state[i].label==tentative && state[i].len

min=state[i].len; k=i;

state[k].label=permanent;

while(k!=s);

return(min);

Domain Name system

importjava.net.*;
importjava.io.*;
importjava.util.*;

publicclassDNS 
{
publicstaticvoidmain(String[]args) 
{
int;
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
do
{
System.out.println("\n Menu:\n 1. DNS 2. Reverse DNS 3. Exit \n");
System.out.println("\nEnteryourchoice");
n=Integer.parseInt(System.console().readLine()); 
if(n==1)
{
try 
{
System.out.println("\nEnterHostName");
Stringname=in.readLine();
InetAddressaddress;
address=InetAddress.getByName(hname);
System.out.println("HostName“+address.getHostName());
System.out.println("IP:"+address.getHostAddress());
} 
catch(IOException ioe) 
{
ioe.printStackTrace();
}
}
if(n==2)
{
 try 
{

   System.out.println("\nEnterIPaddress");
   Stringipstr=in.readLine();
   InetAddressia=InetAddress.getByName(ipstr);
   System.out.println("IP:"+ipstr);
   System.out.println("HostName:"+ia.getHostName());
 } 
catch(IOException ioe) 
{
ioe.printStackTrace();
}
}
}while(!(n==3));
}
}