Сортировка Слияния не через рекурсию!! - C#

Формулировка задачи:

Ребята, выручайте, срочно надо сделать сортировку СЛИЯНИЯ не через рекурсию... я ее вот так сделал

                    Листинг программы
                
 
                            
                        
private void LocalSort(int[] mass, int l, int r)
        { 
            if (l >= r) 
                return;
 
            int m = (l + r) / 2;
            LocalSort(mass, l, m);
            LocalSort(mass, m + 1, r);
            Merge(mass, l, m, r);
        }
 
        private void Merge(int[] mass, int l, int m, int r)
        {
            if (m + 1 > r) return;
 
            int[] b = new int[mass.Length];
            
            for (int i = l; i != m + 1; i++)
            {
                b[i] = mass[i];
            }
 
            for (int i = m + 1; i != r + 1; i++)
            {
                b[i] = mass[r + m + 1 - i];
            }
 
            int k = l; 
            int j = r; 
            for (int i = l; i != r + 1; i++)
            {
                Comparing(k, j); 
                if (b[k] <= b[j])
                {
                    UnPermutation(i, j);
                    mass[i] = b[k++];
                    Permutation(i, j);
                }
                else
                {
                    UnPermutation(i, j);
                    mass[i] = b[j--];
                    Permutation(i, j);
                }
            }
        }

А надо чтобы через перестановки....( я ваще в недоумении как это сделать? и ваще реально ли?

Решение задачи: «Сортировка Слияния не через рекурсию!!»

textual
                            Листинг программы 
                        
 
                            
                        
static Int32[] Merge_Sort(Int32[] massive)
        {
            if (massive.Length == 1)
                return massive;
            Int32 mid_point = massive.Length / 2;
            return Merge(Merge_Sort(massive.Take(mid_point).ToArray()), Merge_Sort(massive.Skip(mid_point).ToArray()));
        }
 
        static Int32[] Merge(Int32[] mass1, Int32[] mass2)
        {
            Int32 a = 0, b = 0;
            Int32[] merged = new int[mass1.Length + mass2.Length];
            for (Int32 i = 0; i < mass1.Length + mass2.Length; i++)
            {
                if (b < mass2.Length && a < mass1.Length)
                    if (mass1[a] > mass2[b] && b < mass2.Length)
                        merged[i] = mass2[b++];
                    else
                        merged[i] = mass1[a++];
                else
                    if (b < mass2.Length)
                        merged[i] = mass2[b++];
                    else
                        merged[i] = mass1[a++];
            }
            return merged;
        }
 
    static void Main(string[] args)
        {
              Int32[] arr = new Int32[100];
              //заполняем массив случайными числами
              Random rd = new Random();
              for(Int32 i = 0; i < arr.Length; ++i) {
                 arr[i] = rd.Next(1, 101);
              }
              System.Console.WriteLine("The array before sorting:");
              foreach (Int32 x in arr)
              {
                 System.Console.Write(x + " ");
              }
              //сортировка
 
              arr = Merge_Sort(arr);
 
              System.Console.WriteLine("\n\nThe array after sorting:");
              foreach (Int32 x in arr)
              {
                 System.Console.Write(x + " ");
              }
              System.Console.WriteLine("\n\nPress the <Enter> key");
              System.Console.ReadLine();
        }