Sorting algorithms/Bubble sort: Difference between revisions

 

=={{header|ActionScript}}==

public function bubbleSort(toSort:Array):Array

{

return toSort;

}

 

=={{header|Ada}}==

{{works with|GCC|4.1.2}}

 

generic

type Element is private;

New_Line;

end Main;

 

=={{header|ALGOL 68}}==

 

Assume numbers are in a DIM of size "size" called "nums".

DO

changed = 0

END IF

LOOP WHILE(NOT changed)

 

=={{header|C}}==

 

void swap(int *p)

{

} while (!sorted);

}

 

=={{header|C++}}==

{{works with|g++|4.0.2}}

 

#include <iostream>

#include <algorithm>

std::cout << std::endl ;

}

 

=={{header|C sharp|C#}}==

{{works with|C sharp|C#|3.0+}}

using System;

using System.Collections.Generic;

}

}

 

=={{header|Clean}}==

 

{{works with|DMD|1.025}}

import std.stdio;

 

writefln("array[%d] = %d", index, value);

}

 

=={{header|E}}==

=={{header|Fortran}}==

 

SUBROUTINE Bubble_Sort(a)

REAL, INTENT(in out), DIMENSION(:) :: a

END DO

END SUBROUTINE Bubble_Sort

 

=={{header|Haskell}}==

This version checks for changes in a separate step for simplicity, because Haskell has no variables to track them with.

bsort :: Ord a => [a] -> [a]

bsort s = case _bsort s of

| otherwise = x:(_bsort (x2:xs))

_bsort s = s

This version uses the polymorphic <tt>Maybe</tt> type to designate unchanged lists. (The type signature of <tt>_bsort</tt> is now <tt>Ord a => [a] -> Maybe [a]</tt>.) It is slightly faster than the previous one.

bsort :: Ord a => [a] -> [a]

bsort s = case _bsort s of

Just xs2 -> Just $ x:xs2

_bsort _ = Nothing

 

=={{header|Java}}==

Bubble sorting (ascending) an array of any <tt>Comparable</tt> type:

do{

boolean changed = false;

}

}while(!changed);

 

For descending, simply switch the direction of comparison:

if(comparable[a].compareTo(comparable[b]) < 0){

//same swap code as before

}

 

=={{header|JavaScript}}==

 

Array.prototype.bubblesort = function() {

var done = false;

return this;

}

 

{{works with|SEE|3.0}}

{{works with|OSSP js|1.6.20070208}}

Array.prototype.bubblesort = function() {

var done = false;

return this;

}

 

Example:

var my_arr = ["G", "F", "C", "A", "B", "E", "D"];

my_arr.bubblesort();

print(my_arr);

 

Output:

=={{header|Modula-3}}==

 

MODULE Bubble;

 

END sort;

END Bubble.

 

=={{header|OCaml}}==

 

This version checks for changes in a separate step for simplicity.

let rec bsort s =

let rec _bsort = function

if t = s then t

else bsort t

 

This version uses the polymorphic <tt>option</tt> type to designate unchanged lists. (The type signature of <tt>_bsort</tt> is now <tt>'a list -> 'a list option</tt>.) It is slightly faster than the previous one.

let rec bsort s =

let rec _bsort = function

| None -> s

| Some s2 -> bsort s2

 

=={{header|Perl}}==

{{works with|Perl|5.8.8}}

# Sorts an array in place and returns a copy

sub bubble_sort (@) {

return @_;

}

# usage

@a = qw/G F C A B E D/;

bubble_sort(@a);

 

Alternate "Long Hand" Perl Method

 

sub Bubble_Sort {

my @list = @_;

return @list;

}

# usage

my @test = (1, 3, 256, 0, 3, 4, -1);

print join(",", Bubble_Sort(@test));

 

=={{header|Pop11}}==

 

=={{header|Python}}==

def bubble_sort(seq):

"""Inefficiently sort the mutable sequence (list) in place.

bubble_sort(testcase)

assert testcase == testset # we've unshuffled it back into a copy

 

=={{header|Ruby}}==

Although the native Ruby sort method for Arrays if much faster (O(n*log(n)) versus O(n**2)), you can find a Ruby version of Bubble sort hereunder. It adds the bubblesort! method to the Array object. Below are two different methods that show four different iterating constructs in ruby.

 

class Array

def bubblesort1!

return self

end

def bubblesort2!

each_index do |index|

end

end

puts [3, 78, 4, 23, 6, 8, 6].bubblesort1!

# => [3, 4, 6, 6, 8, 23, 78]

 

=={{header|Scheme}}==

(define (bubble-sort x gt?)

(letrec

 

(fix sort-step x)))

 

This solution iteratively finds the fixed point of sort-step. A comparison function must be passed to bubblesort. Example usages:

(bubble-sort (list 1 3 5 9 8 6 4 2) >)

(bubble-sort (string->list "Monkey") char<?)

 

=={{header|Seed7}}==

A straight translation from the pseudocode above. Swap is done with a [[wp:Smalltalk#Code_blocks|block closure]].

 

|item swap itemCount hasChanged|

item := #(1 4 5 6 10 8 7 61 0 -3) copy.

hasChanged := true]].

hasChanged] whileTrue.

 

=={{header|Toka}}==

 

=={{header|UnixPipes}}==

rm -f _sortpass

 

 

cat to.sort | bubblesort