quicksorrrtt

using System;

namespace zadanie2
{
    class Program
    {
        static int[] quickSort(string[] a, int start, int end)
        {
            int[] pomocnicza = new int[a.Length];
            int[] wynik = new int[a.Length];
            // index for the "left-to-right scan"
            int i = start;
            // index for the "right-to-left scan"
            int j = end;
            string[] kopia = new string[a.Length];
            Array.Copy(a, kopia,a.Length);

            // only examine arrays of 2 or more elements.
            if (j - i >= 1)
            {
                // The pivot point of the sort method is arbitrarily set to the first element int the array.
                string pivot = a[i];
                // only scan between the two indexes, until they meet.
                while (j > i)
                {
                    // from the left, if the current element is lexicographically less than the (original)
                    // first element in the String array, move on. Stop advancing the counter when we reach
                    // the right or an element that is lexicographically greater than the pivot String.
                    while (a[i].CompareTo(pivot) <= 0 && i < end && j > i)
                    {
                        i++;
                    }
                    // from the right, if t he current element is lexicographically greater than the (original)
                    // first element in the String array, move on. Stop advancing the counter when we reach
                    // the left or an element that is lexicographically less than the pivot String.
                    while (a[j].CompareTo(pivot) >= 0 && j > start && j >= i)
                    {
                        j--;
                    }
                    // check the two elements in the center, the last comparison before the scans cross.
                    if (j > i)
                        swap(a, i, j);


                }
                // At this point, the two scans have crossed each other in the center of the array and stop.
                // The left partition and right partition contain the right groups of numbers but are not
                // sorted themselves. The following recursive code sorts the left and right partitions.

                // Swap the pivot point with the last element of the left partition.
                swap(a, start, j);
                // sort left partition
                quickSort(a, start, j - 1);
                // sort right partition
                quickSort(a, j + 1, end);
            }

            for (int z = 0; z < a.Length; z++)
            {
                if (a[z] == kopia[z])
                {
                    pomocnicza[z] = z;
                }
                else if (a[z].CompareTo(kopia[z]) < 0)
                {
                    pomocnicza[z] = z + 1;
                }
                else
                {
                    pomocnicza[z] = z - 1;
                }
            }
            return pomocnicza;
        }

        static void swap(string[] a, int i, int j)
        {
            string temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }


        static void Main(string[] args)
        {
            string[] tab = { "Adam", "Zenek", "Barbara" };
            Console.WriteLine(String.Join(",", quickSort(tab, 0, tab.Length - 1)));
            foreach (string slowo in tab)
            {
                Console.WriteLine(slowo);
            }
            Console.ReadKey();
        }
    }
}