## Introduction to Bubble Sort in C#

The following article provides an outline on Bubble Sort in C#. Bubble sort is a sorting algorithm which is considered to be the simplest algorithm, which places the elements or numbers in a particular order and these elements are eventually put to their sorted proper location in the array.

### Bubble sort Algorithm

The basic concept upon which bubble sort works is that an array is taken into consideration. This array is iterated from the first index to the last index. While traversing the array is compared with the adjacent elements and swapped if they are present in the wrong order. This means if the numbers are smaller than the current element at a particular index then they will be swapped. This process is repeated until the array is completely sorted. It takes place in the form of passes.

Let us take into consideration an array of seven random numbers and sort them:

Bubble sort works in the form of passes. These passes take two adjacent numbers at a single time and then compare those two numbers. If the numbers present are said to be N. Then the number of passes required to sort a data set are N – 1. Each pass sorts the data considering those two numbers and reiterates the sequence till all numbers are not sorted in the expected way.

**Pass 1:**

90 76 45 93 68 13 98

In the first pass the first two numbers are compared. Here it will compare 90 with 76. 90 is greater than 76 hence it will be swapped.

76 90 45 93 68 13 98

Now 90 will be compared with 45. (0 is greater than 45 as well. Hence this will be getting swapped with 45.

76 45 90 93 68 13 98

Now, the numbers 90 and 93 are already in order. They will not be swapped and will remain as it is. This pass will hence be stopped as per the algorithm.

**Pass 2:**

76 45 90 93 68 13 98

This pass will again start with the first number in the array. This means the sorting will now start from 76. 76 will be compared with 45. 45 being lesser than 76 will be swapped with 76.

45 76 90 93 68 13 98

Now 76 and 90 will be checked. They are already in correct order hence there will be no changes in the array.

In this way the traversing will happen till the end of the array.

#### Algorithm of Bubble Sort

- BubbleSort(Array : list of sortable items)
- N= Array.Length
- Set Flag := True
- Repeat Steps from 3 to 5 for I = 1 to N-1 while Flag == true
- Set Flag := False
- Set i:=0
- Repeat while i<N-1 [Executing pass]
- (a) If Array[i+1]>Array[i], then:

Swap Array[i] and Array[i+1] Set Flag:= True - (b) Set i :=i+1
- Exit

### Examples of Bubble Sort in C#

Given below are the examples:

#### Example #1

C# program to implement Bubble sort.

**Code:**

```
using System;
class Bubble
{
static void bubbleSrt(int []arr)
{
int num = arr.Length;
for (int i = 0; i < num - 1; i++)
for (int j = 0; j < num - i - 1; j++)
if (arr[j] > arr[j + 1])
{
// swap tmp and arr[i]
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
}
/* Printing the array */
static void printIt(int []arr)
{
int n = arr.Length;
for (int i = 0; i < n; ++i)
Console.Write(arr[i] + " ");
Console.WriteLine();
}
// Main method
public static void Main()
{
int []arr = {90, 76, 45, 93, 68, 13, 98};
bubbleSrt(arr);
Console.WriteLine("Sorted array");
printIt(arr);
}
}
```

**Output:**

The program above has a method defined to sort the numbers using Bubble sort. Bubblesort has two for loops which traverse the array and store the number to be swapped in a temporary variable tmp. This tmp value is then swapped with the position where it should be with the help of index j. Another method is used to print the sorted array. Bubble sort makes use of n – 1 passes to sort the array.

The Bubble sort can be implemented for descending order as well.

#### Example #2

The C# program to implement Bubble sort in descending order can be as below:

**Code:**

```
using System;
public class BubbleSrt
{
public static void Main(string[] args)
{
int[]arr=new int[10]{23,98,45,12,9,16,65,74,34,29};//Array created with 10 unsorted numbers
bubblesort(arr,10);
int a;
for(a = 0; a < 10; a++)
Console.Write(arr[a]+"\t");//Printing the array after sorting in descending order
Console.ReadLine();
}
//bubble sort
static void bubblesort(int[] data, int n)
{
int a;
int b;
for(a = 0; a < n; a++)
for (b = n-1; b > a; b--)
if (data[b] > data[b-1])//Condition to arrange array in descending order
{
int temp = data[b];
data[b]=data[b-1];
data[b-1]=temp;
}
}
}
```

**Output:**

Here, we are sorting the array in descending order. We have declared an array having ten numbers. After that we are calling the bubblesort function in main program and then printing it in descending order. The bubblesort function here has taken two variables for traversing the array. Here it is taking two for loops and traversing the array and comparing the values present in the array. The condition being data present at index b and index b – 1 will be compared. If the number present at b is greater then it will be swapped. This is being done in the inner for loop. Once it is swapped, it will continue until the end of the array.

### Conclusion

Bubble sort is the simplest sorting method. It traverses the entire array and bubble pops the numbers which helps in swapping and bringing the array in correct sequence. It compares two adjacent numbers and pops those as and when they are not in the expected order. This sorting by using C# is very easy and can be done by using basic variables present in the array.

### Recommended Articles

This is a guide to Bubble Sort in C#. Here we discuss the introduction, bubble sort algorithm, and examples. You may also have a look at the following articles to learn more –