递归转非递归通用解决方案

递归转非递归总结

递归的时候，计算机透明的帮我们做了入栈，出栈等等操作，而且在入栈的时候，还记录了上下文信息，很重要的是记录了当此节点出栈后，应该继续从什么位置进行执行。

若我们自己进行递归转非递归，那么我们就得自己记录上面的信息了。入栈及记录出栈后从什么位置开始执行。

列子：
递归
public class Recursion {


public static int count = 0;
public static int childrenCount = 5;
public static void builderTree(int[] tree,int index) {
if(tree.length <= index) {
return ;
}
tree[index] = count++;

for (int i = childrenCount*index+1,j=0; j < childrenCount; j++,i++) {

builderTree(tree,i);
}
}


public static void main(String[] args) {

int[] tree = new int[500];
builderTree(tree, 0);

System.out.println(Arrays.toString(tree));

// visitTree(tree, 0);
NoneRecursion.visitTree(tree,childrenCount);
}


public static void visitTree(int[] tree,int index) {

if(tree.length <= index) {
return ;
}
System.out.println(tree[index]);

for (int i = childrenCount*index+1,j=0; j < childrenCount; j++,i++) {

visitTree(tree,i);
}
}
}




非递归：

public static void visitTree(int[] tree,int childrenCount) {

LinkedList<Node<Integer>> nodeList = new LinkedList<>(); //递归转非递归后，需要我们自己维护入栈、出栈了


int length = tree.length;

int index = 0;
int upDate = -1;
while(index < length || nodeList.size() > 0) {


while(index < length) {

if(! (tree[index] > upDate)) {
System.out.println(tree[index] > upDate);
}
upDate = tree[index];
Node<Integer> node = new Node<Integer>();
node.index = 2;
node.t = index;
nodeList.addLast(node); //入栈

index = index*childrenCount + 1; //进行第一个子节点操作
}

if(nodeList.size() == 0) {
break ;
}

Node<Integer> node = nodeList.getLast(); //获取栈中的元素
index = node.t*childrenCount + node.index; //计算需要访问的获取元素的哪一个子节点

if(node.index == childrenCount) { //若访问的子节点是获取元素的最后一个需要操作的子节点
nodeList.pollLast(); //就让此元素出栈
} else {
node.index++; //否则标记位下移，表示下次来访问此节点的子节点时候，是访问此次访问的后一个子节点
}
}
}


public static class Node<T>{

T t;
int index;
}



通用模型
public static void visitTree(Tree tree) {

LinkedList<Node<Integer>> nodeList = new LinkedList<>(); //递归转非递归后，需要我们自己维护入栈、出栈了

Tree h = tree;
while(h != null || nodeList.size() > 0) { //


while(h != null) {

visitNode(h); //访问节点操作

//入栈//
Node<Tree> node = new Node<Tree>();
node.index = 2;
node.t = h;
nodeList.addLast(node); //入栈



h = getChildrenOfIndex(h,1); //获取h的第一个子节点 这里完全可以使用钩子函数来实现
}

if(nodeList.size() == 0) {
break ;
}

Node<Tree> node = nodeList.getLast(); //获取栈中的元素
h = getChildrenOfIndex(node.t,node.index); //获取h的第一个子节点

if(h == null) { //若访问的子节点是获取元素的最后一个需要操作的子节点
nodeList.pollLast(); //就让此元素出栈
} else {
node.index++; //否则标记位下移，表示下次来访问此节点的子节点时候，是访问此次访问的后一个子节点
}
}
}


public static class Node<T>{

T t;
int index;
}