C# में KeyValuePair सूची को सॉर्ट करना

C# में List<KeyValuePair<TKey, TValue>> को सॉर्ट करने के लिए Sort() मेथड का उपयोग किया जाता है, जिसमें एक कस्टम तुलना डेलीगेट (comparison delegate) प्रदान किया जाता है।

उदाहरण: मान (Value) के अनुसार अवरोही क्रम में सॉर्टिंग

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // KeyValuePair सूची बनाएं
        var myList = new List>();
        
        // तत्व जोड़ें
        myList.Add(new KeyValuePair(1, 20));
        myList.Add(new KeyValuePair(2, 15));
        myList.Add(new KeyValuePair(3, 35));
        myList.Add(new KeyValuePair(4, 50));
        myList.Add(new KeyValuePair(5, 25));
        
        Console.WriteLine("असॉर्ट की गई सूची:");
        foreach (var pair in myList)
        {
            Console.WriteLine($"  [{pair.Key}, {pair.Value}]");
        }
        
        // मान (Value) के अनुसार अवरोही क्रम में सॉर्ट करें
        myList.Sort((x, y) => y.Value.CompareTo(x.Value));
        
        Console.WriteLine("\nमान के अनुसार अवरोही क्रम में सॉर्ट की गई सूची:");
        foreach (var pair in myList)
        {
            Console.WriteLine($"  [{pair.Key}, {pair.Value}]");
        }
    }
}

आउटपुट

असॉर्ट की गई सूची:
  [1, 20]
  [2, 15]
  [3, 35]
  [4, 50]
  [5, 25]

मान के अनुसार अवरोही क्रम में सॉर्ट की गई सूची:
  [4, 50]
  [3, 35]
  [5, 25]
  [1, 20]
  [2, 15]

विभिन्न सॉर्टिंग विकल्प

// 1. कुंजी (Key) के अनुसार आरोही क्रम
myList.Sort((x, y) => x.Key.CompareTo(y.Key));

// 2. कुंजी (Key) के अनुसार अवरोही क्रम
myList.Sort((x, y) => y.Key.CompareTo(x.Key));

// 3. मान (Value) के अनुसार आरोही क्रम
myList.Sort((x, y) => x.Value.CompareTo(y.Value));

// 4. मान (Value) के अनुसार अवरोही क्रम
myList.Sort((x, y) => y.Value.CompareTo(x.Value));

// 5. LINQ का उपयोग करके (नई सूची बनाता है, मूल को नहीं बदलता)
var sortedByKeyAsc = myList.OrderBy(p => p.Key).ToList();
var sortedByValueDesc = myList.OrderByDescending(p => p.Value).ToList();

// 6. जटिल सॉर्टिंग: पहले मान के अनुसार, फिर कुंजी के अनुसार
myList.Sort((x, y) => 
{
    int valueComparison = x.Value.CompareTo(y.Value);
    if (valueComparison != 0) return valueComparison;
    return x.Key.CompareTo(y.Key); // मान समान होने पर कुंजी से सॉर्ट
});

स्ट्रिंग कुंजी/मान के साथ उदाहरण

using System;
using System.Collections.Generic;

public class Demo
{
    public static void Main()
    {
        var products = new List>
        {
            new KeyValuePair("लैपटॉप", 55000),
            new KeyValuePair("माउस", 500),
            new KeyValuePair("कीबोर्ड", 1200),
            new KeyValuePair("मॉनिटर", 15000),
            new KeyValuePair("हेडफोन", 3000)
        };
        
        Console.WriteLine("मूल्य के अनुसार अवरोही क्रम:");
        products.Sort((x, y) => y.Value.CompareTo(x.Value));
        
        foreach (var p in products)
        {
            Console.WriteLine($"{p.Key}: ₹{p.Value:N0}");
        }
    }
}

आउटपुट

मूल्य के अनुसार अवरोही क्रम:
लैपटॉप: ₹55,000
मॉनिटर: ₹15,000
हेडफोन: ₹3,000
कीबोर्ड: ₹1,200
माउस: ₹500

महत्वपूर्ण बिंदु

• List.Sort() मूल सूची को स्थानांतरित (in-place) करता है
• LINQ OrderBy() नई सूची बनाता है, मूल अपरिवर्तित रहती है
• तुलना डेलीगेट: (x, y) => ... जहां नकारात्मक = x पहले, शून्य = समान, धनात्मक = y पहले
• CompareTo() तुलना के लिए मानक तरीका है
• कुंजी और मान दोनों पर सॉर्टिंग के लिए तुलना लॉजिक में दोनों का उपयोग करें