An Ultimate Solution Guide on Sorting Algorithms in C#

In computer science, Sorting describes organizing in an ordered sequence. Numerous applications frequently use sorting, and effective algorithms to carry it out have been created. The most frequent applications for sorted sequences are efficient lookup, search, and merge of sequences and processing data in a predetermined order. Shuffling is the antithesis of Sorting, which is rearranging a series of things in an arbitrary or meaningless order.

In this "Sorting Algorithms in C#," you will explore the most important technical and practical aspects of typecasting and working around various types of variables.

Post Graduate Program: Full Stack Web Development

in Collaboration with Caltech CTMEEnroll Now
Post Graduate Program: Full Stack Web Development

What Is Sorting?

Sorting is the technique of putting the items of a collection in a certain order in C#. An array, a list, or other data set can be considered a collection. The collection may contain items of both simple and complex kinds. A simple type can be an array of integers, texts, floating-point values, and so on. 

A complex type might be a collection of objects of user-defined kinds like Employees, students, etc. Complex types are frequently nested, meaning the objects may have several characteristics. C# includes built-in methods for sorting collections. C# Sort() may sort an Array, List, or any Generic Collection depending on the Comparer. 

Now that we understand what Sorting is, let's discuss some basic Sorting methods.

Basic Sorting Methods

There are various Sorting methods available to sort an Array aside from our Sorting Algorithms.

We'll look at a few of them now.

  • Sort() Function

Code:

using System;

namespace Sort_method

{

    class Program

    {

        static void Main(string[] args)

        {

            // declaring and initializing the array

            int[] arr = new int[] {16, 29, 6, 17, 35, 19};

            Console.WriteLine("Unsorted Array: ");

            foreach(int value in arr)

            {

                Console.Write(value + " ");

            }

            // Sort array in ascending order.

            Array.Sort(arr);

            Console.WriteLine("\nUnsorted Array: ");

            // print all elements of the array

            foreach(int value in arr)

            {

                Console.Write(value + " ");

            }

        }

    }

}

Basic-Sortmethod-img1

Caltech Coding Bootcamp

Become a full stack developer in 6 monthsEnroll Now
Caltech Coding Bootcamp

  • CompareTo() Function

Code:

using System;

namespace Compareto_method

{

    class Program

    {

        static void Main(string[] args)

        {

            // declaring and initializing the array

            int[] arr = new int[] {16, 29, 6, 17, 35, 19};

            Console.WriteLine("Unsorted Array:");

            foreach(int value in arr)

            {

                Console.Write(value + " ");

            }

            // Sort the arr from first to Last.

            // compare every element to each other

            Array.Sort<int>(arr, new Comparison<int>(

                    (i1, i2) => i1.CompareTo(i2)));

            Console.WriteLine("\nSorted Array:");

            // print all elements of the array

            foreach(int value in arr)

            {

                Console.Write(value + " ");

            }

        }

    }

}

Basic-Compareto-img1.

Full Stack Web Developer Course

To become an expert in MEAN StackView Course
Full Stack Web Developer Course

  • Using Delegates Method:

Code:

using System;

namespace Using_Delegates

{

    class Program

    {

        static void Main(string[] args)

        {

            // declaring and initializing the array

            int[] arr = new int[] {16, 29, 6, 17, 35, 19};

            Console.WriteLine("Unsorted Array: ");

            foreach(int value in arr)

            {

                Console.Write(value + " ");

            }

            // Sort the arr from first to last

            Array.Sort<int>(arr, delegate(int m, int n)

                                    { return m - n; });

            Console.WriteLine("\n\nSorted Array: ");

            // print all elements of the array

            foreach(int value in arr)

            {

                Console.Write(value + " ");

            }

        }

    }

}

Basic-Delegates-img1.

  • Using Linq Library Functions

Code:

using System;

using System.Linq; 

namespace Using_LINQ

{

    class Program

    {

        static void Main(string[] args)

        {

            // declaring and initializing the 

            // array with six positive number

            int[] arr = new int[] {16, 29, 6, 17, 35, 19};

            Console.WriteLine("Unsorted Array:");

            foreach(int value in arr)

            {

                Console.Write(value + " ");

            }

            // Sort the arr in Increasing order

            // and return an array

            arr = arr.OrderBy(c => c).ToArray();

            Console.WriteLine("\n\nSorted Array:");

            // print all elements of the array

            foreach(int value in arr)

            {

                Console.Write(value + " ");

            }

        }

    }

}

Basic-Linq-img1.

Full Stack Java Developer Course

In Partnership with HIRIST and HackerEarthEXPLORE COURSE
Full Stack Java Developer Course

  • Iterative Method

Code:

using System;

namespace Iterative

{

    class Program

    {

        static void Main(string[] args)

        {

            int[] arr = new int[] {16, 29, 6, 17, 35, 19};

            int temp;

            //Print the Unsorted Array

            Console.WriteLine("Unsorted Array:");

            foreach(int x in arr)

            {

                Console.Write(x + " ");

            }

            // traverse 0 to array length

            for(int itr1=0; itr1<arr.Length-1;itr1++)

                // traverse i+1 to array length

                for(int itr2=itr1+1;itr2<arr.Length;itr2++)    

             // compare array element with all next element

                    if (arr[itr1] > arr[itr2]) {   

                        temp = arr[itr1];

                        arr[itr1] = arr[itr2];

                        arr[itr2] = temp;

                    }

            Console.WriteLine("\n\nSorted Array:");

            // print all elements of the array

            foreach(int x in arr)

            {

                Console.Write(x + " ");

            }

        }

    }

}

Basic-Iterative-img1

Now let's check out various Sorting Algorithms.

New Course: Full Stack Development for Beginners

Learn Git Command, Angular, NodeJS, Maven & MoreEnroll Now
New Course: Full Stack Development for Beginners

Sorting Algorithms

We will discuss the Sorting Algorithms given Below and the logic behind them.

  1. Bubble Sort
  2. Insertion Sort
  3. Selection Sort
  4. Quick Sort

Let's discuss each of them in Detail.

Bubble Sort Algorithm

Logic:

Article-BubbleSort-img1

We will start with the first two elements and compare them. If the first is bigger than the second, we will switch them. And then, we will move on to the next set of pairs. We will repeat this with the next set of pairs as well.

Article-BubbleSort-img2

Once we have reached the end, we will go into the second iteration and repeat the last step.

Article-BubbleSort-img3

As you can check the image above, the array is sorted. But our algorithm doesn't know that. So we will go into the third iteration. And let's say if we don't find any swaps, we will declare it to be a sorted array.

Code:

using System;

namespace Bubble_Sort

{

    class Program

    {

        static void bubbleSort(int[] arr)

        {

            int n = arr.Length;

            for (int i = 0; i < n - 1; i++)

                for (int j = 0; j < n - i - 1; j++)

                    if (arr[j] > arr[j + 1]) {

                        // swap temp and arr[i]

                        int temp = arr[j];

                        arr[j] = arr[j + 1];

                        arr[j + 1] = temp;

                    }

        }   

        /* Prints the array */

        static void printArray(int[] arr)

        {

            int n = arr.Length;

            for (int i = 0; i < n; ++i)

                Console.Write(arr[i] + " ");

            Console.WriteLine();

        }    

        // Driver method

        public static void Main()

        {

            int[] arr = { 4, 2, 1, 8, 3};

            Console.WriteLine("Unsorted array:");

            printArray(arr);

            bubbleSort(arr);

            Console.WriteLine("\nSorted array:");

            printArray(arr);

        }

    }

}

Article-BubbleSort-img4.

FREE Java Certification Training

Learn A-Z of Java like never beforeEnroll Now
FREE Java Certification Training

Insertion Sort Algorithm

Logic:

Article-InsertionSort-img1

Let's say we have an array. We will start with traversing the array from index 1 to n-1.

Article-InsertionSort-img2

While traversing, we will compare elements in the current index to its predecessor.

Article-InsertionSort-img3

If data at the current index is smaller than its predecessor, then we will compare it with the element before that.

Article-InsertionSort-img4

Then, We will shift a bigger element to an index up to make space for the swapped element, and then we will iterate the same steps again to sort the complete array.

Code:

using System;

namespace Insertion_Sort

{

    class InsertionSort

    {

        // Function to sort array

        // using insertion sort

        void sort(int[] arr)

        {

            int n = arr.Length;

            for (int i = 1; i < n; ++i) {

                int key = arr[i];

                int j = i - 1;

                // Move elements of arr[0..i-1],

                // that is greater than key,

                // to one position ahead of

                // their current position

                while (j >= 0 && arr[j] > key) {

                    arr[j + 1] = arr[j];

                    j = j - 1;

                }

                arr[j + 1] = key;

            }

        }  

        // A utility function to print

        // array of size n

        static void printArray(int[] arr)

        {

            int n = arr.Length;

            for (int i = 0; i < n; ++i)

                Console.Write(arr[i] + " ");  

            Console.Write("\n");

        }   

        // Driver Code

        public static void Main()

        {

            int[] arr = { 6, 5, 4, 2, 3 };

            Console.WriteLine("Unsorted array:");

            printArray(arr);

            InsertionSort IS = new InsertionSort();

            IS.sort(arr);

            Console.WriteLine("\nSorted array:");

            printArray(arr);

        }

    }

}

Article-InsertionSort-img5

Free Course: Programming Fundamentals

Learn the Basics of ProgrammingEnroll Now
Free Course: Programming Fundamentals

Selection Sort Algorithm

Logic:

Article-SelectionSort-img1

Let's say we have an array. First, we will divide this array into two subarrays: unsorted and sorted Subarray.

Article-SelectionSort-img2

Then, we will find the minimum element from the unsorted array and swap it with the leftmost element of this unsorted array. After that, we will add it to the sorted array. 

Article-SelectionSort-img3

We will keep repeating this process until no elements are left on the unsorted array.

Article-SelectionSort-img4

Code:

using System;

namespace Selection_Sort

{

    class Program

    {

        static void sort(int []arr)

        {

            int n = arr.Length;    

          // One by one move boundary of unsorted Subarray

            for (int i = 0; i < n - 1; i++)

            {

          // Find the minimum element in the unsorted array

                int min_idx = i;

                for (int j = i + 1; j < n; j++)

                    if (arr[j] < arr[min_idx])

                        min_idx = j;

   // Swap the found minimum element with the first element

                int temp = arr[min_idx];

                arr[min_idx] = arr[i];

                arr[i] = temp;

            }

        }    

        // Prints the array

        static void printArray(int []arr)

        {

            int n = arr.Length;

            for (int i=0; i<n; ++i)

                Console.Write(arr[i]+" ");

            Console.WriteLine();

        }    

        // Driver code

        public static void Main()

        {

            int []arr = { 4, 2, 1, 8, 3 };

            Console.WriteLine("Unsorted array:");

            printArray(arr);

            sort(arr);

            Console.WriteLine("\nSorted array:");

            printArray(arr);

        }

    }

}

Article-SelectionSort-img5

Quick Sort Algorithm

Logic:

Article-QuickSort-img1

Let's say we have an array. First, We have to select a pivot. We can select the first element, the last or median, or any random element as pivots.

Article-QuickSort-img2

This pivot will dissect the array in two sub-arrays then we will shift all smaller elements from the pivot element to the left.

Article-QuickSort-img3

Then we will again apply the same operation for the left Subarray and take pivot as we did for the main array.

Article-QuickSort-img4

We will perform the same for the right Subarray as well.

Code:

using System;

namespace Quick_Sort

{

    class Program

    {

        // A utility function to swap two elements

        static void swap(int[] arr, int i, int j)

      {

            int temp = arr[i];

            arr[i] = arr[j];

            arr[j] = temp;

        }

        

   /* 

This function uses the last element as a pivot and arranges all other elements so that all smaller elements are placed to the left of the pivot and all larger elements are placed to the right of the pivot in a sorted array.

   */

        static int partition(int[] arr, int low, int high)

        {        

            // pivot

            int pivot = arr[high];

            // Index of smaller elements and

            // indicates the right position

            // of pivot found so far

            int i = (low - 1);        

            for (int j = low; j <= high - 1; j++)

            {

            // If the current element is smaller 

            // than the pivot

            if (arr[j] < pivot)

            {       

                // Increment index of 

                // smaller element

                i++;

                swap(arr, i, j);

            }

            }

            swap(arr, i + 1, high);

            return (i + 1);

        }       

        /* The main function that implements QuickSort

                    arr[] --> Array to be sorted,

                    low --> Starting index,

                    high --> Ending index

            */

        static void quickSort(int[] arr, int low, int high)

        {

            if (low < high)

            {        

            // pi is partitioning index, arr[p]

            // is now at right place 

            int pi = partition(arr, low, high);        

            // Separately sort elements before

            // partition and after partition

            quickSort(arr, low, pi - 1);

            quickSort(arr, pi + 1, high);

            }

        }

        // Function to print an array 

        static void printArray(int[] arr, int size)

        {

            for (int i = 0; i < size; i++)

            Console.Write(arr[i] + " ");        

            Console.WriteLine();

        }

        // Driver Code

        public static void Main()

        {

            int[] arr = { 6, 9, 5, 2, 3 };

            int n = arr.Length;

            Console.Write("Unsorted array: ");

            printArray(arr, n);

            quickSort(arr, 0, n - 1);

            Console.Write("\nSorted array: ");

            printArray(arr, n);

        }

    }}

QuickSort-img5.

You have a good command of Sorting Algorithms' technical and theoretical aspects in C#. Check out what's next in your journey to master C# programming.

Master front-end and back-end technologies and advanced aspects in our Post Graduate Program in Full Stack Web Development. Unleash your career as an expert full stack developer. Get in touch with us NOW!

Next Steps

You can start with "Boxing and Unboxing in C#" as your next Chapter in your path to conquering C# Programming. A value type can be "boxed" into any object or interface type that it implements. The process of changing an object type parameter into a value type parameter is known as unboxing. If you want to unbox an object into a unique data type than its original, you have to double typecast.

If you want to master skills relevant to today's economy, you should enroll at Simplilearn, the world's most popular online Bootcamp for doing just that. Topics like data science and digital marketing are covered in our online courses.

You've found the appropriate location to hone your software development skills and prepare for an industry career. Software Development courses from both the Indian Institute of Technology (IIT) in Kanpur and the California Institute of Technology (CaltechCenter ) 's for Technology Management and Education (CTME) are available through Simplilearn. Data structures and algorithms, as well as more advanced subjects like Competitive Programming, are covered in these classes. As a software engineer, you'll have experience working with various data structures, such as trees, graphs, and queues.

If you have questions about this "Sorting Algorithm in C#" lesson, feel free to post them in the comments section. Good luck with a productive educational experience!

About the Author

SimplilearnSimplilearn

Simplilearn is one of the world’s leading providers of online training for Digital Marketing, Cloud Computing, Project Management, Data Science, IT, Software Development, and many other emerging technologies.

View More
  • Disclaimer
  • PMP, PMI, PMBOK, CAPM, PgMP, PfMP, ACP, PBA, RMP, SP, and OPM3 are registered marks of the Project Management Institute, Inc.
  • *According to Simplilearn survey conducted and subject to terms & conditions with Ernst & Young LLP (EY) as Process Advisors