Users Online

· Guests Online: 115

· Members Online: 0

· Total Members: 188
· Newest Member: meenachowdary055

Forum Threads

Newest Threads
No Threads created
Hottest Threads
No Threads created

Latest Articles

C# Program to Implement Quick sort

C# Program to Implement Quick sort

 

 

This is a C# Program to implement quick sort.

Problem Description

This C# Program Implements Quick Sort.

Problem Solution

Quicksort is a divide and conquer algorithm. Here Quicksort first divides a large array into two smaller sub-array: the low elements and the high elements. Quicksort can then recursively sort the sub-arrays

Program/Source Code

Here is source code of the C# Program to Implement Quick Sort. The C# program is successfully compiled and executed with Microsoft Visual Studio. The program output is also shown below.

/*
 *  C# Program to Implement Quick Sort
 */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace sortQuick
{
    class quickSort
    {
 
        private int[] array = new int[20];
        private int len;
 
        public void QuickSort()
        {
            sort(0, len - 1);
        }
 
        public void sort(int left, int right)
        {
            int pivot, leftend, rightend;
 
            leftend = left;
            rightend = right;
            pivot = array[left];
 
            while (left < right)
            {
                while ((array[right] >= pivot) && (left < right))
                {
                    right--;
                }
 
                if (left != right)
                {
                    array[left] = array[right];
                    left++;
                }
 
                while ((array[left] <= pivot) && (left < right))
                {
                    left++;
                }
 
                if (left != right)
                {
                    array[right] = array[left];
                    right--;
                }
            }
 
            array[left] = pivot;
            pivot = left;
            left = leftend;
            right = rightend;
 
            if (left < pivot)
            {
                sort(left, pivot - 1);
            }
 
            if (right > pivot)
            {
                sort(pivot + 1, right);
            }
        }
 
        public static void Main()
        {
            quickSort q_Sort = new quickSort();
 
            int[] array = { 4, 3, 1, 4, 6, 7, 5, 4, 32, 5, 26, 187, 8 };
            q_Sort.array = array;
            q_Sort.len = q_Sort.array.Length;
            q_Sort.QuickSort();
 
            for (int j = 0; j < q_Sort.len; j++)
            {
                Console.WriteLine(q_Sort.array[j]);
            }
            Console.ReadKey();
        }
    }
}
Program Explanation

This C# program is used to implement quick sort. We are creating an object ‘q_sort’ variable for quickSort() function. Quick sort is a divide and conquer algorithm. Here Quicksort first divides a large array into two smaller sub-array the low elements and the high elements. Quicksort() procedure can then recursively sort the sub-arrays.

 

In Quicksort() procedure, the ‘Partition()‘ function which divides array into two part (not necessarily equal) and then recursively calling the quicksort() procedure on divided arrays.

The QuickSort() procedure chooses a pivot element and rearranges the array such that all elements smaller than pivot are put before the pivot and all bigger elements are put at the end. We have actually found the correct position for pivot element and return the index of pivot element after rearranging the array.

Runtime Test Cases
 
1
3
4
4
4
5
5
6
7
8
26
32
187

 

Comments

No Comments have been Posted.

Post Comment

Please Login to Post a Comment.

Ratings

Rating is available to Members only.

Please login or register to vote.

No Ratings have been Posted.
Render time: 1.03 seconds
10,859,234 unique visits