### Shortest Path from source to Vertex :- Dijkstra Algorithm

Shortest Path from source to Vertex :- Dijkstra Algorithm:-

Dijkstra Algorithms is an algorithm use to find the shortest path from source vertex to a given vertex.

```package Graph;

import java.util.HashMap;

abstract public class DirectedGraph {

Vertex[] vertexlist=new Vertex;
HashMap<Character,HashMap<Character,Integer>> edgelist=new HashMap<>();
Vertex vertex;
//count of vertex and edge
static int vertexcount=0;
int edgecount=0;
/*
* This function takes a label and insert in the vertex list as well as edge list since it is new vertex it will add
* null to its adjoining vertices
*/
{
vertex=new Vertex(label);
vertexlist[vertexcount]=vertex;
System.out.println(vertexlist[vertexcount].label);
edgelist.put(vertex.label, null);
vertexcount++;
return vertexcount;
}

{
HashMap<Character,Integer> vertexlist=new HashMap<>();
for(int i=0;i<labels.length;i++)
{
vertexlist.put(labels[i], distances[i]);
}
edgelist.put(label, vertexlist);
return edgecount;
}

int removeEdge(char labelfrom,char labelto)
{
edgelist.get(labelfrom).remove(labelto);
edgecount--;
return edgecount;
}

HashMap<Character,Integer> getNeighbours(char label)
{
return edgelist.get(label);
}

void listOfVertex()
{
System.out.println("Total Vertex:"+ vertexcount);

//This is how we traverse over a hashmap
for(Object key:edgelist.keySet())
{
System.out.println(key+" " +edgelist.get(key));
}

}
}
```

```package Graph;

import java.util.HashMap;
import java.util.Queue;
import java.util.Stack;

public class DirectedGraphImpl extends DirectedGraph {

//Algorithm to search the shortest path
public void djiksta(DirectedGraphImpl g)
{
//Creating new instance of grapg passed in parameter
DirectedGraphImpl newgraph=new DirectedGraphImpl();
newgraph=g;

/*
* Declaring hashmap for holding vertex value in character and distance from source in Integer
*/
HashMap<Character,Integer> map=new HashMap<>();
/*
* Declaring queue to iterate graph in BFS fashion
*/

//Initializing new instance of graph with vertex and distance as minimum value
for(int i=0;i<newgraph.vertexcount;i++)
{
map.put(vertexlist[i].label, Integer.MIN_VALUE);
}

while(!queue.isEmpty())
{
//checking vertex distance if it minimum distance make it as 0
if(map.get(queue.peek())==Integer.MIN_VALUE)
{
map.put(queue.peek(), 0);
}

//Storing previous vertex name
char previousvertex=queue.peek();

//Getting neigbours of previous vertex as well as removing the same from queue tail
HashMap<Character,Integer> neigbours=newgraph.getNeighbours(queue.remove());

//if neighbours are there
if(neigbours!=null)
{

//iterating over neighbours
for(Character key:neigbours.keySet())
{
//Adding neighbour in queue from front

/*
* checking condition if distance(new vertex from previous vertex)+distance(source to previous vertex)
* is less than what we have in able assign new distance to the table
*
*
* supose from A to B distance is 4
* from A to C distance is 1 and from C to A distance is 2 then
*
*  A to B 4 will be replaced by 3
*/
int newvalue=neigbours.get(key)+map.get(previousvertex);

//loop will only run when distance is less or distance not yet defined
if(newvalue<map.get(key) || map.get(key)==Integer.MIN_VALUE)
{
map.put((Character) key, newvalue);
}

}
}

}

//calling method to show final matrix of Vertex distance relation
showShortestDistance(map);

}

//Iterating Hash Map to show the shortest distance of vertex from Source
public void showShortestDistance(HashMap map)
{
for(Object key:map.keySet())
{
System.out.println(key.toString()+"    "+map.get(key));
}
}

public static void main(String[] args)
{
DirectedGraphImpl dgraph=new DirectedGraphImpl();

dgraph.listOfVertex();
System.out.println("shortest distance in a graph using djikstra");
dgraph.djiksta(dgraph);

}

}
```

### Selection Sort in JAVA

What is selection sort?

It is a sorting technique that is based on the partitioning of array into two parts, sorted and unsorted.

The process is:-

1) Find minimum element in unsorted array.
2) Swap the element at the end of sorted array.

when i=0 we don't have any sorted array so element will be replaced from first element later the sorted array end will growas the index.

Steps:-

underline elements are sorted array, the length is increasing with each minimum element added at the end.minimum element11 1125122264 minimum element12 1112252264 minimum element22 1112222564 minimum element25 1112222564 minimum element64 1112222564
Program:-

package sorting;publicclassSelectionSort{//function to print arraypublicstaticvoidprint(int[] arr){for(int i=0;i<=arr.length-1;i++) System.out.print(" "+arr[i]); System.out.println(" ");}//function to swap elementspublicstaticint[]swap(int[] arr,int i,int j){int temp; temp=arr[i]; arr[i]=arr[j]; arr[j]=temp…

### Bubble Sort in JAVA

What is bubble sort?

It is a sorting technique that is based on the comparison.Here we compare adjacent element, if the first element is larger than the second we swap each other. We do the same procedure again and again until array do not sort completely.

Example:-
5 1 4 2 8

51428here pass is nothing but iterating the loops equal to number of elements in the array but if it already sorted before then we can break the loop anddo existPASS1 case0 1 //check 0 and first element15428 case1 2 //check 1 and 2 element14528 case2 314258 case3 414258 swap istruePASS2 //first pass completed now do second pass case0 114258 case1 212458 case2 312458 case3 412458 swap istrue PASS3 // third pass case0 112458 case1 212458 case2 312458 case3 412458 swap isfalse since swap is false we break from the loop and do not go for fourth and fifth pass
Program:-

package sorting;publicclassBubbleSort{//function to print arraypublicstaticvoidprint(int[] arr){for(int i=0;i<=arr.length-1;i++) Syst…