迭代 VS 递归

通常的递归是线性递归，又称之为单向递归
尾递归是线性递归的一种特殊形式。其归调用在递归实例中恰好以最后一步操作的形式出现，
把全部的操作先执行完，不用栈空间来保存环境,即类似闭包引用外部变量

• 迭代通常是有序的水平扩张，而递归层层嵌套，先进后出，以始为终
• 通常来说递归都可用迭代来演绎，但前者更易理解，对心智负担比较轻

迭代

以指定目录下文件查找器为例，迭代更有优势

// 关注同类问题的退出
// 收集目录对象,处理目录对照
func scanFile(dir string) []string {
	// 文件结果集
	var result []string
	// 目录收集器
	dirList := []string{dir}

	// 将层级目录，变成对每个目录的遍历
	for len(dirList) > 0 {
		files, _ := ioutil.ReadDir(dirList[0])
		for _, f := range files {
			next := dirList[0] + "/" + f.Name()
			if f.IsDir() {
				dirList = append(dirList, next)
			} else {
				result = append(result, next)
			}
		}
		// go切片越界不会报错，直接为空[]
		dirList = dirList[1:]
	}
	return result
}

基本上，收集目标目录下的所有目录及子目录，然后遍历文件记录下来
目录收集器列表这个可变对象作为外层死循环退出条件的参与者，
用队列的形式先进先出，循环体中生产队列元素，循环体尾消费队元素，很显然生产元素前期是比较多，但终会有停下（文件夹的数量是有限的），到后期就是不停消费队列了，直至队列元素为空退出循环。

当然也可用for循环作为外层条件，但不能用for…range

func scanFile2(dirname string) []string {
	// 文件结果集
	var result []string
	// 目录收集器
	dirList := []string{dirname}

	// 将层级目录，变成同一级下所有目录遍历
	for i := 0; i < len(dirList); i++ {
		files, _ := ioutil.ReadDir(dirList[i])
		// for...range 是值拷贝
		for _, f := range files {
			next := dirList[i] + "/" + f.Name()
			if f.IsDir() {
				dirList = append(dirList, next)
			} else {
				result = append(result, next)
			}
		}
	}
	return result
}

递归

若只收集某个文件夹下的所有空文件夹（或文件兼之），显然递归才是明智的选择。
其区别在于，文件夹的定义依赖于其下是否存在文件。即上层向下层提供计算的状态条件，
上层调用下层计算，下层反馈为上层逻辑的后半断处理所依赖，有一个A->B->A的趋势。

// 递归文件夹 关注递归链条
func scanAllByRecursive(path string) []string {
	var result []string // 收集本层结果集
	files, _ := ioutil.ReadDir(path)
	for _, f := range files {
		p := path + "/" + f.Name()
		if f.IsDir() {
			t := scanAllByRecursive(p)
			if len(t) == 0 {
				// 记录目录名
				result = append(result, p)
			} else {
				result = append(result, t...)
			}
		} else {
			result = append(result, p)
		}
	}
	return result
}

递归只关注单递归链条的逻辑处理，每单链递归过程都是一个全新的开始，包括启用的变量只服务于本次单链条，与下一次互不干扰。而在内对递归的调用，意味着进入新一单链（A->B->C…, A->B过程称之为），即对递归的调用结果的获取，本质是调用前外层给内层状态，等待内层处理反馈，外层再根据反馈结果，进行本次递归的后半段处理，类似于函数嵌套调用（如 a(b(c(d())))。递归的返回值类型，通常由递归的中止退出返回类型决定，当然前提是每次递归的结果需要链式递归返回，先进后出，层层传导