如何避免更改堆栈大小避免让C＃中的堆栈溢出(How do I avoid changing the

我一直在努力，现在找到了几个小时的回答这个问题，在网络上，并在这个网站，我不能令人信服。

据我所知，.NET 1MB分配给应用程序，而且它最好通过重新编码，而不是强迫堆栈大小，以避免堆栈溢出。

我工作的一个“最短路径”的应用程序，以约3000个节点，此时它溢出的伟大工程起来。下面是导致问题的方法：

    public void findShortestPath(int current, int end, int currentCost)
    {
        if (!weight.ContainsKey(current))
        {
            weight.Add(current, currentCost);
        }
        Node currentNode = graph[current];
        var sortedEdges = (from entry in currentNode.edges orderby entry.Value ascending select entry);
        foreach (KeyValuePair<int, int> nextNode in sortedEdges)
        {
            if (!visited.ContainsKey(nextNode.Key) || !visited[nextNode.Key])
            {
                int nextNodeCost = currentCost + nextNode.Value;
                if (!weight.ContainsKey(nextNode.Key))
                {
                    weight.Add(nextNode.Key, nextNodeCost);
                }
                else if (weight[nextNode.Key] > nextNodeCost)
                {
                    weight[nextNode.Key] = nextNodeCost;
                }
            }
        }
        visited.Add(current, true);
        foreach (KeyValuePair<int, int> nextNode in sortedEdges)
        {
            if(!visited.ContainsKey(nextNode.Key) || !visited[nextNode.Key]){
                findShortestPath(nextNode.Key, end, weight[nextNode.Key]);
            }
        }
    }//findShortestPath

作为参考，节点类具有一个成员：

 public Dictionary<int, int> edges = new Dictionary<int, int>();

图形[]是：

  private Dictionary<int, Node> graph = new Dictonary<int, Node>();

我试图opimize使得它没有携带不是从一个迭代（递归？）需要在未来的任何行李多的代码，但与1-9之间为每个节点100K节点图边它会打的1MB限制很快。

反正，我是新来的C＃代码优化，如果有人可以给我一些指点（不是这样），我将不胜感激。

Answer 1:

前阵子我在我的博客探讨这个问题。或者说，我摸索出了相关的问题：你如何找到一个二叉树的深度，而无需使用递归？递归树深度溶液是微不足道的，但吹堆如果树高度不平衡。

我的建议是研究解决这个问题的简单方法，然后决定哪些人，如果有的话，可以适应你稍微更复杂的算法。

请注意，这些文章中的例子是在JScript完全放弃。然而，它不应该是很难使之适应于C＃。

在这里，我们通过定义问题开始。

http://blogs.msdn.com/ericlippert/archive/2005/07/27/recursion-part-one-recursive-data-structures-and-functions.aspx

在解决方案的第一次尝试是典型的技术，你可能会采取：定义一个明确的堆栈; 使用它，而不是依赖于操作系统和编译器执行堆栈为您服务。这是当面对这个问题大多数人做的。

http://blogs.msdn.com/ericlippert/archive/2005/08/01/recursion-part-two-unrolling-a-recursive-function-with-an-explicit-stack.aspx

与解决方案的问题是，这是一个有点乱。我们可以有过之而无不及简单地使我们自己的堆栈。我们可以让我们自己的小领域特定的虚拟机都有自己的堆分配栈，然后通过编写一个程序，它针对的是机器解决问题！这是比它听起来其实更容易; 机器的操作可能会非常高的水平。

http://blogs.msdn.com/ericlippert/archive/2005/08/04/recursion-part-three-building-a-dispatch-engine.aspx

最后，如果你真的惩罚馋嘴（或编译器的开发者）可以在继续传递方式，从而消除了对堆栈有必要在所有重写你的程序：

http://blogs.msdn.com/ericlippert/archive/2005/08/08/recursion-part-four-continuation-passing-style.aspx

http://blogs.msdn.com/ericlippert/archive/2005/08/11/recursion-part-five-more-on-cps.aspx

http://blogs.msdn.com/ericlippert/archive/2005/08/15/recursion-part-six-making-cps-work.aspx

CPS是通过在一堆代表之间的关系编码它移动的隐含堆栈数据结构关闭系统堆栈和到堆上的一个特别聪明的方式。

这里是我所有的递归的文章：

http://blogs.msdn.com/ericlippert/archive/tags/Recursion/default.aspx

Answer 2:

经典的技术，以避免深递归栈潜水是简单地通过用合适的列表数据结构反复写算法和管理自己的“堆栈”避免递归。最有可能你会在这里需要这种方法给您输入的庞大规模设置。

Answer 3:

你可以将代码转换为使用“工作队列”，而不是递归。沿着下面的伪代码的东西：

Queue<Task> work;
while( work.Count != 0 )
{
     Task t = work.Dequeue();
     ... whatever
     foreach(Task more in t.MoreTasks)
         work.Enqueue(more);
}

我知道那是神秘的，但它是你需要做的基本概念。由于您只获得3000个节点与当前的代码，你会得到最好的12〜15K不带任何参数。所以，你需要彻底杀灭递归。