static List<int>Merge(List<int> list_a, List<int> list_b)
{
    List<int> list_c=new List<int>();
    
    int countA = 0, countB = 0;

        for (int i =0;i< list_a.Count + list_b.Count-2;i++)
        {
            if (list_a[countA]<=list_b[countB])
            {
                list_c.Add(list_a[countA]);
                countA ++;
            }
            else
            {
                list_c.Add(list_b[countB]);
                countB ++;
            }
        }
        return list_c;
    }

मेरा विचार लूप के माध्यम से कई बार जाना था कि अंत में कितने तत्व list_c होंगे, दोनों सूची में प्रत्येक तत्व की तुलना करें, फिर list_c में सबसे छोटा जोड़ें, मेरे पास यह जांचने का एक तरीका है कि दोनों सूचियां आरोही क्रम में हैं या नहीं मैं इसके साथ परीक्षण कर रहा हूँ

List<int> myList1 = new List<int> { 1, 2, 3, 7, 8, 9 };
List<int> myList2 = new List<int> { 4, 5, 6};
Console.WriteLine("new list :{ " + string.Join(",", Merge(myList1, myList2)));

एक बार सूची बी में अंतिम तत्व जोड़े जाने के बाद गिनती बी बाध्य हो जाती है, उस फॉर-लूप में अगली तुलना अमान्य है क्योंकि इसकी तुलना सूची_बी [3]

0
Paris 27 अगस्त 2021, 10:32

5 जवाब

सबसे बढ़िया उत्तर

ध्यान में रखते हुए कि आप चक्रों का उपयोग करना चाहते हैं:

public static List<int> Merge(List<int> list_a, List<int> list_b)
{
    int firstListIndexer = 0, secondListIndexer = 0;    
    List<int> list_c = new List<int>();

    // Traverse lists, until one of them run out of the elements
    while (firstListIndexer < list_a.Count && secondListIndexer < list_b.Count)
    {
        
        if (list_a[firstListIndexer] < list_b[secondListIndexer])
            list_c.Add(list_a[firstListIndexer++]);
        else
            list_c.Add(list_b[secondListIndexer++]);
    }
 
    // Store remaining elements of first list
    while (firstListIndexer < list_a.Count)
        list_c.Add(list_a[firstListIndexer++]);
 
    // Store remaining elements of second list
    while (secondListIndexer < list_b.Count)
        list_c.Add(list_b[secondListIndexer++]);
    return list_c;
}

साथ ही, आप इस विषय पर अपने ज्ञान को बेहतर बनाने के लिए इसे पढ़ सकते हैं।

0
Camilo Terevinto 27 अगस्त 2021, 07:59

छोटी सरणी पर आपकी अनुक्रमणिका इसकी अधिकतम अनुक्रमणिका से अधिक है। यह जांचने की आवश्यकता है कि क्या Count अधिकतम सूचकांक से अधिक है।

class Program {
  static List<int> Merge(List<int> list_a, List<int> list_b) {
    List<int> list_c = new List<int>();

    int countA = 0, countB = 0;

    for (int i = 0; i < list_a.Count + list_b.Count; i++) {
      if (countA < list_a.Count && countB < list_b.Count) {
        if (list_a[countA] <= list_b[countB]) {
          list_c.Add(list_a[countA]);
          countA++;
        }
        else {
          list_c.Add(list_b[countB]);
          countB++;
        }
      }
      else if (countA < list_a.Count) {
        list_c.Add(list_a[countA]);
        countA++;
      }
      else {
        list_c.Add(list_b[countB]);
        countB++;
      }

    }
    return list_c;
  }
  static void Main(string[] args) {
    List<int> myList1 = new List<int> { 1, 2, 3, 7, 8, 9 };
    List<int> myList2 = new List<int> { 4, 5, 6 };
    Console.WriteLine("new list :{ " + string.Join(",", Merge(myList1, myList2)) + "}");
  }
}
1
Rizquuula 27 अगस्त 2021, 08:29

यदि हम मान सकते हैं कि दोनों सूचियाँ आरोही क्रम में हैं तो आप आरोही क्रम का सम्मान करने के लिए इस तरह के संग्रह को मर्ज कर सकते हैं।

static List<int> MergeTowAscendinglyOrderedCollections(IEnumerable<int> collectionA, IEnumerable<int> collectionB)
{
    var result = new List<int>();
    IEnumerator<int> iteratorA = collectionA.GetEnumerator();
    IEnumerator<int> iteratorB = collectionB.GetEnumerator();

    bool doesIteratorAHaveRemainingItem = iteratorA.MoveNext();
    bool doesIteratorBHaveRemainingItem = iteratorB.MoveNext();

    void SaveIteratorAsCurrentAndAdvanceIt()
    {
        result.Add(iteratorA.Current);
        doesIteratorAHaveRemainingItem = iteratorA.MoveNext();
    }

    void SaveIteratorBsCurrentAndAdvanceIt()
    {
        result.Add(iteratorB.Current);
        doesIteratorBHaveRemainingItem = iteratorB.MoveNext();
    }

    do
    {
        if (iteratorA.Current < iteratorB.Current)
        {
            if (doesIteratorAHaveRemainingItem) SaveIteratorAsCurrentAndAdvanceIt(); 
            else SaveIteratorBsCurrentAndAdvanceIt();
        }
        else if (iteratorA.Current > iteratorB.Current)
        {
            if (doesIteratorBHaveRemainingItem) SaveIteratorBsCurrentAndAdvanceIt(); 
            else SaveIteratorAsCurrentAndAdvanceIt();
        }
        else if (iteratorA.Current == iteratorB.Current)
        {
            SaveIteratorAsCurrentAndAdvanceIt();
            SaveIteratorBsCurrentAndAdvanceIt();
        }

    } while (doesIteratorAHaveRemainingItem || doesIteratorBHaveRemainingItem);

    return result;
}

दोहराव के मामले में मैंने मर्ज की गई सूची में दोनों नंबर जोड़ दिए हैं लेकिन आपकी व्यावसायिक आवश्यकताओं के आधार पर आप परिणाम से एक या दोनों मानों को हटाने के लिए कोड को समायोजित कर सकते हैं।

0
Peter Csala 27 अगस्त 2021, 08:49

आप एक संघ कर सकते हैं

List<int> myList1 = new List<int> { 1, 2, 3, 7, 8, 9 };
List<int> myList2 = new List<int> { 4, 5, 6};

var merged = myList1.Union(myList2).OrderBy(o=>o).ToList();

foreach(int number in merged)
Console.WriteLine(number);

आउटपुट इस प्रकार है

1 2 3 4 5 6 7 8 9

0
thanzeel 27 अगस्त 2021, 11:47

यदि आपको अपना सर्फ़ लागू करना है:

Coroutines का उपयोग करके केवल कुछ पंक्तियों में कोई काउंटर और कोई अनुक्रमणिका के साथ कार्यान्वयन:

      class Program {
    
        static void Main() {

          List<int> l1 = new List<int>() { 9,8, 7, 5, 3, 1 };
          List<int> l2 = new List<int>() {12 ,10, 8, 6, 4, 2 };
          IEnumerable<int> res = MergeAscending(sl1, sl2);

          foreach (int item in res) {
            Console.Write($"{item},");
          }

          Console.Read();
        }
    
        static IEnumerable<T> MergeAscending<T>(IEnumerable<T> l1, IEnumerable<T> l2) where T : struct, IComparable, IComparable<T>, IConvertible, IEquatable<T>, IFormattable {
    
           IEnumerator<T> e1 = l1.AsParallel().OrderBy(e => e).GetEnumerator();
           IEnumerator<T> e2 = l2.AsParallel().OrderBy(e => e).GetEnumerator();

           IEnumerator<T> longest; //to yield longest list remains

//First move needed to init first "Current"
          e1.MoveNext();
          e2.MoveNext();
    
//yields smaller current value and move its IEnumerable pointer
//breaks while loop if no more values in some Enumerable and mark the other one as longest

          while (true) {
            if (e1.Current.CompareTo(e2.Current) < 0) {
              yield return e1.Current;
              if (!e1.MoveNext()) { longest = e2; break; }
            }
            else {
              yield return e2.Current;
              if (!e2.MoveNext()) { longest = e1; break; }
            }
          }

    //finish the longest Enumerator
          do {
            yield return longest.Current;
          } while (longest.MoveNext());
    
        }
      }

वैसे भी, मेरी सिफारिश टिप्पणियों में सियावश की तरह ही है:

var merged = myList1.Union(myList2).AsParallel().OrderBy(e => e).ToList();
0
jlvaquero 27 अगस्त 2021, 12:25