Golang Go语言中for循环多层嵌套怎么用递归函数实现？

大佬们好，go 语言 for 循环多层嵌套怎么用递归函数实现，小弟谷歌很久都不知道怎么实现。

func add(n int){
		//n 嵌套次数，比如嵌套两次
    	for i:=0;i<len(s);i++{
    		for k:=0;k<len(s);k++{
        		...
    		}
    	}    
	}

比如上面 n 是 2 就嵌套两次，万一嵌套 n 次呢？请问大佬们，怎么实现参数 n 次，循环就嵌套 n 次，怎么用递归函数实现呢？小弟是新手，搞不懂，特意上来请教，感谢大家


Golang Go语言中for循环多层嵌套怎么用递归函数实现？

更多关于Golang Go语言中for循环多层嵌套怎么用递归函数实现？的实战教程也可以访问 https://www.itying.com/category-94-b0.html

25 回复

func add(n int) {
if n < 0 ｛
return
｝
if n == 0 {
…
return
}
for i:=0; i<len(s); i++{
add(n-1)
}
}

更多关于Golang Go语言中for循环多层嵌套怎么用递归函数实现？的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


感谢大佬指导，求和没有问题了。但是我原本的递归想法还是不知道如何实现，我贴一下原代码吧




package main

import "fmt"

var (
s = “abcdefghijklnmopqrstuvwxyz”
)

func main() {
var s1 []string
for i := 0; i < len(s); i++ {
for k := 0; k < len(s); k++ {
for j := 0; j < len(s);j++ {
s1 = append(s1,string(s[i])+string(s[k])+string(s[j])))
}
}
}

fmt.Println(s1)
}

相这种多重 for 循环嵌套，拼接字符串，不知道如何递归函数实现？写了好久都不知道如何实现，可能自己是新手吧，求大佬指点一下

首先这个多重 for 循环就很没有必要，只是为了挪一个 index 而已，如果要 10 个长度的字符串难道要写 10 层 for 循环😂

如果你简化了这个 for 循环，参考 1L 的思路就可以写出来了
func generateStrings(n int, prefix string) []string {
if n == 0 {
return []string{prefix}
}
var s1 []string
for i := 0; i < len(s); i++ {
s1 = append(s1, generateStrings(n-1, prefix+string(s[i]))…)
}
return s1
}

func main() {
s1 := generateStrings(3, “”)
fmt.Println(s1)
}

我平时确实这样写的。。。人比较笨，直到遇到好像要一直嵌套的或者嵌套不同数目的例子人就傻了。即便按照一楼大佬的方法，我也想不出怎么写。大佬的方案确实有用，换做我想破脑袋都想不出来。编程是我我的小小爱好，感谢大佬的指导，使我感觉编程更有乐趣了

想了好久，还是不清楚大佬 generateStrings(n-1, prefix+string(s[i]))… 这个怎么想出来的，太精妙了。想请问大佬，需要补充哪些知识才能有这种思维？

递归本来就是个难点，其实没有必要执着使用递归。

另外你可以学一下 Erlang （或其他纯函数式编程语言），对理解递归有很大帮助。我也是对递归特别头疼，直到有一次看 Erlang 的入门教程，才感觉有点开窍。

其实该用递归还是不可避免的，一直对这个好像懂了又好像没懂。直到遇到昨天的问题才想着想把递归吃透。感谢大佬指点，看样子要花点时间看看其他函数式编程语言了

当时学 Erlang ，印象最深刻的就是，它想循环就只能用递归，没有其他实现循环的方法了，学不会递归根本没法用，因此它的教程也会特别深入浅出讲解递归。

说的我都想马上学起来了，哈哈

呃呃，想要深入了解的话建议看点数据结构与算法吧

这东西难吗？需要花的时间多少？其实我学编程只是当业余爱好来玩的。我补充知识单纯是想某门语言突破某个难点

比较枯燥，可以先翻翻看有哪些东西，扩宽一下思路也是不错的

感谢前辈指导

除非算法需要，不然能别递归就别递归了吧，，调用栈有最大层数限制的吧

m = len(s), 你的问题可以用 n 位 m 进制数来进行转换, 就变成了 1 层循环

LeetCode 中 DFS 、回溯相关的题目基本都是这样的，推荐两个网站学习：

labuladong 的算法小抄 | labuladong 的算法小抄
https://labuladong.github.io/algo/

youngyangyang04/leetcode-master: 《代码随想录》 LeetCode 刷题攻略
https://github.com/youngyangyang04/leetcode-master

全排列问题和 OP 提出的问题比较类似，但是需要回溯，难度也不高，对于理解算法思想比较有帮助，可以先看一下：
https://leetcode.cn/problems/permutations/

go 没有尾递归, 没事别写递归
假设 n 是 3, 那么最里面的循环需要的是,
[0,0,0,0]
[0,0,0,1]
[0,0,0,2]
[0,0,1,0]
[0,0,1,1]
…
[2,2,2,1]
[2,2,2,2]

你只需要模拟一个三进制的数,从 0-2222 的流程, 然后把每一位的数分别取出来, 就实现了上面的多重循环的功能.

推荐这本书 The Little Schemer

不是很懂

不知道如何实现，感觉是越来越复杂了…

看了一下，网站真的是好网站，感谢指导

看了一下，网站真的是好网站，感谢指导

在Go语言中，通常使用for循环来实现多层嵌套循环。然而，有时为了简化代码或解决特定问题，可以考虑用递归函数来替代嵌套循环。尽管递归在本质上不是循环，但通过适当的函数调用，它可以模拟多层嵌套循环的行为。

以下是一个简单的示例，演示如何用递归函数模拟两层嵌套循环：

package main

import "fmt"

func nestedLoopRecursive(i, jMax, kMax int) {
    if i > jMax {
        return
    }
    for k := 1; k <= kMax; k++ {
        fmt.Printf("i=%d, j=%d, k=%d\n", i, i, k)
    }
    nestedLoopRecursive(i+1, jMax, kMax)
}

func main() {
    jMax := 3 // 外层循环的上限
    kMax := 2 // 内层循环（实际由递归函数调用中的for循环实现）的上限
    nestedLoopRecursive(1, jMax, kMax)
}

注意，这个示例中，我们实际上只模拟了两层循环的一部分，因为内层循环（k的循环）是在递归函数中直接实现的，而外层循环（i的循环）则通过递归调用自身来模拟。

对于真正的多层嵌套（例如三层或更多层），可以进一步扩展递归函数，增加更多的参数来跟踪每一层的当前索引，并在递归基准条件中检查所有层的索引是否都已超出其上限。

请根据实际情况调整递归函数的设计，以满足特定需求。

回到顶部