汉诺塔的递归学习，以及一些其中的一些规律
啥也不废话进入正题：
首先是经典的解法，即递归，过程大概如下图
实现的代码如下：
int steps = 0; int [] sData = new int[]{1,2,3,4,5,6}; int [] hData = new int[sData.length]; int [] tData = new int[sData.length]; @Test public void testHanoi(){ long start = new Date().getTime(); hanoi(sData.length,sData,hData,tData); long end = new Date().getTime(); System.out.println(Arrays.toString(tData)); System.out.println("共走了 ：" + steps + "步。" + "花费时间："+(end-start)); } /** * * @param n * @param sData : 待移动的集合 * @param hData ： 辅助空间 * @param tData ： 目标集合 */ // n:编号，x:待移动的集合 y:辅助空间 z:目标集合 private void hanoi(int n, int[] sData, int[] hData, int[] tData) { if(n == 1){ move(1,sData,tData); }else{ hanoi(n-1,sData,tData,hData); move(n , sData , tData ); hanoi(n-1,hData,sData,tData); } } private void move(int i, int[] sData, int[] tData) { tData[i-1] = sData[i-1]; sData[i-1] = 0; steps++; /*System.out.print("source:"+Arrays.toString(this.sData) + " target:"+Arrays.toString(this.tData) +" help:"); System.out.print(Arrays.toString(this.hData)+" "); System.out.println("将第"+i+"个方块从 "+judgeName(sData)+" 移动到 "+judgeName(tData));*/ } String judgeName(int []Data){ if(Data == this.sData){ return "source"; }else if(Data == this.tData){ return "target"; }else if(Data == this.hData){ return "help"; } return ""; }
由于有强迫症，硬是要用脑子去递归这块代码，结果大脑溢出了。。。，于是跟着debug跟了一下，算是稍微有点点收获（自己安慰自己），不管了，根据代码的流程来总结总结是到底怎么换的。
上级递归不断重复下级递归，每级递归都要走到最内层（最深层，方法栈最上层）递归才可以返回
这里特别要关注的是，不同角色的空间，传到下一级递归时候角色的转变 ， 所以返回上级递归，要根据入参规则转换一下 ， 不然还是很难理解返回的时候，参数的变换是什么意思，比如说上图 n=3时候的递归场景，返回到 n=4的递归场景，target和help要交换一下角色，才是这级递归对应的角色（因为入参的时候，是交换角色入参的）。
其实递归过程中最绕的就是这些参数角色之间的转换，但是真正存储的空间和含义（最外层递归定义的含义）只有一个，在调用自己的时候，可能会产生角色交换，所以导致大脑溢出。除了要搞清楚最原始定义的空间是怎么变化的，其他的还是很好理解的，递归嘛，感觉像是一种继承性，像是不断的 子承父业 子承父业 子承父业，直到断子绝孙了，你就可以返回，一直返回到祖宗十八代，就玩完了。
一下介绍一下非递归的算法的思想，很固定的套路
非递归算法描述如下：
首先容易证明，当盘子的个数为n时，移动的次数应等于2^n - 1。
一位美国学者发现一种出人意料的方法，只要轮流进行两步操作就可以了。
首先把三根柱子按顺序排成品字型，把所有的圆盘按从大到小的顺序放在柱子A上。
根据圆盘的数量确定柱子的排放顺序：若n为偶数，按顺时针方向依次摆放 A B C；
若n为奇数，按顺时针方向依次摆放 A C B。
（1）按顺时针方向把圆盘1从现在的柱子移动到下一根柱子，即当n为偶数时，若圆盘1在柱子A，则把它移动到B；
若圆盘1在柱子B，则把它移动到C；若圆盘1在柱子C，则把它移动到A。
（2）接着，把另外两根柱子上可以移动的圆盘移动到新的柱子上。
即把非空柱子上的圆盘移动到空柱子上，当两根柱子都非空时，移动较小的圆盘
这一步没有明确规定移动哪个圆盘，你可能以为会有多种可能性，其实不然，可实施的行动是唯一的。
（3）反复进行（1）（2）操作，最后就能按规定完成汉诺塔的移动。
啥时候也能有苹果光临光临咱们的脑瓜子呀。
实现代码：
int steps = 0 ;
@Test public void testHanoi2(){ LinkedList<Integer> source = new LinkedList<Integer>(); LinkedList<Integer> target = new LinkedList<Integer>(); LinkedList<Integer>help = new LinkedList<Integer>(); // 若source中有 偶数个元素 ， 那么 ， 最终全部转换到第三个容器 ； 为奇数的话，全部转换到第二个容器 LinkedList<Integer> [] datas = new LinkedList[3]; datas[0] = source; datas[1] = help; datas[2] = target; for(int i=5 ; i>0 ; i--){ source.push(i); } int count = source.size(); for(int j=0 ; target.size() != count ;j++){ int index = j%3; // 这个会是最终存储所有方块的容器的索引 int nexIndex =(index+1)%3 ; int otherIndex = (nexIndex+1)%3; datas[nexIndex].push(datas[index].pop()); steps++; if(datas[nexIndex].size() == count){ break; } if(datas[otherIndex].isEmpty() ){ datas[otherIndex].push(datas[index].pop()); }else if(datas[index].isEmpty()){ datas[index].push(datas[otherIndex].pop()); }else if(datas[index].peek()>datas[otherIndex].peek()){ datas[index].push(datas[otherIndex].pop()); }else if(datas[otherIndex].peek()>datas[index].peek()){ datas[otherIndex].push(datas[index].pop()); } steps++; } System.out.println(target); System.out.println(source); System.out.println(help); System.out.println("共花费："+steps); }
以上纯属个人观点，如有不对，还请大佬鞭策，谢谢大佬们
