Learn Computer Science programming - C# and C++ Algorithms

 
Quick Sort

The quick sort is an in-place divide and conquer highly recursive algorithm. Silimar to the merge sort, but faster. It is difficult to code. If the array to be sorted contains one or fewer items, then finish. It picks an element in the array to serve as a pivot point, split the array into two parts, recursively repeat the algorithm for both halves of the original array. It is very fast, but very complex and very recursive algorithm.
Code
c_quick_sort.zip
File Size: 24 kb
File Type: zip
Download File

using System;
using System.Collections;

namespace Sort
{
    public class SortBubble
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main(string[] args)
        {
            int[] numbers = new int[] { 25, 57, 6, 9, 12, 65, 82, 36, 90 };
            int n;

            n = numbers.Length;
            Console.WriteLine("Before");
            Display(numbers);
            q_sort(numbers, 0, n - 1);
            Console.WriteLine("\r\nAfter");
            Display(numbers);
        }

        static void q_sort2(int[] numbers, int left, int right)
        {
            int pivot, l_hold, r_hold;


            l_hold = left;
            r_hold = right;
            pivot = numbers[left];
            while (left < right)
            {
                while ((numbers[right] >= pivot) && (left < right))
                    right--;
                if (left != right)
                {
                    numbers[left] = numbers[right];
                    left++;
                }
                while ((numbers[left] <= pivot) && (left < right))
                    left++;
                if (left != right)
                {
                    numbers[right] = numbers[left];
                    right--;
                }
            }
            numbers[left] = pivot;
            pivot = left;
            left = l_hold;
            right = r_hold;
            if (left < pivot)
                q_sort(numbers, left, pivot - 1);
            if (right > pivot)
                q_sort(numbers, pivot + 1, right);
        }

        static void q_sort(int[] numbers, int left, int right)
        {
            int LeftNumber, RightNumber;
            int mid, center;

            LeftNumber = left;
            RightNumber = right;
            mid = (left + right) / 2;
            center = numbers[mid];
            do
            {
                while (numbers[LeftNumber] < center)
                    LeftNumber++;
                while (center < numbers[RightNumber])
                    RightNumber--;
                if (LeftNumber <= RightNumber)
                {
                    int tmp = numbers[LeftNumber];
                    numbers[LeftNumber] = numbers[RightNumber];
                    numbers[RightNumber] = tmp;
                    LeftNumber++;
                    RightNumber--;
                }
            } while (LeftNumber < RightNumber);

            if (left < RightNumber) q_sort(numbers, left, RightNumber);
            if (LeftNumber < right) q_sort(numbers, LeftNumber, right);
        }

        static void Display(int[] numbers)
        {
            //Display Array Content
            IEnumerator sorted = numbers.GetEnumerator();
            while (sorted.MoveNext())
            {
                Console.WriteLine(sorted.Current);
            }
        }
    }
}