在循环内重写递归以仅使用循环

问题描述：

对于以下问题，我现在坐几个小时，我有一个代码，用于计算包中包含多少个盒子。为此，我计算每个软件包和复选框的包装盒。在循环内重写递归以仅使用循环

下面是代码：

private bool CalculateOnePackage(Package package, List<Item> workItems, List<Item> packagedItemsList) 
{ 
    if (workItems.Count == 0) 
    { 
    return true; 
    } 

    var packages = new List<Package>(); 
    Item tempItem = null; 
    foreach (Item entity in workItems) 
    { 
    if (/* execude code that changes entity and packages */) 
    { 
     tempItem = entity; 
     break; 
    } 
    } 

    if (tempItem == null) 
    { 
    return false; 
    } 

    packagedItemsList.Add(tempItem); 
    workItems.Remove(tempItem); 

    foreach (var p in packages) 
    { 
    this.CalculateOnePackage(p, workItems, packagedItemsList); 
    } 

    return true; 
}

我如何重写代码只使用循环？我们遇到问题，此代码导致*Exception。

使用与中断循环：也许（还更换一个简单的LINQ查询您的循环） – rashfmnb

然后，你正在循环所有软件包，包括你已经在其中的软件包。 – BugFinder

你可以使用['Queue '-class]（https://msdn.microsoft.com/zh-cn/ -us/library/7977ey2c（v = vs.110）.aspx）来避免'*Exception'。因此，将软件包添加到队列中，对其进行处理并将其从中删除。循环队列，而'queue.Count> 0' –

答

写这样的东西，但起初你应该调试和修复退货。另外，你的函数不使用Package包。

此外，您的函数不使用内部递归调用的结果。（它不返回或使用this.CalculateOnePackage（p，workItems，packagedItemsList）;）。在我意识到它之后，我停止了重写代码的尝试。但是，你可以阅读下面我uncomplete结果：

private bool CalculateOnePackage(Package package0, List<Item> workItems0, List<Item> packagedItemsList0) 
    { 
     var q = new Queue<Tuple<Package, List<Item>, List<Item>>>(); 
     q.Enqueue(new Tuple<Package, List<Item>, List<Item>>(package0, workItems0, packagedItemsList0)); 
     while (q.Count != 0) 
     { 
      var state = q.Dequeue(); 
      var package = state.Item1; 
      var workItems = state.Item2; 
      var packagedItemsList = state.Item3; 

      if (workItems.Count == 0) 
      { 
       return true; 
      } 

      var packages = new List<Package>(); 
      Item tempItem = null; 
      foreach (Item entity in workItems) 
      { 
       if (/* execude code that changes entity */) 
       { 
        tempItem = entity; 
        break; 
       } 
      } 

      if (tempItem == null) 
      { 
       return false; 
      } 

      packagedItemsList.Add(tempItem); 
      workItems.Remove(tempItem); 

      foreach (var p in packages) 
      { 
       q.Enqueue(new Tuple<Package, List<Item>, List<Item>>(p, workItems, packagedItemsList)); 
      } 
     } 


     return true; 
    }

答

您可以使用Queue<-class避免*Exception。因此，将包添加到队列中，然后对其进行处理并将其从中删除。循环队列，同时queue.Count > 0。

因为我不知道这个方法应该做什么，所以很难展现出一个很好的例子。当你达到你的一个包装盒最大限度地打破循环，如果你明白这一点的话，我会后的代码以及

private void CalculateOnePackage(Package package, List<Item> workItems) 
{ 
    Queue<Package> packages = new Queue<Package>(); 
    packages.Enqueue(package); 

    while (packages.Count > 0) 
    { 
     // method ProcessEntity adds package(s) to the queue 
     Item entityItem = workItems 
      .FirstOrDefault(item => ProcessEntity(item, packages)); 
     // do something with it if entityItem != null 
    } 
}

在循环内重写递归以仅使用循环

相关推荐