सी # कार्यात्मक Quicksort

Question

विफल रहा है मैं linq का उपयोग कर सी # का उपयोग कर एक कार्यात्मक शैली में quicksort लागू करने की कोशिश कर रहा हूँ, और यह कोड यादृच्छिक रूप से काम करता है/काम नहीं करता है, और मैं समझ नहीं सकता क्यों।
उल्लेख करने के लिए महत्वपूर्ण: जब मैं इसे किसी सरणी या सूची पर कॉल करता हूं, तो यह ठीक काम करता है। लेकिन पर एक अज्ञात-क्या यह वास्तव में-है IEnumerable, यह पागल (मान या दुर्घटनाओं, आम तौर पर कभी कभी काम करता है खो देता है।।) चला जाता है
कोड:

public static IEnumerable<T> Quicksort<T>(this IEnumerable<T> source) 
     where T : IComparable<T> 
    { 
     if (!source.Any()) 
      yield break; 
     var pivot = source.First(); 
     var sortedQuery = source.Skip(1).Where(a => a.CompareTo(source.First()) <= 0).Quicksort() 
          .Concat(new[] { pivot }) 
          .Concat(source.Skip(1).Where(a => a.CompareTo(source.First()) > 0).Quicksort()); 
     foreach (T key in sortedQuery) 
      yield return key; 
    } 

आप किसी भी दोष मिल सकता है यहां इससे असफल होने का कारण होगा?

संपादित करें: कुछ बेहतर परीक्षण कोड:

 var rand = new Random(); 
     var ienum = Enumerable.Range(1, 100).Select(a => rand.Next()); 
     var array = ienum.ToArray(); 
     try 
     { 
      array.Quicksort().Count(); 
      Console.WriteLine("Array went fine."); 
     } 
     catch (Exception ex) 
     { 
      Console.WriteLine("Array did not go fine ({0}).", ex.Message); 
     } 
     try 
     { 
      ienum.Quicksort().Count(); 
      Console.WriteLine("IEnumerable went fine."); 
     } 
     catch (Exception ex) 
     { 
      Console.WriteLine("IEnumerable did not go fine ({0}).", ex.Message); 
     } 

Answer 1

ऐसे एसक्यूएल या इकाई की रूपरेखा प्रश्नों का Linq से लौटे उन जैसे कुछ गणनीय उदाहरणों, केवल एक बार दोहराया जा करने के लिए डिजाइन किए हैं। आपके कोड को कई पुनरावृत्तियों की आवश्यकता है और इन प्रकार के उदाहरणों पर अजीब तरह से दुर्घटनाग्रस्त या व्यवहार करेंगे। आपको उन संख्याओं को ToArray() या पहले एक समान विधि के साथ पूरा करना होगा।

आपको भी pivot का पुन: उपयोग करना चाहिए ताकि आपको पहले और शेष तत्वों के लिए पुनरावृत्ति को रखने की आवश्यकता न हो। यह पूरी तरह से समस्या का समाधान नहीं हो सकता है, लेकिन यह कुछ मामलों में आपकी सहायता करेंगे: (। तुम भी sortedQuery के माध्यम से पुनरावृति की जरूरत नहीं है - बस इसे वापस, यह पहले से ही एक IEnumerable<T> है)

public static IEnumerable<T> Quicksort<T>(this IEnumerable<T> source) 
    where T : IComparable<T> 
{ 
    if (!source.Any()) 
     return source; 
    var pivot = source.First(); 
    var remaining = source.Skip(1); 
    return remaining 
     .Where(a => a.CompareTo(pivot) <= 0).Quicksort() 
     .Concat(new[] { pivot }) 
     .Concat(remaining.Where(a => a.CompareTo(pivot) > 0).Quicksort()); 
} 

संबंधित नोट पर, आपको इस कार्यक्षमता को फिर से कार्यान्वित करने की आवश्यकता क्यों महसूस होती है? Enumerable.OrderBy पहले से ही आपके लिए यह करता है।

---

रिस्पांस अद्यतन करने के लिए:

आपका परीक्षण असफल रहे हैं क्योंकि अपने परीक्षण गलत, नहीं एल्गोरिथ्म है।

Random एक गैर-निर्धारिती इनपुट स्रोत है और जैसा कि मैंने उपरोक्त समझाया है, सॉर्ट विधि को उसी अनुक्रम पर एकाधिक पुनरावृत्तियों को करने की आवश्यकता है। अगर अनुक्रम पूरी तरह यादृच्छिक है, तो इसे बाद के पुनरावृत्तियों पर अलग-अलग मान मिलेंगे। अनिवार्य रूप से, आप एक अनुक्रम को त्वरित रूप से करने की कोशिश कर रहे हैं जिनके तत्व बदलते रहते हैं!

यदि आप परीक्षण सफल होना चाहते हैं, तो आपको इनपुट संगत इनपुट करने की आवश्यकता है। यादृच्छिक संख्या जनरेटर के लिए एक बीज का उपयोग करें:

static IEnumerable<int> GetRandomInput(int seed, int length) 
{ 
    Random rand = new Random(seed); 
    for (int i = 0; i < length; i++) 
    { 
     yield return rand.Next(); 
    } 
} 

तब:

static void Main(string[] args) 
{ 
    var sequence = GetRandomInput(248917, 100); 
    int lastNum = 0; 
    bool isSorted = true; 
    foreach (int num in sequence.Quicksort()) 
    { 
     if (num < lastNum) 
     { 
      isSorted = false; 
      break; 
     } 
     lastNum = num; 
    } 
    Console.WriteLine(isSorted ? "Sorted" : "Not sorted"); 
    Console.ReadLine(); 
} 

यह वापस आ जाएगा अनुसार क्रमबद्ध।