Iteracyjny_MergeSort

using System;

namespace Algorytm_MergeSort_Iteracyjny
{
    class Program
    {
        static void mergeSort(char[] arr, int n)
        {

            // For current size of subarrays to
            // be merged curr_size varies from
            // 1 to n/2
            int curr_size;

            // For picking starting index of
            // left subarray to be merged
            int left_start;


            // Merge subarrays in bottom up
            // manner. First merge subarrays
            // of size 1 to create sorted
            // subarrays of size 2, then merge
            // subarrays of size 2 to create
            // sorted subarrays of size 4, and
            // so on.
            for (curr_size = 1; curr_size <= n - 1;
                          curr_size = 2 * curr_size)
            {

                // Pick starting point of different
                // subarrays of current size
                for (left_start = 0; left_start < n - 1;
                            left_start += 2 * curr_size)
                {
                    // Find ending point of left
                    // subarray. mid+1 is starting
                    // point of right
                    int mid = left_start + curr_size - 1;

                    int right_end = Math.Min(left_start
                                 + 2 * curr_size - 1, n - 1);

                    // Merge Subarrays arr[left_start...mid]
                    // & arr[mid+1...right_end]
                    merge(arr, left_start, mid, right_end);
                }
            }
        }


        static void merge(char[] arr, int l, int m, int r)
        {
            int i, j, k;
            int n1 = m - l + 1;
            int n2 = r - m;

            /* create temp arrays */
            char[] L = new char[n1];
            char[] R = new char[n2];

            /* Copy data to temp arrays L[]
            and R[] */
            for (i = 0; i < n1; i++)
                L[i] = arr[l + i];
            for (j = 0; j < n2; j++)
                R[j] = arr[m + 1 + j];

            /* Merge the temp arrays back into
            arr[l..r]*/
            i = 0;
            j = 0;
            k = l;
            while (i < n1 && j < n2)
            {
                if (L[i] >= R[j])
                {
                    arr[k] = L[i];
                    i++;
                }
                else
                {
                    arr[k] = R[j];
                    j++;
                }
                k++;
            }

            /* Copy the remaining elements of
            L[], if there are any */
            while (i < n1)
            {
                arr[k] = L[i];
                i++;
                k++;
            }

            /* Copy the remaining elements of
            R[], if there are any */
            while (j < n2)
            {
                arr[k] = R[j];
                j++;
                k++;
            }
        }

        /* Function to print an array */
        static void printArray(char[] A, int size)
        {
            int i;
            for (i = 0; i < size; i++)
                Console.Write(A[i] + " ");
            Console.WriteLine("");
        }


        static void Main(string[] args)
        {
            char[] arr = { 'A', 'B', 'C', 'D', 'E', 'F' };
            int n = arr.Length;

            Console.Write("Given array is \n");
            printArray(arr, n);

            mergeSort(arr, n);

            Console.Write("\nSorted array is \n");
            printArray(arr, n);
            Console.ReadKey();
        }
    }
}