递归——前奏练习

最新推荐文章于 2024-01-28 22:37:20 发布
最新推荐文章于 2024-01-28 22:37:20 发布
阅读量307 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dawnto/article/details/121070234
版权 
package dynamicProgram

import (
	"fmt"
	"testing"
	"time"
)

/*
暴力递归

暴力递归的过程就是尝试
1.把问题转化为规模缩小了的同类问题的子问题
2.有明确的不需要继续进行递归的条件(base case)
3.有当得到了子问题的结果之后的决策过程
4.不记录每一个子问题的解    记录则为动态规划
 */
/*
熟悉什么叫尝试
。打印n层汉诺塔从最左边移动到最右边的全部过程
。打印一个字符串的全部子序列
。打印一个字符串的全部子序列，要求不要出现重复字面值的子序列
。打印一个字符串的全部排列
。打印一个字符串的全部排列，要求不要出现重复排列
 */



/*

           |         |          |
          ---        |          |
         -----       |          |
        -------      |          |
          左         中         右
                   主视图


   小压大的次序将左侧柱子上的盘子移动的右侧的柱子上去，可以借助中间的柱子


                  O     O
                     O
                   俯视图

   1. 1 ~ N-1   左 --> 中
   2. N         左 --> 右
   3. 1 ~ N-1   中 --> 右
 */

func hanoi1(n int)  {
   leftToRight(n)
}


// 把1~N层圆盘，从左 -> 右
func leftToRight(n int)  {   //1-n层全部圆盘
	if n == 1 { //base case 只剩一个
		fmt.Println("Move 1 from left to right")
		return
	}
	leftToMid(n - 1)
	fmt.Println("Move", n , "from left to right")
	midToRight(n - 1)
}

// 把1~N层圆盘，从左 -> 中
func leftToMid( n int)  {
	if n == 1 {
		fmt.Println("Move 1 from left to mid")
		return
	}
	leftToRight(n - 1)
	fmt.Println("Move",n,"from left to mid")
	rightToMid(n - 1 )
}


// 把1~N层圆盘，从 右 -> 中
func rightToMid(n int){
   if n == 1 {
	   fmt.Println("Move 1 from right to mid")
	   return
   }
   rightToLeft(n - 1)
   fmt.Println("Move",n,"from right to mid")
   leftToMid(n - 1)
}


func midToRight(n int)  {
   if n == 1 {
	   fmt.Println("Move 1 fromo mid to right")
	   return
   }
   midToLeft(n - 1)
   fmt.Println("Move",n,"from mid to right")
   leftToRight(n - 1)
}


func rightToLeft(n int)  {
	if n == 1 {
		fmt.Println("Move 1 from right to left")
		return
	}
	rightToMid(n - 1)
	fmt.Println("Move",n,"from right to left")
	midToLeft(n - 1)
}

func midToLeft(n int)  {
   if n == 1 {
	   fmt.Println("Move 1 from mid to left")
	   return
   }
   midToRight(n - 1)
   fmt.Println("Move",n,"from mid to left")
   rightToLeft(n - 1)
}

func TestHanoi1(t *testing.T)  {
	hanoi1(3)
}

/*
 1. 1~N-1   from  -> other
 2. N       from  -> to
 3. 1~N-1   other -> to
 */

func hanoi2(n int)  {
	if n > 0 {
		hanoi(n,"left","right","mid")
	}
}

func hanoi(N int, from, to, other string)  {
	if N == 1 {
		fmt.Println("Move 1 from",from,"to",to)
		return
	}else {
		hanoi(N - 1,from , other,to)
		fmt.Println("Move",N,"from",from,"to",to)
		hanoi(N-1,other,to,from)
	}
}

func TestHanoi2(t *testing.T)  {
	hanoi2(10)
}


/*
 3层为例


1.  1,2   左 --> 中                   | 1 左 --> 右
                                     | 2 左 --> 中
                                     | 1 右 --> 中
2.  3     左 --> 右

3.  1,2   中 --> 右                   | 1 中 --> 左
                                     | 2 中 --> 右
                                     | 1 左 --> 右


N层汉诺塔最优解复杂度O(2^N-1)
 */







type Record struct {
	finish bool
	base   int
	from   string
	to     string
	other  string
}

type RecordStack struct {
	Elem []Record
}

func NewRecordStack() *RecordStack {
	return &RecordStack{Elem: make([]Record,0)}
}

func (s *RecordStack)Push(val Record)  {
	s.Elem = append(s.Elem, val)
}

func (s *RecordStack)Pop() Record {
	res := s.Elem[len(s.Elem)-1]
	s.Elem = s.Elem[:len(s.Elem)-1]
	return res
}

func (s *RecordStack)Peek() *Record {
	return &s.Elem[len(s.Elem)-1]
}

func (s *RecordStack)IsEmpty() bool  {
	return len(s.Elem) == 0
}

func hanoi3( N int) {
    if N < 1 {
		return
	}

	stack := NewRecordStack()
	stack.Push(Record{
		finish: false,
		base:   N,
		from:   "left",
		to:     "right",
		other:  "mid",
	})


	for !stack.IsEmpty() {
		cur := stack.Pop()
		if cur.base == 1 {
			fmt.Println("Move 1 from",cur.from,"to",cur.to)
			if !stack.IsEmpty() {
				stack.Peek().finish = true
			}
		}else {
			if !cur.finish {
				stack.Push(cur)
				stack.Push(Record{
					finish: false,
					base:   cur.base-1,
					from:   cur.from,
					to:     cur.other,
					other:  cur.to,
				})
			}else {
				fmt.Println("Move",cur.base,"from",cur.from,"to",cur.to)
				stack.Push(Record{
					finish: false,
					base:   cur.base-1,
					from:   cur.other,
					to:     cur.to,
					other:  cur.from,
				})
			}
		}
	}


}

func TestHanoi3(t *testing.T)  {
	hanoi3(3)
}





/*

仰望好的尝试？
给你一个栈，请你逆序这个栈，
不能申请额外的数据结构
只能使用递归函数。如何实现？
*/


/*
第一步  实现去掉栈底，并返回的函数 int f(stack)


| 1 |  |   |
| 2 |  | 1 |
| 3 |  | 2 |
-----  -----
f  r = 1 , last = f2(stack)
                  f2    r = 2, last = f3(stack)
                                      f3  r = 3  return
 */




type Stack []int

func (s *Stack)IsEmpty() bool {
	return len(*s) == 0
}

func (s *Stack)Pop() int {
	res := (*s)[len(*s)-1]
     *s = (*s)[:len(*s)-1]
	return res
}

func (s *Stack)Push(val int)  {
	*s = append(*s,val)
}

func reverse(stack *Stack)  {
	if stack.IsEmpty() {
		return
	}
	i := f(stack)
	reverse(stack)
	stack.Push(i)
}




func f(stack *Stack)  int {
	result := stack.Pop()
	if stack.IsEmpty() {
		return result
	}else {
		last := f(stack)
		stack.Push(result)
		return last
	}
}

func TestReverse(t *testing.T)  {
	stack := &Stack{}
	stack.Push(100)
	stack.Push(200)
	stack.Push(300)
	reverse(stack)

	for !stack.IsEmpty() {
		fmt.Println(stack.Pop())
	}
}















func Test(t *testing.T)  {
	b := false
	go func() {
		for !b {
			fmt.Println("1")
		}
		fmt.Println("2")
	}()
	go func() {
		b = true
	}()
	time.Sleep(time.Second *100)
}


/*
二叉树可以通过先序，后序或者按层遍历的方式序列化和反序列化
二叉树无法通过中序遍历的方式实现序列化和反序列化
因为不同的两棵树，可能得到同样的中序序列，几遍补了空位置也可能一样
比如如下两棵树
        2
       ---
      /
     1
和
     1
     ---
        \
         2
   补足位置的中序遍历结果都是{nil,1,nil,2,nil}
 */









/*
 打印一个字符串的全部子序列
 子串：必须连续的
 abcd
 0: a, ab, abc, abcd
 1: b, bc, bcd
 2: c, cd
 3: d
  for
    for




子序列
原始序列中从左往右拿字符，可以不连续，要求相对次序不能变
    abc
                      ------------0------------
                  要a/                          \ 不要a
               -----1-----                  -----1-----
           要b/            \不要b        b要/            \b 不要
           -2-            -2-           -2-            -2-
      c要 /   \c不要   c要 /   \c不要 c要 /   \c不要   c要 /   \c不要
     abc     ab       ac      a      bc      b       c      ""
 */

func subs(str string) []string {
	var path string
	path = ""
	ans := &[]string{}
	process1(str,0,ans,path)
	return *ans
}

// str 固定不变
// index 此时来到的位置，要 or 不要
// ans 如果index 来到了 str 的终止位置，我要把我沿途路径所形成的的答案，放到ans里去
// 之前做出的选择，就是path
func process1(str string,index int, ans *[]string,path string)  {
	if index == len(str) {
		*ans = append(*ans,path)
		return
	}
	no := path
	process1(str, index + 1, ans, no)
	yes := path + string(str[index])
	process1(str, index + 1, ans, yes)
}

func TestSubStr(t *testing.T)  {
	fmt.Println(subs("abcdefg")) //也是深度优先遍历
}

/*
打印一个字符串的全部子序列，要求不要出现重复字面值的子序列
所有的字符都不是一样的
如aaaa

 */



func process2(str string,index int, ans map[string]bool,path string)  {
	if index == len(str) {
		ans[path] = true
		return
	}
	no := path
	process2(str, index + 1, ans, no)
	yes := path + string(str[index])
	process2(str, index + 1, ans, yes)
}

func subs2(str string) []string {
	var path string
	path = ""
	ans := map[string]bool{}
	process2(str,0,ans,path)

	result := []string{}

	for key, _ := range ans{
		result = append(result, key)
	}

	return result
}

func TestSubs2(t *testing.T)  {
	fmt.Println(subs2("aaaaa"))
}

/*
所有不同字面值的子序列的个数，动态规划
 */



/*
打印一个字符串的全部排列



                                                                 [a,b,c]
                                                                 [0,1,2]
                                                 0a ->0          1b -> 0     2c ->0    谁来到0 位置 做决策
                                                 abc             bac         cba
                                           1b ->1   2c ->1                             谁来到1 位置 做决策，不要把已经放到0位置的 再调回来
                                           abc      acb
                                           2c ->2   2b ->2
                                           abc      acb
                                                               1a->1    2c->1         1b ->b    2a ->1
                                                               bac      bca           cba       cab






 */






func premution(str string) []string {
	var res []string
	if str == "" || len(str) == 0 {
		return res
	}
    process([]byte(str),0,&res)
	return res
}


//str[0...i-1]已经做好决定的
//str[i...]都有机会来到i位置
//i终止位置,str当前的样子就是一种结果 -> ans
func process(str []byte, i int,res *[]string)  {
	if i == len(str) {
		*res = append(*res, string(str))
		return //可加可不加
	}
	// 若果i 没到终止位置，从i 往后的所有位置都可以来到i位置(j,可以尝试来到i位置)
	for j := i; j < len(str); j++ {
     swap(str,i,j)
	 process(str,i+1,res)
	 swap(str,i,j)  // 恢复现场，才能正确执行
	}
}

func swap(str []byte,i,j int)  {
	str[i] , str[j] = str[j], str[i]
}

func TestPermutations(t *testing.T)  {
	fmt.Println(premution("abac"))
}



/*
打印一个字符串的全部排列 要求不出现重复的排列

分支限界

 */

func TestPremution2(t *testing.T)  {
	fmt.Println(premution2("abac"))
}


func premution2(str string) []string {
	var res []string
	if str == "" || len(str) == 0 {
		return res
	}
	process_2([]byte(str),0,&res)
	return res
}


//str[0...i-1]已经做好决定的
//str[i...]都有机会来到i位置
//i终止位置,str当前的样子就是一种结果 -> ans
func process_2(str []byte, i int,res *[]string)  {
	if i == len(str) {
		*res = append(*res, string(str))
		return  // 可加可不加
	}
	visit := [26]bool{}   //非共享，剪枝  --> 分支限定
	// 若果i 没到终止位置，从i 往后的所有位置都可以来到i位置(j,可以尝试来到i位置)
	for j := i; j < len(str); j++ {
		if !visit[str[j]-'a'] {
			visit[str[j]-'a'] = true
			swap(str, i, j)
			process_2(str, i+1, res)
			swap(str, i, j) // 恢复现场，才能正确执行
		}
	}
}




// 用位图解决问题
func premution3(str string) []string {
	var res []string
	if str == "" || len(str) == 0 {
		return res
	}
	process_3([]byte(str),0,&res)
	return res
}


func process_3(str []byte, i int,res *[]string)  {
	if i == len(str) {
		*res = append(*res, string(str))
		return  // 可加可不加
	}
	visit := 0   //非共享，剪枝  --> 分支限定

	// 若果i 没到终止位置，从i 往后的所有位置都可以来到i位置(j,可以尝试来到i位置)
	for j := i; j < len(str); j++ {
		if visit >> (str[j]-'a') &1 == 0 {
			visit |= 1 << (str[j]-'a')
			swap(str, i, j)
			process_3(str, i+1, res)
			swap(str, i, j) // 恢复现场，才能正确执行
		}
	}
}


func TestPremution3(t *testing.T)  {
	fmt.Println(premution3("aaaa"))
}
metabit
关注
专栏目录
动态规划（dynamic programming）基础【背包问题】
upward
10-14 1108
目 录 哔哩哔哩网站——动态规划基础 背包问题(1) 01背包 哔哩哔哩网站——【动态规划】背包问题 百度百科——背包问题 哔哩哔哩网站——动态规划基础 背包问题(1) 01背包 视频网址——哔哩哔哩网站——动态规划基础 背包问题(1) 01背包 滚动数组 背包问题——优化算法——阶梯跳跃点 // #include "everything.h" #include <bits/stdc++.h> // 错误代码 using nam...
教你彻底学会递归——《进阶篇》
12-21
教你彻底学会递归——《进阶篇》 通过上一篇，我们已经基本了解了递归的思想，以及递归求解问题的方法。因此这一篇文章，我将通过一些经典的通过递归算法实现的实例来更深入的了解递归算法。 汉诺塔问题 汉诺塔...
数据结构与算法笔记——用Go语言描述
Go的全部
11-16 3738
数据结构与算法 用Go语言描述 位运算 位运算——奇淫技巧 位运算——二进制截断和插入 位运算——交换奇偶位 位运算——回文判断 位运算——LeetCode1386. 安排电影院座位 位运算——面试题 17.19. 消失的两个数字 位运算——求1比特数 位运算——476. 数字的补数 位运算——出现一次的数，出现两次的数 查找 二分——有序数组中查找元素 二分——有序数组中，某个数最左或最右的位置 二分——无序无重复元素数组的局部最小值的索引 排序 排序——选择排序 排序——冒泡排序 排序——插入排序 .
目录索引整理
Go的全部
12-08 488
目录索引整理
大数据入门级学习——Hadoop集群搭建总结（VM+centOS7）
不撸先疯。
10-11 2029
步入大数据的第一步： 必须学会搭建大数据集群的框架 那么第一步必须要在linux系统上搭建Hadoop集群 一、安装并配置虚拟机（centOS7） 先在VM中创建一台虚拟机（VM傻瓜式安装即可）： 下面简单介绍一下安装centOS7的过程： 安装centOS7的过程（安装桌面版）： 安装完成，下面开始配置： 注意：centOS6与centOS7的配置选项不同！（如果安装的是centOS6，最后的文件夹为......
JavaScript——函数作用域，运行三部曲，预编译四部曲，函数声明整体提升，
abraham的博客
07-13 719
视频：https://ke.qq.com/course/231577?taid=3983676656552089 练习8.写一个函数，功能是告知你所选的小动物的叫声。 function scream(animal){ switch(animal){ case"dog": ...
《编译原理》-4.自顶向下的分析
weixin_44952817的博客
10-18 1773
自顶向下的分析4.1使用递归下降分析算法进行自顶向下的分析4.1.1 递归下降分析的基本方法4.1.2 重复和选择：使用EBNF4.1.3 其他决定问题4.2 LL（1）分析4.2.1 LL(1)分析的基本方法4.2.2 LL(1)分析和算法4.2.3 LL(1)消除左递归和提取左因子1)左递归消除2)提取左因子4.3 First集合和Follow集合4.3.1 First集合4.3.2 Follow集合4.3.3 构造LL(1)分析表 自顶向下的分析算法跟最左推导结合，描述各个步骤来分析记号串的输入。之所
linux和python学哪个好一些-作为一个Python自学者，怎样学好Python？
weixin_37988176的博客
10-30 941
想学习Python? 加群：778570108? ?分享资源和在线课堂，专业教学。对于有基础的更容易上手。可以根据计划进行学习，楼主是否有基础？不知道楼主进行到哪一步了。只要路线可以先把基础打好，后期多做一些项目之类的。目前，我按照计划进行一步一步的去学习，效果慢慢的就有了。当然你也可以看我的学习demo：Python基础：python：框架Django学习：python很简单，资源也很多。我的建...
如何自学python-作为一个Python自学者，怎样学好Python？
weixin_37988176的博客
10-29 281
想学习Python 加群：778570108 分享资源和在线课堂，专业教学。对于有基础的更容易上手。可以根据计划进行学习，楼主是否有基础？不知道楼主进行到哪一步了。只要路线可以先把基础打好，后期多做一些项目之类的。目前，我按照计划进行一步一步的去学习，效果慢慢的就有了。当然你也可以看我的学习demo：Python基础：python：框架Django学习：python很简单，资源也很多。我的建...
Java核心语法
小草莓的博客
04-29 396
基础通用语法一、标识符Identifier1、什么是标识符：2、标识符的命名规则：（不遵守会报错，如法律）3、标识符的命名规范：（不遵守会被谴责，如道德）二、常见关键字（均小写）三、字面值Const 一、标识符Identifier 1、什么是标识符： 凡是程序员有权利自己命名的单词都是标识符，EditPlus中是黑色高亮显示 类名，变量名，方法名，接口名，常量名 public class IdentifierTest{ //IdentifierTest是类名 public static void
C++长训基础@递归——拓展.pdf
06-10
在C++编程中，递归是一种强大的解决问题的方法，它涉及到函数调用自身的过程。递归在解决复杂问题时尤其有用，比如在处理分治策略、树遍历或像汉诺塔这样的经典问题时。汉诺塔问题是一个典型的递归实例，它的解决...
递归——放苹果
11-01
基本的递归程序，放苹果，基本思路就是找前后两个相同的步骤
Little-Chen-T#Zhihu#蓝桥杯冲刺训练营之递归——例3.第K个语法符号1
07-25
1. 题目 2. 解题思路 3. 代码
go标准库——优先级队列的实现
Go的全部
10-24 3098
package heap_test // priorty_queue是以个带权值观念的queue，它允许加入新元素，移除旧元素，审视元素值等功能 import ( "container/heap" "fmt" "testing" ) // Item 是我们在优先队列中管理的东西 type Item struct { value string // The value of the item; arbitrary. priority int // 队列中项目的优先级 // The
动态规划——编辑距离问题
最新发布
Go的全部
01-28 2526
动态规划——编辑距离问题
堆定制——1.0强耦合版
Go的全部
10-24 2237
package heap import ( "encoding/json" "fmt" "testing" ) //什么时候需要手写堆，需要更新堆中的某些值，让他自然有序 //迪杰斯特拉算法 就需要这类算法 // 从每个节点扫一遍， 代价会非常高 // 用户：可能对于某一个已经存在的对象，修改值， 在堆上找到，调整到该去的位置，logN级别 type student struct { Name string Age int Height int Weight int
上升子序列的最大长度，递归-记忆化搜索-动态规划三步走
Go的全部
01-27 2188
题目描述： 小明有一个数组，他想从数组任意元素开始向后遍历，找出所有上升子序列，并计算出最长的上升子序列的长度。 上升子序列的最大长度，递归-记忆化搜索-动态规划三步走
search——Bloom Filter
Go的全部
01-19 2185
BitMap
c++之递归进阶练习题
12-28
在进行递归进阶练习时，可以尝试一些复杂的递归问题，例如斐波那契数列、阶乘计算、汉诺塔问题等。这些问题可以帮助我们更深入地理解递归的原理和运行机制。当我们解决这些问题时，需要注意递归的边界条件和递归的层...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

metabit

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值