# Adjacency list representation of undirected graph in kotlin

Kotlin program for Adjacency list representation of undirected graph. Here problem description and explanation.

```
/*
Kotlin Program for
Undirected graph representation by using adjacency list
*/
class AjlistNode
{
// Vertices node key
var id: Int;
var next: AjlistNode ? ;
constructor(id: Int)
{
// Set value of node key
this.id = id;
this.next = null;
}
}
class Vertices
{
var data: Int;
var next: AjlistNode ? ;
var last: AjlistNode ? ;
constructor(data: Int)
{
this.data = data;
this.next = null;
this.last = null;
}
}
class Graph
{
// Number of Vertices
var size: Int;
var node: Array < Vertices ? > ;
constructor(size: Int)
{
// Set value
this.size = size;
this.node = Array(size)
{
null
};
this.setData();
}
// Set initial node value
fun setData(): Unit
{
if (this.size <= 0)
{
println("\nEmpty Graph");
}
else
{
var index: Int = 0;
while (index < this.size)
{
this.node[index] = Vertices(index);
index += 1;
}
}
}
// Connect two nodes
fun connect(start: Int, last: Int): Unit
{
val edge: AjlistNode = AjlistNode(last);
if (this.node[start]?.next == null)
{
this.node[start]?.next = edge;
}
else
{
// Add edge at the end
this.node[start]?.last?.next = edge;
}
// Get last edge
this.node[start]?.last = edge;
}
// Handling the request of adding new edge
fun addEdge(start: Int, last: Int): Unit
{
if (start >= 0 && start < this.size &&
last >= 0 && last < this.size)
{
this.connect(start, last);
if (start == last)
{
// When self loop
return;
}
this.connect(last, start);
}
else
{
// When invalid nodes
println("\nHere Something Wrong");
}
}
fun printGraph(): Unit
{
if (this.size > 0)
{
var index: Int = 0;
// Print graph ajlist Node value
while (index < this.size)
{
print("\nAdjacency list of vertex " + index + " :");
var temp: AjlistNode ? = this.node[index]?.next;
while (temp != null)
{
// Display graph node
print(" " + this.node[temp.id]!!.data);
// Visit to next edge
temp = temp.next;
}
index += 1;
}
}
}
}
fun main(args: Array < String > ): Unit
{
// 5 implies the number of nodes in graph
val g: Graph = Graph(5);
// Connect node with an edge
g.addEdge(0, 1);
g.addEdge(0, 2);
g.addEdge(0, 4);
g.addEdge(1, 2);
g.addEdge(1, 4);
g.addEdge(2, 3);
g.addEdge(3, 4);
// print graph element
g.printGraph();
}
```

**Output**

```
Adjacency list of vertex 0 : 1 2 4
Adjacency list of vertex 1 : 0 2 4
Adjacency list of vertex 2 : 0 1 3
Adjacency list of vertex 3 : 2 4
Adjacency list of vertex 4 : 0 1 3
```

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

## New Comment