Éviter récursion

Question

J'ai une méthode, ce qui me donne le nombre de boîtes en fonction du nombre d'appareils il peut hold.Currently je l'ai mis en œuvre cette logique en utilisant récursion

private uint PerformRecursiveDivision(uint m_oTotalDevices,uint m_oDevicesPerBox, ref uint BoxesRequired) 
     { 
      if (m_oTotalDevices< m_oDevicesPerBox) 
      { 
       BoxesRequired = 1; 
      } 
      else if ((m_oTotalDevices- m_oDevicesPerBox>= 0) && (m_oTotalDevices- m_oDevicesPerBox) < m_oDevicesPerBox) 
      { 
       //Terminating condition 
       BoxesRequired++; 
       return BoxesRequired; 
      } 
      else 
      { 
       //Call recursive function 
       BoxesRequired++; 
       return PerformRecursiveDivision((m_oTotalDevices- m_oDevicesPerBox), m_oDevicesPerBox, ref BoxesRequired); 
      } 
      return BoxesRequired; 
     } 

Y at-il une meilleure méthode pour mettre en œuvre la même logique sans utiliser la récursivité. Parce que cette méthode rend mon application très lente pour les cas où le nombre de périphériques dépasse 50000.

Answer 1

Oui, vous pouvez utiliser la file d'attente pour éviter la récursivité. Smth comme ceci:

private void ProcessNonRecursively(string data) 
    { 
     Queue<string> queue = new Queue<string>(); 

     // Enque initiali data. 
     queue.Enqueue(data); 

     while (queue.Count > 0) 
     { 
      // Get current data. 
      string currentData = queue.Dequeue(); 

      // Process it here... 

      // Enque all data to be processed instead of calling the recursion. 
      foreach (string newData in someNewDataAfterProcessing) 
      { 
       queue.Enqueue(newData); 
      } 
     } 
    } 

Mais il semble que dans votre cas, vous n'avez pas besoin récursion/file d'attente du tout. Voir d'autres réponses

Answer 2

Que diriez-vous ceci:

int boxesRequired = m_oTotalDevices/m_oDevicesPerBox; 
if (m_oTotalDevices % m_oDevicesPerBox > 0) 
    boxesRequired++; 

return boxesRequired; 

Je ne vois pas pourquoi vous utiliseriez solution récursion ou même une file d'attente pour quelque chose comme ça.

Answer 3

Je pense que je dois être malentendu. Si vous devez déterminer le nombre de boîtes nécessaires pour tenir un certain nombre de dispositifs, il est trivial:

boxesRequired = ceil(totalDevices/devicesPerBox) 

... où ceil est une opération qui prend une valeur fractionnelle et arrondit au nombre entier le plus proche. (. Presque tous les environnements ont remarqué cette opération simplement votre tag .Net, il est Math.Ceiling en .Net, si vous utilisez JScript.Net c'est aussi Math.ceil parce que c'est une partie standard de JavaScript.)

Si vous devez faire purement avec les mathématiques entier:

boxesRequired = totalDevices/devicesPerBox 
if totalDevices mod devicesPerBox <> 0 then 
    increment boxesRequired 
endif 

Answer 4

il est fort probable que votre compilateur a déjà transformé cette récursion queue dans une boucle.