Sorting algorithms/Cocktail sort with shifting bounds: Difference between revisions

{{task|Sorting Algorithms}}

{{Sorting Algorithm}}

{{Wikipedia|Cocktail sort}}

 

Because the Rosetta Code task Cocktail sort had so many entries in it,

adding an optional algorithm (or a stretch goal) wasn't feasible at this time,

 

-------------- Gerard Schildberger ---------------------

!-->

 

After   ''ii''   passes,   the first   ''ii''   and the

last   ''ii''   elements in the array are in their correct

 

By shortening the part of the array that is sorted each time,   the number of

Pseudocode for the &nbsp; <big> 2^nd </big> &nbsp; algorithm &nbsp; (from

[[wp:Cocktail sort|Wikipedia]]) &nbsp; with an added comment and changed indentations:

% `beginIdx` and `endIdx` marks the first and last index to check.

beginIdx = 1;

beginIdx = newBeginIdx + 1;

end

<big>'''%'''</big> &nbsp; indicates a comment, &nbsp; and &nbsp; '''deal''' &nbsp; indicates a &nbsp; ''swap''.

 

:* &nbsp; [https://rosettacode.org/wiki/Sorting_algorithms/Cocktail_sort cocktail sort]

<br><br>

 

=={{header|360 Assembly}}==

For maximum compatibility, this program uses only the basic instruction set.

The program uses also HLASM structured macros (DO,ENDDO,IF,ELSE,ENDIF) for readability and two ASSIST/360 macros (XDECO,XPRNT) to keep the code as short as possible.

COCKSHIS CSECT

USING COCKSHIS,R13 base register

REGEQU

RI EQU 6 i

{{out}}

<pre>

-31 0 1 2 2 4 45 58 65 69 74 82 82 83 88 89 99 104 112 782

</pre>

 

=={{header|ALGOL 60}}==

{{works with|A60}}

begin

for i:=lbx step 1 until ubx do if A[i]>A[i+1] then swap(i);

end

{{out}}

<pre>

3 6 14 16 19 23 28 33 33 47 61 62 64 67 73 77 78 81 83 92

</pre>

 

=={{header|C}}==

#include <string.h>

 

print(a, len);

return 0;

 

{{out}}

 

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

#include <cassert>

#include <iostream>

print(v.begin(), v.end());

return 0;

 

{{out}}

after: -6 0 1 2 3 4 5 12 13 15

</pre>

 

=={{header|Go}}==

If you run this a few times, the figures for 8K random numbers upwards are quite stable at around the levels shown.

 

import (

fmt.Printf(" %2dk %0.3f\n", n/1000, sum/runs)

}

 

{{out}}

20k 1.302

</pre>

 

=={{header|Java}}==

 

public class CocktailSort {

array[j] = tmp;

}

 

{{out}}

The implementation chosen is to extend the native Julia base sort! function, which by default in base Julia supports insertion sort,

quick sort, partial quick sort, and merge sort.

 

using Base.Order, Base.Sort

println("\nUsing CocktailShakerSort:")

@btime cocktailshakersort!([5, 8, 2, 0, 6, 1, 9, 3, 4])

<pre>

[5, 8, 2, 0, 6, 1, 9, 3, 4] => [0, 1, 2, 3, 4, 5, 6, 8, 9] => [9, 8, 6, 5, 4, 3, 2, 1, 0]

94.443 ns (1 allocation: 160 bytes)

</pre>

 

=={{header|Phix}}==

Averages 7 or 8% better than [[Sorting_algorithms/Cocktail_sort#Phix]] which already shifted the bounds, however this shifts >1 (sometimes).

newEndIdx = ii

newBeginIdx = ii

beginIdx = newBeginIdx + 1

{{out}}

<pre>

</pre>

 

=={{header|Raku}}==

{{works with|Rakudo|2020.05}}

 

my ($min, $max) = 0, +@a - 2;

loop {

 

my @weights = (flat 0..9, 'A'..'F').roll(2 + ^4 .roll).join xx 100;

 

=={{header|REXX}}==

This REXX version can handle array elements that may contain blanks or spaces.

call gen /*generate some array elements. */

call show 'before sort' /*show unsorted array elements. */

say 'element' right(j, w) arg(1)":" @.j

end /*j*/ /* ↑ */

{{out|output|text=&nbsp; when using the internal default inputs:}}

 

 

=={{header|Rust}}==

let mut begin = 0;

let mut end = a.len();

cocktail_shaker_sort(&mut v);

println!("after: {:?}", v);

 

{{out}}

=={{header|Swift}}==

{{trans|Rust}}

var begin = 0

var end = a.count

var array = [5, 1, -6, 12, 3, 13, 2, 4, 0, 15]

print("before: \(array)")

print(" after: \(array)")

 

var array2 = ["one", "two", "three", "four", "five", "six", "seven", "eight"]

print("before: \(array2)")

 

{{out}}

 

=={{header|VBA}}==

 

Function cocktailShakerSort(ByVal A As Variant) As Variant

Debug.Print Join(B, ", ")

Debug.Print Join(cocktailShakerSort(B), ", ")

{{out}}

<pre>

 

=={{header|VBScript}}==

 

Function cocktailShakerSort(ByVal A)

Next

Wscript.Echo Join(cocktailShakerSort(B)," ")

{{out}}

<pre>

=={{header|Visual Basic .NET}}==

{{works with|Visual Basic .NET|9.0}}

Private Sub Cocktail_Shaker_Sort()

Dim A(20), tmp As Long 'or Integer Long Single Double String

'Display the sorted list

Debug.Print(String.Join(", ", A))

{{out}}

<pre>

 

Ratios are noticeably less than the Go example (more in keeping with the REXX results in the talk page) and vary more if the script is run a few times. Frankly, I don't know why this is.

import "random" for Random

 

}

System.print(" %(Fmt.d(2, (n/1000).floor))k %(Fmt.f(0, sum/runs, 3))")

 

{{out}}

20k 1.228

</pre>