quicksort

using System;

namespace zadanie2
{
    class Program
    {
        static void quickSort(string[] a, int start, int end)
        {
            // index for the "left-to-right scan"
            int i = start;
            // index for the "right-to-left scan"
            int j = end;

            // 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);
            }
        }

        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" };
            quickSort(tab, 0, tab.Length - 1);
            foreach (string slowo in tab)
            {
                Console.WriteLine(slowo);
            }
            Console.ReadKey();
        }
    }
}