Sorting algorithms/Cocktail sort: Difference between revisions

'''function''' ''cocktailSort''( A : list of sortable items )

'''do'''

'''while''' swapped; ''// if no elements have been swapped,''

''// then the list is sorted''

 

=={{header|ActionScript}}==

do {

var swapped:Boolean=false;

} while (swapped);

return input;

 

=={{header|Ada}}==

 

procedure Cocktail_Sort_Test is

Cocktail_Sort(Data);

Put_Line(Data);

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

PROC swap = (REF DATA a,b)VOID:(

DATA tmp:=a; a:=b; b:=tmp

[32]CHAR data := "big fjords vex quick waltz nymph";

cocktail sort(data);

Alternatively - when the data records are large - the data can be manipulated

indirectly, thus removing the need to actually swap large chunks of memory

as only addresses are swapped.

PROC swap = (REF DATA a,b)VOID:(

DATA tmp:=a; a:=b; b:=tmp

cocktail sort(ref data);

FOR i TO UPB ref data DO print(ref data[i]) OD; print(new line);

big fjords vex quick waltz nymph</pre>

FOR offset FROM 0 DO

BOOL swapped := FALSE;

OD;

break do od loop: SKIP

=={{header|AutoHotkey}}==

contributed by Laszlo on the ahk [http://www.autohotkey.com/forum/post-276379.html#276379 forum]

MsgBox % CocktailSort("xxx")

MsgBox % CocktailSort("3,2,1")

sorted .= "," . array%A_Index%

Return SubStr(sorted,2) ; drop leading comma

 

=={{header|AWK}}==

Sort the standard input and print it to standard output

line[NR] = $0

}

print line[i]

}

 

=={{header|BBC BASIC}}==

Sorting an integer array. '%' indicates integer variable in BBC BASIC

 

Start%=2

UNTIL ( ( End% * Direction% ) < ( Start% * Direction% ) )

 

 

=={{header|C}}==

 

}

}

 

 

return 0;

 

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

{

bool swapped;

//if no elements have been swapped, then the list is sorted

} while (swapped);

 

 

 

C-000.

DISPLAY "SORT STARTING".

 

F-999.

 

=={{header|Common Lisp}}==

This version works on lists and vectors alike. The vector implementation is coded directly. The list version uses an intermediate vector.

(labels ((scan (start step &aux swapped)

(loop for i = start then (+ i step) while (< 0 i len) do

(list (map-into sequence 'identity

(cocktail-sort-vector (coerce sequence 'vector)

 

=={{header|D}}==

 

foreach (i; 0 .. data.length - 1)

if (!swapped)

break;

swapped = false;

foreach_reverse (i; 0 .. data.length - 1)

} while(swapped);

}

 

void main() {

 

=={{header|Delphi}}==

 

Static array is an arbitrary-based array of fixed length

 

{$APPTYPE CONSOLE}

Writeln;

Readln;

<pre>

0 3 86 20 27 67 31 16 37 42 8 47 7 84 5 29

 

=={{header|E}}==

def cocktailSort(array) {

def swapIndexes := 0..(array.size() - 2)

}

}

Note that this solution contains no repeated code to handle the forward and reverse passes.

 

=={{header|Euphoria}}==

integer swapped, d

object temp

constant s = rand(repeat(1000,10))

? s

<pre>{963,398,374,455,53,210,611,285,984,308}

{53,210,285,308,374,398,455,611,963,984}

</pre>

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

IMPLICIT NONE

 

END SUBROUTINE Cocktail_sort

 

 

=={{header|Go}}==

 

import "fmt"

}

}

More generic version that sorts anything that implements <code>sort.Interface</code>:

 

import (

}

}

 

=={{header|Groovy}}==

Solution:

def checkSwap = { a, i, j = i+1 -> [(a[i] > a[j])].find{ it }.each { makeSwap(a, i, j) } }

}

list

Test:

println cocktailSort([88,18,31,44,4,0,8,81,14,78,20,76,84,33,73,75,82,5,62,70,12,7,1])

 

println cocktailSort([ 3, 14, 1, 5, 9, 2, 6, 3 ])

println cocktailSort([ 3, 14 ])

<pre>..............................................................................................................................................[4, 12, 14, 23, 24, 24, 31, 35, 38, 46, 51, 57, 57, 58, 76, 78, 89, 92, 95, 97, 99]

.........................................................................................................................................[0, 1, 4, 5, 7, 8, 12, 14, 18, 20, 31, 33, 44, 62, 70, 73, 75, 76, 78, 81, 82, 84, 88]

 

=={{header|Haskell}}==

cocktailSort l

| not swapped1 = l

| otherwise = swappingPass op (swapped, x1 : l) (x2 : xs)

swappingPass _ (swapped, l) [x] = (swapped, x : l)

 

=={{header|Io}}==

cocktailSortInPlace := method(

start := 0

 

l := list(2, 3, 4, 5, 1)

 

 

=={{header|J}}==

{{eff note|J|/:~}}

smallToLeft=: (([ (<. , >.) {.@]) , }.@])/

Test run:

4 6 8 6 5 8 6 6 6 9

cocktailSort ?. 10 $ 10

As is usual with J, <code>/:~</code> is the preferred method of sorting in practice.

 

=={{header|Java}}==

boolean swapped;

swapped = false;

if (A[ i ] > A[ i + 1 ]) {

//test whether the two elements are in the wrong order

}

swapped = false;

int temp = A[i];

A[i] = A[i+1];

//if no elements have been swapped, then the list is sorted

} while (swapped);

 

 

local swapped

repeat

 

until swapped==false

cocktailSort(list)

for i=1,#list do

print(list[i]j)

 

 

While[ swapped == True,

swapped=False;

For [ i= Length[A]-1, i > 0, i--,

If[ A[[i]] > A[[i+1]], A[[i;;i+1]] = A[[i+1;;i;;-1]]; swapped = True;]

<pre>cocktailSort[{2,1,5,3,6}]

->{1,2,3,5,6}</pre>

 

=={{header|MATLAB}} / {{header|Octave}}==

%We have to do this because the do...while loop doesn't exist in MATLAB

end %for

end %while

 

ans =

 

 

=={{header|MAXScript}}==

(

local swapped = true

)

return arr

 

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols binary

 

end i_

if \swapped then do

end

swapped = isFalse

 

method isFalse public constant binary returns boolean

<pre>

UK London

US Washington

</pre>

 

=={{header|Objeck}}==

class Cocktail {

function : Main(args : String[]) ~ Nil {

}

}

 

=={{header|OCaml}}==

let tmp = a.(i) in

a.(i) <- a.(j);

Array.iter (Printf.printf " %d") a;

print_newline();

1 2 3 4 5 6 7 8 9

 

=={{header|Octave}}==

swapped = true;

while(swapped)

endwhile

sl = l;

1, 8, 6, 2, 3 ]);

 

=={{header|Oz}}==

proc {CocktailSort Arr}

proc {Swap I J}

in

{CocktailSort Arr}

 

=={{header|PARI/GP}}==

while(1,

my(done=1);

if(done, return(v))

)

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

use warnings;

 

my $swapped_forward = 0;

$swapped_forward = 1;

}

last if not $swapped_forward;

 

my $swapped_backward = 0;

$swapped_backward = 1;

}

last if not $swapped_backward;

}

}

 

 

=={{header|PHP}}==

if (is_string($arr)) $arr = str_split(preg_replace('/\s+/','',$arr));

 

echo implode(',',$arr) . '<br>';

echo implode(',',$arr2) . '<br>';

<pre>

1,2,3,4,5,6,7

 

=={{header|PicoLisp}}==

(use (Swapped L)

(loop

(on Swapped) )

(T (== Lst L)) )

<pre>: (cocktailSort (make (do 9 (link (rand 1 999)))))

-> (1 167 183 282 524 556 638 891 902)

 

=={{header|PL/I}}==

declare A(*) fixed;

declare t fixed;

end;

end;

=={{header|PowerShell}}==

Based on the entry for PowerShell in [[Bubble Sort]]

$l = $a.Length

$m = 0

}

 

 

=={{header|PureBasic}}==

The following approach improves on the method in the pseudo-code by not examining indexes on either end of the array that have already been sorted by reducing the index range on each subsequent pass.

Procedure cocktailSort(Array a(1))

Protected index, hasChanged, low, high

low + 1

Until hasChanged = #False ;if no elements have been changed, then the array is sorted

 

=={{header|Python}}==

up = range(len(A)-1)

while True:

swapped = True

if not swapped:

cocktailSort(test1)

print test1

cocktailSort(test2)

print ''.join(test2)

 

=={{header|R}}==

{

{

}

{

}

}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

</pre>

 

=={{header|Ruby}}==

def cocktailsort!

begin

end

end

swapped = false

self

end

 

=={{header|Slate}}==

[ |swapped|

swapped: False.

swapped: False].

] loop

 

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

swap: indexA and: indexB [

|t|

^ self

]

 

 

=={{header|Tcl}}==

{{tcllib|struct::list}}<!-- convenient element swapping only -->

package require struct::list

 

}

return $A

 

 

=={{header|Ursala}}==

 

test program:

 

<pre>

'aabbddddddeffgggiiijkkkkklllmoqsstuuwxxy'

</pre>

 

=={{header|VBScript}}==

A few of the streets nearby.

 

dim swapped

dim i

a = b

b = tmp

a = array( "portcullis", "redoubt", "palissade", "turret", "collins", "the parapet", "the quarterdeck")

wscript.echo join( a, ", ")

dim b

b = cocktailSort( a )

<pre>

portcullis, redoubt, palissade, turret, collins, the parapet, the quarterdeck

collins, palissade, portcullis, redoubt, the parapet, the quarterdeck, turret

</pre>