Bubble sort  is a sorting algorithm that iterates through an array, comparing two  elements at a time and swapping if appropriate. On each pass, at least one value is placed in its final sorted location  (though it is possible that more are also placed in their final  location).

Big-O Notation:  Because the array must be iterated  over one time for every element in the array, the average runtime would  be quadratically proportional to the length of the array.  This means  that the average runtime complexity is expressed as .

The following implementation of the bubble sorting algorithm is  written in C# with a generic implementation that makes use of the IComparable interface so that any array containing an object that implements this interface can be sorted (integers, strings, characters, etc…)

public class BubbleSorter<T> where T : IComparable<T>
{
    public T[] Sort(T[] array)
    {
        bool swapFound;
        do
        {
            swapFound = false;
            
            // used to track the earliest point in the array that is fully sorted
            var firstSortedElement = array.Length;
            for (var i = 0; i < firstSortedElement - 1; i++)
            {
                var comparison = array[i].CompareTo(array[i + 1]);
                if (comparison > 0)
                {
                    swapFound = true;
                    firstSortedElement = i + 1;
                        
                    var temp = array[i + 1];
                    array[i + 1] = array[i];
                    array[i] = temp;                
                }
            }
        } while (swapFound);

        return array;
    }
}

In order to make use of this class, you would do something like the following:

var bubbleSorter = new BubbleSorter<int>();
var result = bubbleSorter.Sort(new[] {9, 5, 1, 4, 2, 8, 2});