function burburja (myArray){ var tam = myArray.length; for ( var temp =1; temp < tam; temp++) { for (var izq = 0; izq< (tam - temp); izq++) { var dcha = izq+1; if (myArray[izq] < myArray[dcha] { ordenar(myArray, izq, dcha); } } }return myArray;}

bubbleSort(array)

  for i <- 1 to indexOfLastUnsortedElement-1

    if leftElement > rightElement

      swap leftElement and rightElement

end bubbleSort

Bubble sort, aka sinking sort is a basic algorithm

for arranging a string of numbers or other elements

in the correct order. This sorting algorithm is

comparison-based algorithm in which each pair of

adjacent elements is compared and the elements are

swapped if they are not in order. The algorithm then

repeats this process until it can run through the

entire string or other elements and find no two

elements that need to be swapped. This algorithm is

not suitable for large data sets as its average and

worst case complexity are of Ο(n2) where n is the number of items.

​

In general, Just like the movement of air bubbles

in the water that rise up to the surface, each element

of the array move to the end in each iteration.

Therefore, it is called a bubble sort.

#include <bits/stdc++.h>

​

using namespace std;

​

void bubbleSort(int arr[], int n){

    int temp,i,j;

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

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

            if(arr[i] > arr[j]){

                temp = arr[i];

                arr[i] = arr[j];

                arr[j] = temp;

            }

        }

    }

}

​

int main(){

    int arr[] = {1,7,33,9,444,2,6,33,69,77,22,9,3,11,5,2,77,3};

    int n = sizeof(arr) / sizeof(arr[0]);

​

    bubbleSort(arr, n);

​

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

        cout << arr[i] << " ";

    }

​

    return 0;

​

}

begin BubbleSort(list)

​

   for all elements of list

      if list[i] > list[i+1]

         swap(list[i], list[i+1])

      end if

   end for

   return list

end BubbleSort

procedure bubbleSort(arr: list of comparable items)

    n = length(arr)

    do

        swapped = false

        for i from 1 to n-1 inclusive do

            if arr[i-1] > arr[i] then

                swap(arr[i-1], arr[i])

                swapped = true

            end if

        end for

        n = n - 1

    while swapped is true

end procedure

​

​

In this pseudocode:

​

arr is the input array that needs to be sorted.

length(arr) gives the number of elements in the array.

The outer loop (while swapped is true) continues until no more swaps are needed.

The inner loop (for i from 1 to n-1 inclusive) goes through the array, compares adjacent elements, and swaps them if they are in the wrong order.

The swapped variable is used to track whether any swaps were made in a pass through the array. If no swaps are made, the array is considered sorted, and the algorithm terminates.

Note: The pseudocode uses 1-based indexing for the array. Adjustments may be needed if your programming language uses 0-based indexing. Additionally, the swap function is used to exchange the values of two elements.