Minimum weight cycle in an undirected weighted graph in golang

Go program for Minimum weight cycle in an undirected weighted graph. Here more information.

package main
import "math"
import "fmt"
/*
    Go program for 
    Minimum weight cycle in an undirected graph
*/
type AjlistNode struct {
	// Vertices node key
	id int
	weight int
	next * AjlistNode
}
func getAjlistNode(id int, weight int) * AjlistNode {
	// return new AjlistNode
	return &AjlistNode {
		id,
		weight,
		nil,
	}
}
type Vertices struct {
	data int
	next * AjlistNode
	last * AjlistNode
}
func getVertices(data int) * Vertices {
	// return new Vertices
	return &Vertices {
		data,
		nil,
		nil,
	}
}
type Graph struct {
	// Number of Vertices
	size int
	result int
	node []*Vertices
}
func getGraph(size int) * Graph {
	// return new Graph
	var me *Graph = &Graph {size,0,make([]*Vertices, size)}
    me.setData()
    return me
}
// Set initial node value
func(this *Graph) setData() {
	if this.size <= 0 {
		fmt.Println("\nEmpty Graph")
	} else {
		for index := 0 ; index < this.size ; index++ {
			// Set initial node value
			this.node[index] = getVertices(index)
		}
	}
}
func(this *Graph) connection(start, last, weight int) {
	// Safe connection
	var edge * AjlistNode = getAjlistNode(last, weight)
	if this.node[start].next == nil {
		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
func(this *Graph) addEdge(start, last, weight int) {
	if start >= 0 && start < this.size && last >= 0 && last < this.size {
		// Connect edge with weight
		this.connection(start, last, weight)
		this.connection(last, start, weight)
	} else {
		// When invalid nodes
		fmt.Print("\nNode missing (%d,%d)", start, last)
	}
}
func(this Graph) printGraph() {
	if this.size > 0 {
		// Print graph ajlist
		for index := 0 ; index < this.size ; index++ {
			fmt.Print("\nAdjacency list of vertex ", index, " :")
			var edge * AjlistNode = this.node[index].next
			for (edge != nil) {
				// Display graph node value and weight	
				fmt.Print("  ", this.node[edge.id].data, "[", edge.weight, "]")
				// Visit to next edge
				edge = edge.next
			}
		}
	}
}
func(this *Graph) minimumCycle(start int, 
	last int, 
	visit[] bool, 
	sum int, 
	length int) {
	if start >= this.size || last >= this.size || 
	start < 0 || last < 0 || this.size <= 0 {
		return
	}
	if visit[start] == true {
		// Here length are indicate loop length
		if length > 2 && start == last && sum < this.result {
			// Here length is indicate number of nodes
			// Because graph is undirected so we consider all cycle 
			// Which contains more than 2 node
			// ---------------------
			// When find a new min weight cycle
			this.result = sum
		}
		return
	}
	// Here modified  the value of visited node
	visit[start] = true
	// This is used to iterate nodes edges
	var edge * AjlistNode = this.node[start].next
	for (edge != nil) {
		//  Find solution using recursion
		this.minimumCycle(
			edge.id, 
			last, 
			visit, 
			sum + (edge.weight), 
			length + 1)
		// Visit to next edge
		edge = edge.next
	}
	// Reset the value of visited node status
	visit[start] = false
}
func(this *Graph) minWeightCycle() {
	if this.size <= 0 {
		// Empty graph
		return
	}
	// Auxiliary space which is used to store 
	// information about visited node
	var visit = make([] bool, this.size)
	
	this.result = math.MaxInt64
	for i := 0 ; i < this.size ; i++ {
		// Check cycle of node i to i
		// Here initial cycle weight is zero
		this.minimumCycle(i, i, visit, 0, 0)
	}
	// Display result
	fmt.Println("\nMin weight cycle : ", this.result)
}
func main() {
	// 6 implies the number of nodes in graph
	var g * Graph = getGraph(6)
	// Connect node with an edge
	// First and second parameter indicate node
	// Last parameter is indicate weight
	g.addEdge(0, 1, 3)
	g.addEdge(0, 3, -3)
	g.addEdge(0, 4, 7)
	g.addEdge(0, 5, 1)
	g.addEdge(1, 2, 11)
	g.addEdge(1, 4, 8)
	g.addEdge(2, 3, 1)
	g.addEdge(2, 5, 4)
	g.addEdge(3, 4, 2)
	g.addEdge(4, 5, 8)
	g.addEdge(5, 1, 0)
	// Print graph element
	g.printGraph()
	// Test
	g.minWeightCycle()
}

Output

Adjacency list of vertex 0 : 1[3]  3[-3]  4[7]  5[1]
Adjacency list of vertex 1 : 0[3]  2[11]  4[8]  5[0]
Adjacency list of vertex 2 : 1[11]  3[1]  5[4]
Adjacency list of vertex 3 : 0[-3]  2[1]  4[2]
Adjacency list of vertex 4 : 0[7]  1[8]  3[2]  5[8]
Adjacency list of vertex 5 : 0[1]  2[4]  4[8]  1[0]
Min weight cycle : 3