How do you write a C plus plus program that uses Bubble Sort?

Answer 1

template<class T>

void exch( T& x, T& y )

{

T tmp=x;

x=y;

y=tmp;

}

template<class T>

void bubble_sort( T A[], size_t size )

{

size_t last_exch, left, right;

while( size )

{

for( left=0, right=1, last_exch=left; right<size; ++left, ++right)

if( A[right]<A[left] )

exch( A[left], A[last_exch=right] );

size = last_exch;

}

}

Answer 2

Bubble Sort:

Bubble Sort works by repeatedly stepping through the array to be sorted, comparing each pair of adjacent items and swapping them if they are in the wrong order.

A C-language implementation for bubble sort is as follows:

void bubblesort (int a[], int size)

{

int j, temp;

while (size != 1) {

for(j = 1; j < size; j++)

if ( a[j-1] > a[j] )

{

temp = a[j-1];

a[j-1] = a[j];

a[j] = temp;

}

size--;

}

}

This function sorts an array of integers in ascending order. It can be called from main() function as: bubblesort (array, arraylength);

Answer 3

Note that Bubble Sort is one of the least efficient sorting algorithms, even when optimised. Due to its quadratic nature it is not at all suitable for sorting large sets, but even for small sets an Insert Sort will generally give better performance. Bubble Sort is typically cited as an example of how not to write an algorithm.

The following code demonstrates the optimal Bubble sort algorithm.

#include

#include

#include // for std::greater

template>

void bubblesort (std::vector& v) {

if (v.size() < 2) return; // sets of less than 2 do not need sorted

Compare cmp; // construct a comparison predicate

auto last = v.begin() + (v.size() - 1); // refer to last element of the unsorted set

while (v.begin() != last) { // repeat until unsorted set is empty

auto adj1 = v.begin(); // adjacent objects (1 and 2)

auto adj2 = adj1 + 1;

auto temp = v.begin(); // keeps track of where the last swap occurred

while (adj1 != last) { // repeat for all elements of the current unsorted set

if (!cmp (*adj1, *adj2)) { // compare the adjacent objects

std::swap (*adj1, *adj2); // objects are out of sequence, swap them

temp = adj1; // the last swap occurred here

}

++adj1; // advance adjacent objects by 1

++adj2;

}

last = temp; // the unsorted set ends at the last swap

}

}

template

std::ostream& operator<< (std::ostream& os, const std::vector& vct){

os << "{";

for (auto val : vct) os << val << ", ";

os << "\b\b}"; // backspace over trailing comma

return os;

}

int main () {

std::vector data {5, 6, 4, 7, 3, 8, 2, 9, 1};

std::cout << "Unsorted: " << data << std::endl;

bubblesort (data); // default sort uses std::less

std::cout << " Ascend: " << data << std::endl;

bubblesort> (data);

std::cout << " Descend: " << data << std::endl;

}