刚接触golang，正在慢慢学习。为了学习，我选择将这段算法转换为 golang“http://www.geeksforgeeks.org/backtracking-set-7-suduku/”。 我已经尽力了，但 golang 指针比 c++ 指针更容易混淆。
我尝试了很多不同的方法来让它工作，但指针的东西仍然让我心烦意乱。我只是无法让下面提到的两个功能正常工作。有时输出是 - 找不到解决方案。有时，它只是输出不变的网格。
有人可以修复 SolveSudoku() 和 FindUnassignedLocation() 函数(以及任何其他函数，如果有的话)并解释如何在 GO 中使用引用和指针。
我也尝试阅读 GO 网站上的一些文档，但这并不是那么好，而且我没有足够的经验来理解那里给出的极小的东西。
如果有人建议在此代码中可以改进的更多内容，我也将不胜感激，错误？ , 错误？, 任何东西。

package main

import "fmt"

const (
    UNASSIGNED = 0
    N          = 9
)

func SolveSudoku(grid [N][N]int) bool {
    var row, col int
    if !FindUnassignedLocation(grid, row, col) {
        return true
    }
    for num := 1; num <= 9; num++ {
        if isSafe(grid, row, col, num) {
            grid[row][col] = num
            if SolveSudoku(grid) {
                return true
            }
            grid[row][col] = UNASSIGNED
        }
    }
    return false
}

func FindUnassignedLocation(grid [N][N]int, row int, col int) bool {
    for row = 0; row < N; row++ {
        for col = 0; col < N; col++ {
            if grid[row][col] == UNASSIGNED {
                return true
            }
        }
    }
    return false
}

func UsedInRow(grid [N][N]int, row int, num int) bool {
    for col := 0; col < N; col++ {
        if grid[row][col] == num {
            return true
        }
    }
    return false
}

func UsedInCol(grid [N][N]int, col int, num int) bool {
    for row := 0; row < N; row++ {
        if grid[row][col] == num {
            return true
        }
    }
    return false
}

func UsedInBox(grid [N][N]int, boxStartRow int, boxStartCol int, num int) bool {
    for row := 0; row < 3; row++ {
        for col := 0; col < 3; col++ {
            if grid[row+boxStartRow][col+boxStartCol] == num {
                return true
            }
        }
    }
    return false
}

func isSafe(grid [N][N]int, row int, col int, num int) bool {
    return !UsedInRow(grid, row, num) && !UsedInCol(grid, col, num) && !UsedInBox(grid, row-row%3, col-col%3, num)
}

func printGrid(grid [N][N]int) {
    for row := 0; row < N; row++ {
        for col := 0; col < N; col++ {
            fmt.Printf("%2d", grid[row][col])
        }
        fmt.Printf("\n")
    }
}

func main() {
    var grid = [N][N]int{
        [N]int{3, 0, 6, 5, 0, 8, 4, 0, 0},
        [N]int{5, 2, 0, 0, 0, 0, 0, 0, 0},
        [N]int{0, 8, 7, 0, 0, 0, 0, 3, 1},
        [N]int{0, 0, 3, 0, 1, 0, 0, 8, 0},
        [N]int{9, 0, 0, 8, 6, 3, 0, 0, 5},
        [N]int{0, 5, 0, 0, 9, 0, 6, 0, 0},
        [N]int{1, 3, 0, 0, 0, 0, 2, 5, 0},
        [N]int{0, 0, 0, 0, 0, 0, 0, 7, 4},
        [N]int{0, 0, 5, 2, 0, 6, 3, 0, 0},
    }

    if SolveSudoku(grid) == true {
        printGrid(grid)
    } else {
        fmt.Printf("No solution exists")
    }

    return
}

最佳答案

您的问题并不是您不了解指针。指针在 Go 中的工作方式与在 C++ 中的工作方式大体相同(除了因为 Go 具有逃逸分析和 GC 之类的东西，所以您不必担心悬空或无效指针，而代价是没有指针算法是可疑的)。

您的问题是对 C++ 和 Go 中数组之间差异的误解。在 C++ 中，数组实际上是一个指针，语法是一个别名。 int a[9] 和 int *a 是同一类型，静态大小调整和自由初始化只是一个很酷的编译器技巧。访问数组是指针运算的奇特语法，后跟取消引用——如前所述，这是 Go 所没有的。

在 Go 中，数组是值 而不是指针。当您有一个接受 a [9]int 的函数时，您实际上是在告诉编译器复制九个整数值，而不是指向内存中恰好有九个整数值的位置的指针。将 func(a [2]int) 视为编写 func(a1, a2 int) 的好方法。

这也导致了另一个细微的代码差异，在 C++ 中 int a[9][9] 是一个指向九个指针的指针，每个指针指向九个整数。在 Go 中，它是一个字面的、连续的 RMO 存储的 9x9 整数 block 。

Go 中有两种简单的解决方案:

1. 使用指向数组的指针。如 grid *[N][N]int 中。这工作正常，但访问和存储数组中的东西有点不干净。您必须使用 (*grid)[i][j] 显式取消引用指针，该指针看起来很难看并且可能有点难以阅读。

2. 使用 slice 。这是更好的选择，也是更惯用的 Go 风格。它还避免了到处都是令人讨厌的全局常量。代价是您确实牺牲了一些关于列大小的先验保证。

我将用带有一些注释的 slice 重写几个方法，剩下的交给你:

func main() {
    // We can omit the []int on every line, Go infers it
    var grid = [][]int{
        {3, 0, 6, 5, 0, 8, 4, 0, 0},
        {5, 2, 0, 0, 0, 0, 0, 0, 0},
        {0, 8, 7, 0, 0, 0, 0, 3, 1},
        {0, 0, 3, 0, 1, 0, 0, 8, 0},
        {9, 0, 0, 8, 6, 3, 0, 0, 5},
        {0, 5, 0, 0, 9, 0, 6, 0, 0},
        {1, 3, 0, 0, 0, 0, 2, 5, 0},
        {0, 0, 0, 0, 0, 0, 0, 7, 4},
        {0, 0, 5, 2, 0, 6, 3, 0, 0},
    }

    // == true is superfluous
    if SolveSudoku(grid) {
        printGrid(grid)
    } else {
        fmt.Println("No solution exists")
    }

    // Don't need to explicitly return, Go's mains are "void"
}


func UsedInCol(grid [][]int, col int, num int) bool {
    // We can use range to iterate over the whole slice.
    // The first value (which we ignore) is the slice index, the value you
    // used to call "row".
    // Now row is the slice containing the given row, this is similar to an iterator.
    for _,row := range grid {
        if row[col] == num {
            return true
        }
    }
    return false
}

杂项说明:

1. 以前使用常量 N 的地方，现在可以使用 len(grid)。要获取列的长度，请使用 len(grid[0])(警告:确保 grid[0] 存在)。

2. 由于它是一个值，因此将 [N][N]int 作为参数或返回值几乎总是效率低下，因为它在每次函数调用时都是相当大的副本。指针追逐通常更快，除非 N 值非常小(可能是 1-2)。

3. Go 中不存在引用，除非是极端技术意义上的引用，例如封闭变量的行为。

4. 一个更好的方法可能是声明类似 type SudokuGrid struct { grid []int; 的东西rows,cols int } 与某种 At/Set 方法集，这让你有一些大小保证回来。我会把这个(或者它是否是个好主意)留给你。

关于go - Golang 新手 - 对指针感到困惑，请帮助将 c++ 片段转换为 go，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/26728331/