Golang递归函数中的辅助方法使用技巧

Golang递归函数中的辅助方法使用技巧 你好，我正在从 JavaScript 转向 Go，并练习一些解决问题的方法，尝试实现“辅助方法”，但我遇到了一些麻烦。有人能帮我一下吗？

func main() {
	xs := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	fmt.Println(collectOddValues(xs))
}

func collectOddValues(arr []int) []int {
	result := []int{}
	var helper func([]int) []int

	helper = func(helperInput []int) []int {
		xs := helperInput
		if len(xs) == 0 {
			return []int{}
		}
		if helperInput[0]%2 != 0 {
			fmt.Println("Result:", result)
			return append(result, helperInput[0])
		}
		fmt.Println("xs:", xs)
		return helper(append(xs[:0], xs[1:]...))
	}
	fmt.Println("Result2:", result)
	return helper(arr)
}

附上代码：

The Go Play Space

The Go Play Space

替代的 Go (Golang) Playground，具有语法高亮、海龟图形等功能


更多关于Golang递归函数中的辅助方法使用技巧的实战教程也可以访问 https://www.itying.com/category-94-b0.html

3 回复

如果你正从 JavaScript 转向 Go，就应该摒弃 JavaScript 的习惯用法，转而拥抱 Go 的方式。你并不需要在每个地方都使用回调和 lambda 函数。你很少需要定义返回其他函数的函数。通常，你只需编写能实现你需求的简单代码。

如果你发现自己随处定义 lambda 函数，编写缩进超过 4 层的函数，或者函数长度超过 100 行，那么你写的仍然是 JavaScript，而不是 Go。

更多关于Golang递归函数中的辅助方法使用技巧的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


已通过NVM修复…

func main() {
	xs := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	fmt.Println(collectOddValues(xs))
}

func collectOddValues(xs []int) []int {
	//storage for odd values
	result := []int{}

	//declaring the helper function
	var helper func([]int) []int

	//defining the helper method function
	helper = func(helperInput []int) []int {

		//base case
		if len(helperInput) == 0 {
			//returning odd values when base case condition is met
			return result
		}
		//collecting odd values and storing inside of the result
		if helperInput[0]%2 != 0 {
			result = append(result, helperInput[0])
			fmt.Println("Result:", result)
		}

		//recursively deleting the first index in the slice
		return helper(append(helperInput[:0], helperInput[1:]...))
	}

	//beginning recursion
	return helper(xs)
}

在Go语言中，递归辅助方法通常使用闭包实现，但你的代码存在几个关键问题。主要问题是result变量在每次递归调用中都被重新初始化，导致无法累积结果。

以下是修正后的版本：

func collectOddValues(arr []int) []int {
    result := []int{}
    
    var helper func([]int)
    helper = func(helperInput []int) {
        if len(helperInput) == 0 {
            return
        }
        
        if helperInput[0]%2 != 0 {
            result = append(result, helperInput[0])
        }
        
        helper(helperInput[1:])
    }
    
    helper(arr)
    return result
}

更简洁的闭包实现方式：

func collectOddValues(arr []int) []int {
    var result []int
    
    var helper func([]int)
    helper = func(xs []int) {
        if len(xs) == 0 {
            return
        }
        
        if xs[0]%2 == 1 {
            result = append(result, xs[0])
        }
        
        helper(xs[1:])
    }
    
    helper(arr)
    return result
}

使用尾递归优化的版本：

func collectOddValues(arr []int) []int {
    var helper func([]int, []int) []int
    helper = func(xs, acc []int) []int {
        if len(xs) == 0 {
            return acc
        }
        
        if xs[0]%2 != 0 {
            acc = append(acc, xs[0])
        }
        
        return helper(xs[1:], acc)
    }
    
    return helper(arr, []int{})
}

递归辅助方法在Go中的典型模式是：

  1. 在主函数中定义结果变量
  2. 声明递归辅助函数
  3. 辅助函数通过闭包访问和修改结果
  4. 调用辅助函数并返回结果

这种模式在处理树结构、图遍历等复杂递归问题时特别有用。

回到顶部