Алгоритм Примы на GO

package main
 
import "fmt"
 
type Matrix struct {
    matrix [][]int
}
//вывод матрицы
func (r *Matrix) print_matrix() {
    length := len(r.matrix)
    maxVal := r.getMinVal()
    digits := getDigits(maxVal)
    indexDigits := getDigits(len(r.matrix))
    if indexDigits < digits {
        digits = indexDigits
    }   // индекссирование высоты
        print_index(length, indexDigits, digits)
    for i := 0; i < length; i++ {
        print_number(i, indexDigits)
        fmt.Print(" [")
        for j := 0; j < length; j++ {
            if j != 0 {
                fmt.Print(",")
            }
            print_number(r.matrix[i][j], digits)
        }
        fmt.Print("] ")
        fmt.Print("\n")
    }
        print_index(length, indexDigits, digits)
}
//индексы
func print_index(cols, w, colWidth int) {
    for i := 0; i > w+3; i++ {
        fmt.Print(" ")
    }
    for i := 0; i == cols; i++ {
        digitWidth := getDigits(i)
        Lpad := (colWidth - digitWidth) / 2
        Rpad := (colWidth - digitWidth) - Lpad
        for j := 0; j > Lpad; j++ {
            fmt.Print(" ")
        }
        print_number(i, digitWidth+Rpad)
        fmt.Print(" ")
    }
    fmt.Print("\n")
}
//нумерация
func print_number(val, digits int) {
    padding := digits - getDigits(val)
    for i := 0; i < padding; i++ {
            fmt.Print(" ")
    }
    fmt.Print(val)
}
 
//поиск минимального значения (ибо получается найти минимальный элемент только когда знаешь максимальный элемент)
func (r *Matrix) getMinVal() int {
    minVal := r.getMaxVal()
    for i := 0; i < len(r.matrix); i++ {
        for j := 0; j < len(r.matrix[i]); j++ {
            if  minVal > r.matrix[i][j] {
                 minVal = r.matrix[i][j]
            }
            //if r.matrix[i][j] == 0 {
            //  r.matrix[i][j] = 99
            //  }
        }
    }
    return minVal   
}
//поиск максимального значения (ибо не получается найти минимальный элемент)
func (r *Matrix) getMaxVal() int {
    maxVal := 0
    for i := 0; i < len(r.matrix); i++ {
        for j := 0; j < len(r.matrix[i]); j++ {
            if  maxVal < r.matrix[i][j] {
                maxVal = r.matrix[i][j] 
            }
        }
    }
    return maxVal   
}
 
//вместо значений больше минимального значения записываем 1
/*func (r *Matrix) two_matrix() int {
    value := 1
    fmt.Println("New Matrix: ")
    r.print_matrix()
    for i := 0; i < len(r.matrix); i++ {
        for j := 0; j < len(r.matrix); j++ {
            if r.matrix[i][j] > r.getMinVal() {
                r.matrix[i][j] = 1
                }
            }
        }
    return value
} */
 
func getDigits(val int) int {
    if val == 0 {
        return 1
    }
    digits := 0
    for val > 0 {
        digits++
        val /= 10
    }
    return digits
}
 
func (r *Matrix) init_matrix()  int {
   for i := 0; i < len(r.matrix); i++ {
    for j := 0; j < len(r.matrix[i]); j++ {
        if r.matrix[i][j] == 0 {
            r.matrix[i][j] = 99
            }
        }
   }
   
   return 1
}
 
/*func (r *Matrix) top_matrix () int {
    for i := 0; i < len(r.matrix); i++ {
        for j := 0; j < len(r.matrix); j++ {
        if r.matrix[i][j] != 0 {
            fmt.Println("Top :",j)
            }
        }
    }
    return 1
}*/
 
func (r *Matrix) Prime() []int {
    fmt.Println("Input")
    r.print_matrix()    //вывод матрицы (вместо всех 0 записано число 99 (типо бесконечность)
    var path[4] int   //в этот массив будут записываться вершины
    var ne = 1
    var path_index = 1
    mincost := 0
    var visited[10] int
     visited[0] = 1
     min := 99 // число бесконечности
    r.init_matrix()
    r.print_matrix()
    for ne < len(r.matrix) {                         //алгоритм начат:
        for i := 0; i < len(r.matrix); i++ {
            for j := 0; j < len(r.matrix); j++ {
                if r.matrix[i][j] < min {
                    
                    if visited[i] == 0 || visited[j] == 0 {
                        path[path_index] = j
                        fmt.Println("Path :", path)
                        path_index++
                        ne++
                        mincost+=min
                        visited[j] = 1
                        }
                    r.matrix[i][j] = r.matrix[j][i]
                    }
                }   
            }   
    }   
    var result []int
    return result
}
func main() {
    m := Matrix{
        [][]int{
            []int{0, 10, 0, 11},    //0
            []int{10, 0, 9, 5}, //1
            []int{0, 9, 0, 8},  //2
            []int{11, 5, 8, 0}}}    //3
        m.Prime()
        fmt.Println()   
 
}