all tasks
This commit is contained in:
Ingy döt Net
parent
b83f433714
commit
68f8f3e56b
14735 changed files with 178959 additions and 0 deletions
30
Task/Sorting-algorithms-Comb-sort/0DESCRIPTION
Normal file
30
Task/Sorting-algorithms-Comb-sort/0DESCRIPTION
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
{{Sorting Algorithm}}
|
||||
|
||||
The '''Comb Sort''' is a variant of the [[Bubble Sort]]. Like the [[Shell sort]], the Comb Sort increases the gap used in comparisons and exchanges (dividing the gap by <math>(1-e^{-\varphi})^{-1} \approx 1.247330950103979</math> works best, but 1.3 may be more practical). Some implementations use the insertion sort once the gap is less than a certain amount. See the [[wp:Comb sort|article on Wikipedia]].
|
||||
Variants:
|
||||
*Combsort11 makes sure the gap ends in (11, 8, 6, 4, 3, 2, 1), which is significantly faster than the other two possible endings
|
||||
*Combsort with different endings changes to a more efficient sort when the data is almost sorted (when the gap is small). Comb sort with a low gap isn't much better than the Bubble Sort.
|
||||
|
||||
Pseudocode:
|
||||
'''function''' combsort('''array''' input)
|
||||
gap := input'''.size''' ''//initialize gap size''
|
||||
'''loop until''' gap = 1 '''and''' swaps = 0
|
||||
''//update the gap value for a next comb. Below is an example''
|
||||
gap := int(gap / 1.25)
|
||||
'''if''' gap < 1
|
||||
''//minimum gap is 1''
|
||||
gap := 1
|
||||
'''end if'''
|
||||
i := 0
|
||||
swaps := 0 ''//see [[Bubble Sort]] for an explanation''
|
||||
''//a single "comb" over the input list''
|
||||
'''loop until''' i + gap >= input'''.size''' ''//see [[Shell sort]] for similar idea''
|
||||
'''if''' input[i] > input[i+gap]
|
||||
'''swap'''(input[i], input[i+gap])
|
||||
swaps := 1 ''// Flag a swap has occurred, so the''
|
||||
''// list is not guaranteed sorted''
|
||||
'''end if'''
|
||||
i := i + 1
|
||||
'''end loop'''
|
||||
'''end loop'''
|
||||
'''end function'''
|
||||
2
Task/Sorting-algorithms-Comb-sort/1META.yaml
Normal file
2
Task/Sorting-algorithms-Comb-sort/1META.yaml
Normal file
|
|
@ -0,0 +1,2 @@
|
|||
---
|
||||
note: Sorting Algorithms
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
function combsort( a, len, gap, igap, swap, swaps, i )
|
||||
{
|
||||
gap = len
|
||||
swaps = 1
|
||||
|
||||
while( gap > 1 || swaps )
|
||||
{
|
||||
gap /= 1.2473;
|
||||
if ( gap < 1 ) gap = 1
|
||||
i = swaps = 0
|
||||
while( i + gap < len )
|
||||
{
|
||||
igap = i + int(gap)
|
||||
if ( a[i] > a[igap] )
|
||||
{
|
||||
swap = a[i]
|
||||
a[i] = a[igap]
|
||||
a[igap] = swap
|
||||
swaps = 1
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
BEGIN {
|
||||
a[0] = 5
|
||||
a[1] = 2
|
||||
a[2] = 7
|
||||
a[3] = -11
|
||||
a[4] = 6
|
||||
a[5] = 1
|
||||
|
||||
combsort( a, length(a) )
|
||||
|
||||
for( i=0; i<length(a); i++ )
|
||||
print a[i]
|
||||
}
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
function combSort(input:Array)
|
||||
{
|
||||
var gap:uint = input.length;
|
||||
var swapped:Boolean = false;
|
||||
while(gap > 1 || swapped)
|
||||
{
|
||||
gap /= 1.25;
|
||||
swapped = false;
|
||||
for(var i:uint = 0; i + gap < input.length; i++)
|
||||
{
|
||||
if(input[i] > input[i+gap])
|
||||
{
|
||||
var tmp = input[i];
|
||||
input[i] = input[i+gap];
|
||||
input[i+gap]=tmp;
|
||||
swapped = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return input;
|
||||
}
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
with Ada.Text_IO;
|
||||
procedure Comb_Sort is
|
||||
generic
|
||||
type Element_Type is private;
|
||||
type Index_Type is range <>;
|
||||
type Array_Type is array (Index_Type range <>) of Element_Type;
|
||||
with function ">" (Left, Right : Element_Type) return Boolean is <>;
|
||||
with function "+" (Left : Index_Type; Right : Natural) return Index_Type is <>;
|
||||
with function "-" (Left : Index_Type; Right : Natural) return Index_Type is <>;
|
||||
procedure Comb_Sort (Data: in out Array_Type);
|
||||
|
||||
procedure Comb_Sort (Data: in out Array_Type) is
|
||||
procedure Swap (Left, Right : in Index_Type) is
|
||||
Temp : Element_Type := Data(Left);
|
||||
begin
|
||||
Data(Left) := Data(Right);
|
||||
Data(Right) := Temp;
|
||||
end Swap;
|
||||
Gap : Natural := Data'Length;
|
||||
Swap_Occured : Boolean;
|
||||
begin
|
||||
loop
|
||||
Gap := Natural (Float(Gap) / 1.25 - 0.5);
|
||||
if Gap < 1 then
|
||||
Gap := 1;
|
||||
end if;
|
||||
Swap_Occured := False;
|
||||
for I in Data'First .. Data'Last - Gap loop
|
||||
if Data (I) > Data (I+Gap) then
|
||||
Swap (I, I+Gap);
|
||||
Swap_Occured := True;
|
||||
end if;
|
||||
end loop;
|
||||
exit when Gap = 1 and not Swap_Occured;
|
||||
end loop;
|
||||
end Comb_Sort;
|
||||
|
||||
type Integer_Array is array (Positive range <>) of Integer;
|
||||
procedure Int_Comb_Sort is new Comb_Sort (Integer, Positive, Integer_Array);
|
||||
Test_Array : Integer_Array := (1, 3, 256, 0, 3, 4, -1);
|
||||
begin
|
||||
Int_Comb_Sort (Test_Array);
|
||||
for I in Test_Array'Range loop
|
||||
Ada.Text_IO.Put (Integer'Image (Test_Array (I)));
|
||||
end loop;
|
||||
Ada.Text_IO.New_Line;
|
||||
end Comb_Sort;
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
List1 = 23,76,99,58,97,57,35,89,51,38,95,92,24,46,31,24,14,12,57,78
|
||||
List2 = 88,18,31,44,4,0,8,81,14,78,20,76,84,33,73,75,82,5,62,70
|
||||
|
||||
List2Array(List1, "MyArray")
|
||||
CombSort("MyArray")
|
||||
MsgBox, % List1 "`n" Array2List("MyArray")
|
||||
|
||||
List2Array(List2, "MyArray")
|
||||
CombSort("MyArray")
|
||||
MsgBox, % List2 "`n" Array2List("MyArray")
|
||||
|
||||
|
||||
|
||||
;---------------------------------------------------------------------------
|
||||
CombSort(Array) { ; CombSort of Array %Array%, length = %Array%0
|
||||
;---------------------------------------------------------------------------
|
||||
Gap := %Array%0
|
||||
While Gap > 1 Or Swaps {
|
||||
If (Gap > 1)
|
||||
Gap := 4 * Gap // 5
|
||||
i := Swaps := False
|
||||
While (j := ++i + Gap) <= %Array%0 {
|
||||
If (%Array%%i% > %Array%%j%) {
|
||||
Swaps := True
|
||||
%Array%%i% := (%Array%%j% "", %Array%%j% := %Array%%i%)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
;---------------------------------------------------------------------------
|
||||
List2Array(List, Array) { ; creates an array from a comma separated list
|
||||
;---------------------------------------------------------------------------
|
||||
global
|
||||
StringSplit, %Array%, List, `,
|
||||
}
|
||||
|
||||
|
||||
|
||||
;---------------------------------------------------------------------------
|
||||
Array2List(Array) { ; returns a comma separated list from an array
|
||||
;---------------------------------------------------------------------------
|
||||
Loop, % %Array%0
|
||||
List .= (A_Index = 1 ? "" : ",") %Array%%A_Index%
|
||||
Return, List
|
||||
}
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
DEF PROC_CombSort11(Size%)
|
||||
|
||||
gap%=Size%
|
||||
REPEAT
|
||||
IF gap% > 1 THEN
|
||||
gap%=gap% / 1.3
|
||||
IF gap%=9 OR gap%=10 gap%=11
|
||||
ENDIF
|
||||
I% = 1
|
||||
Finished%=TRUE
|
||||
REPEAT
|
||||
IF data%(I%) > data%(I%+gap%) THEN
|
||||
SWAP data%(I%),data%(I%+gap%)
|
||||
Finished% = FALSE
|
||||
ENDIF
|
||||
I%+=1
|
||||
UNTIL I%+gap% > Size%
|
||||
UNTIL gap%=1 AND Finished%
|
||||
|
||||
ENDPROC
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
template<class ForwardIterator>
|
||||
void combsort ( ForwardIterator first, ForwardIterator last )
|
||||
{
|
||||
static const double shrink_factor = 1.247330950103979;
|
||||
typedef typename std::iterator_traits<ForwardIterator>::difference_type difference_type;
|
||||
difference_type gap = std::distance(first, last);
|
||||
bool swaps = true;
|
||||
|
||||
while ( (gap > 1) || (swaps == true) ){
|
||||
if (gap > 1)
|
||||
gap = static_cast<difference_type>(gap/shrink_factor);
|
||||
|
||||
swaps = false;
|
||||
ForwardIterator itLeft(first);
|
||||
ForwardIterator itRight(first); std::advance(itRight, gap);
|
||||
|
||||
for ( ; itRight!=last; ++itLeft, ++itRight ){
|
||||
if ( (*itRight) < (*itLeft) ){
|
||||
std::iter_swap(itLeft, itRight);
|
||||
swaps = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
void Combsort11(double a[], int nElements)
|
||||
{
|
||||
int i, j, gap, swapped = 1;
|
||||
double temp;
|
||||
|
||||
gap = nElements;
|
||||
while (gap > 1 || swapped == 1)
|
||||
{
|
||||
gap = gap * 10 / 13;
|
||||
if (gap == 9 || gap == 10) gap = 11;
|
||||
if (gap < 1) gap = 1;
|
||||
swapped = 0;
|
||||
for (i = 0, j = gap; j < nElements; i++, j++)
|
||||
{
|
||||
if (a[i] > a[j])
|
||||
{
|
||||
temp = a[i];
|
||||
a[i] = a[j];
|
||||
a[j] = temp;
|
||||
swapped = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
C-PROCESS SECTION.
|
||||
C-000.
|
||||
DISPLAY "SORT STARTING".
|
||||
|
||||
MOVE WC-SIZE TO WC-GAP.
|
||||
|
||||
PERFORM E-COMB UNTIL WC-GAP = 1 AND FINISHED.
|
||||
|
||||
DISPLAY "SORT FINISHED".
|
||||
|
||||
C-999.
|
||||
EXIT.
|
||||
|
||||
E-COMB SECTION.
|
||||
E-000.
|
||||
IF WC-GAP > 1
|
||||
DIVIDE WC-GAP BY 1.3 GIVING WC-GAP
|
||||
IF WC-GAP = 9 OR 10
|
||||
MOVE 11 TO WC-GAP.
|
||||
|
||||
MOVE 1 TO WC-SUB-1.
|
||||
MOVE "Y" TO WF-FINISHED.
|
||||
|
||||
PERFORM F-SCAN UNTIL WC-SUB-1 + WC-GAP > WC-SIZE.
|
||||
|
||||
E-999.
|
||||
EXIT.
|
||||
|
||||
F-SCAN SECTION.
|
||||
F-000.
|
||||
ADD WC-SUB-1 WC-GAP GIVING WC-SUB-2.
|
||||
IF WB-ENTRY(WC-SUB-1) > WB-ENTRY(WC-SUB-2)
|
||||
MOVE WB-ENTRY(WC-SUB-1) TO WC-TEMP
|
||||
MOVE WB-ENTRY(WC-SUB-2) TO WB-ENTRY(WC-SUB-1)
|
||||
MOVE WC-TEMP TO WB-ENTRY(WC-SUB-2)
|
||||
MOVE "N" TO WF-FINISHED.
|
||||
|
||||
ADD 1 TO WC-SUB-1.
|
||||
|
||||
F-999.
|
||||
EXIT.
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
import std.stdio, std.algorithm;
|
||||
|
||||
void combSort(T)(T[] input) {
|
||||
int gap = input.length;
|
||||
bool swaps = true;
|
||||
|
||||
while (gap > 1 || swaps) {
|
||||
gap = max(1, cast(int)(gap / 1.2473));
|
||||
swaps = false;
|
||||
foreach (i; 0 .. input.length - gap)
|
||||
if (input[i] > input[i + gap]) {
|
||||
swap(input[i], input[i + gap]);
|
||||
swaps = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void main() {
|
||||
auto array = [28, 44, 46, 24, 19, 2, 17, 11, 25, 4];
|
||||
combSort(array);
|
||||
writeln(array);
|
||||
}
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
defer precedes
|
||||
defer exchange
|
||||
|
||||
: gnomesort ( a n)
|
||||
swap >r 1 ( n c)
|
||||
begin ( n c)
|
||||
over over > ( n c f)
|
||||
while ( n c)
|
||||
dup if ( n c)
|
||||
dup dup 1- over over r@ precedes
|
||||
if r@ exchange 1- else drop drop 1+ then
|
||||
else 1+ then ( n c)
|
||||
repeat drop drop r> drop ( --)
|
||||
;
|
||||
|
||||
: combsort ( a n --)
|
||||
dup begin ( a n g)
|
||||
10 13 */ tuck >r >r 0 ( a g 0)
|
||||
begin ( a g 0)
|
||||
over r@ < ( a g 0 f)
|
||||
while ( a g 0)
|
||||
rot >r over over r@ precedes ( g 0 f)
|
||||
if over over r@ exchange then ( g 0)
|
||||
r> rot 1+ rot 1+ ( a g 0)
|
||||
repeat drop drop r> r> ( a n g)
|
||||
dup 9 < ( a n g f)
|
||||
until drop gnomesort ( --)
|
||||
;
|
||||
|
||||
create example
|
||||
8 93 69 52 50 79 33 52 19 77 , , , , , , , , , ,
|
||||
72 85 11 61 64 80 64 76 47 65 , , , , , , , , , ,
|
||||
13 47 23 40 87 45 2 48 22 69 , , , , , , , , , ,
|
||||
1 53 33 60 57 14 76 32 59 12 , , , , , , , , , ,
|
||||
74 38 39 22 87 28 37 93 71 88 , , , , , , , , , ,
|
||||
56 35 48 99 21 35 26 28 58 85 , , , , , , , , , ,
|
||||
27 16 54 88 82 18 45 64 45 87 , , , , , , , , , ,
|
||||
98 97 60 77 43 1 64 0 32 89 , , , , , , , , , ,
|
||||
77 90 68 83 9 76 10 10 95 12 , , , , , , , , , ,
|
||||
99 23 74 58 54 25 50 9 94 1 , , , , , , , , , ,
|
||||
|
||||
:noname >r cells r@ + @ swap cells r> + @ swap < ; is precedes
|
||||
:noname >r cells r@ + swap cells r> + over @ over @ swap rot ! swap ! ; is exchange
|
||||
|
||||
: .array 100 0 do example i cells + ? loop cr ;
|
||||
|
||||
.array example 100 combsort .array
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
program Combsort_Demo
|
||||
implicit none
|
||||
|
||||
integer, parameter :: num = 20
|
||||
real :: array(num)
|
||||
|
||||
call random_seed
|
||||
call random_number(array)
|
||||
write(*,*) "Unsorted array:-"
|
||||
write(*,*) array
|
||||
write(*,*)
|
||||
call combsort(array)
|
||||
write(*,*) "Sorted array:-"
|
||||
write(*,*) array
|
||||
|
||||
contains
|
||||
|
||||
subroutine combsort(a)
|
||||
|
||||
real, intent(in out) :: a(:)
|
||||
real :: temp
|
||||
integer :: i, gap
|
||||
logical :: swapped = .true.
|
||||
|
||||
gap = size(a)
|
||||
do while (gap > 1 .or. swapped)
|
||||
gap = gap / 1.3
|
||||
if (gap < 1) gap = 1
|
||||
swapped = .false.
|
||||
do i = 1, size(a)-gap
|
||||
if (a(i) > a(i+gap)) then
|
||||
temp = a(i)
|
||||
a(i) = a(i+gap)
|
||||
a(i+gap) = temp;
|
||||
swapped = .true.
|
||||
end if
|
||||
end do
|
||||
end do
|
||||
|
||||
end subroutine combsort
|
||||
|
||||
end program Combsort_Demo
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
package main
|
||||
|
||||
import "fmt"
|
||||
|
||||
func main() {
|
||||
a := []int{170, 45, 75, -90, -802, 24, 2, 66}
|
||||
fmt.Println("before:", a)
|
||||
combSort(a)
|
||||
fmt.Println("after: ", a)
|
||||
}
|
||||
|
||||
func combSort(a []int) {
|
||||
if len(a) < 2 {
|
||||
return
|
||||
}
|
||||
for gap := len(a); ; {
|
||||
if gap > 1 {
|
||||
gap = gap * 4 / 5
|
||||
}
|
||||
swapped := false
|
||||
for i := 0; ; {
|
||||
if a[i] > a[i+gap] {
|
||||
a[i], a[i+gap] = a[i+gap], a[i]
|
||||
swapped = true
|
||||
}
|
||||
i++
|
||||
if i+gap >= len(a) {
|
||||
break
|
||||
}
|
||||
}
|
||||
if gap == 1 && !swapped {
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"sort"
|
||||
"fmt"
|
||||
)
|
||||
|
||||
func main() {
|
||||
a := []int{170, 45, 75, -90, -802, 24, 2, 66}
|
||||
fmt.Println("before:", a)
|
||||
combSort(sort.IntSlice(a))
|
||||
fmt.Println("after: ", a)
|
||||
}
|
||||
|
||||
func combSort(a sort.Interface) {
|
||||
if a.Len() < 2 {
|
||||
return
|
||||
}
|
||||
for gap := a.Len(); ; {
|
||||
if gap > 1 {
|
||||
gap = gap * 4 / 5
|
||||
}
|
||||
swapped := false
|
||||
for i := 0; ; {
|
||||
if a.Less(i+gap, i) {
|
||||
a.Swap(i, i+gap)
|
||||
swapped = true
|
||||
}
|
||||
i++
|
||||
if i+gap >= a.Len() {
|
||||
break
|
||||
}
|
||||
}
|
||||
if gap == 1 && !swapped {
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
def makeSwap = { a, i, j -> print "."; a[i] ^= a[j]; a[j] ^= a[i]; a[i] ^= a[j] }
|
||||
|
||||
def checkSwap = { a, i, j -> [(a[i] > a[j])].find { it }.each { makeSwap(a, i, j) } }
|
||||
|
||||
def combSort = { input ->
|
||||
def swap = checkSwap.curry(input)
|
||||
def size = input.size()
|
||||
def gap = size
|
||||
def swapped = true
|
||||
while (gap != 1 || swapped) {
|
||||
gap = (gap / 1.247330950103979) as int
|
||||
gap = (gap < 1) ? 1 : gap
|
||||
swapped = (0..<(size-gap)).any { swap(it, it + gap) }
|
||||
}
|
||||
input
|
||||
}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
def combSort11 = { input ->
|
||||
def swap = checkSwap.curry(input)
|
||||
def size = input.size()
|
||||
def gap = size
|
||||
def swapped = true
|
||||
while (gap != 1 || swapped) {
|
||||
gap = (gap / 1.247330950103979) as int
|
||||
gap = ((gap < 1) ? 1 : ([10,9].contains(gap) ? 11 : gap))
|
||||
swapped = (0..<(size-gap)).any { swap(it, it + gap) }
|
||||
}
|
||||
input
|
||||
}
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
println (combSort([23,76,99,58,97,57,35,89,51,38,95,92,24,46,31,24,14,12,57,78,4]))
|
||||
println (combSort11([23,76,99,58,97,57,35,89,51,38,95,92,24,46,31,24,14,12,57,78,4]))
|
||||
println ()
|
||||
println (combSort([88,18,31,44,4,0,8,81,14,78,20,76,84,33,73,75,82,5,62,70,12,7,1]))
|
||||
println (combSort11([88,18,31,44,4,0,8,81,14,78,20,76,84,33,73,75,82,5,62,70,12,7,1]))
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
import Data.List
|
||||
import Control.Arrow
|
||||
import Control.Monad
|
||||
|
||||
flgInsert x xs = ((x:xs==) &&& id)$ insert x xs
|
||||
|
||||
gapSwapping k = (and *** concat. transpose). unzip
|
||||
. map (foldr (\x (b,xs) -> first (b &&)$ flgInsert x xs) (True,[]))
|
||||
. transpose. takeWhile (not.null). unfoldr (Just. splitAt k)
|
||||
|
||||
combSort xs = (snd. fst) $ until (\((b,_),g)-> b && g==1)
|
||||
(\((_,xs),g) ->(gapSwapping g xs, fg g)) ((False,xs), fg $ length xs)
|
||||
where fg = max 1. truncate. (/1.25). fromIntegral
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
*Main> combSort [23,76,99,58,97,57,35,89,51,38,95,92,24,46,31,24,14,12,57,78]
|
||||
[12,14,23,24,24,31,35,38,46,51,57,57,58,76,78,89,92,95,97,99]
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
procedure main() #: demonstrate various ways to sort a list and string
|
||||
demosort(combsort,[3, 14, 1, 5, 9, 2, 6, 3],"qwerty")
|
||||
end
|
||||
|
||||
procedure combsort(X,op) #: return sorted X
|
||||
local gap,swapped,i
|
||||
|
||||
op := sortop(op,X) # select how and what we sort
|
||||
|
||||
swappped := gap := *X # initialize gap size and say swapped
|
||||
until /swapped & gap = 1 do {
|
||||
gap := integer(gap / 1.25) # update the gap value for a next comb
|
||||
gap <:= 1 # minimum gap of 1
|
||||
swapped := &null
|
||||
|
||||
i := 0
|
||||
until (i +:= 1) + gap > *X do # a single "comb" over the input list
|
||||
if op(X[i+gap],X[i]) then
|
||||
X[i+1] :=: X[swapped := i] # swap and flag as unsorted
|
||||
}
|
||||
return X
|
||||
end
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
List do(
|
||||
combSortInPlace := method(
|
||||
gap := size
|
||||
swap := true
|
||||
|
||||
while(gap > 1 or swap,
|
||||
swap = false
|
||||
gap = (gap / 1.25) floor
|
||||
|
||||
for(i, 0, size - gap,
|
||||
if(at(i) > at(i + gap),
|
||||
swap = true
|
||||
swapIndices(i, i + gap)
|
||||
)
|
||||
)
|
||||
)
|
||||
self)
|
||||
)
|
||||
|
||||
lst := list(23, 76, 99, 58, 97, 57, 35, 89, 51, 38, 95, 92, 24, 46, 31, 24, 14, 12, 57, 78)
|
||||
lst combSortInPlace println # ==> list(12, 14, 23, 24, 24, 31, 35, 38, 46, 51, 57, 57, 58, 76, 78, 89, 92, 95, 97, 99)
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
combSort=:3 :0
|
||||
gap=. #y
|
||||
whilst.1 < gap+swaps do.
|
||||
swaps=. 0
|
||||
i=. i.2,gap=. 1 >. <.gap%1.25
|
||||
while.{:$i=.i #"1~ ({: i) < #y do.
|
||||
swaps=.swaps+#{:k=.i #"1~b=. >/ i{y
|
||||
i=. i+gap
|
||||
y=.((|.k){y) k} y
|
||||
end.
|
||||
end.
|
||||
y
|
||||
)
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
public static <E extends Comparable<? super E>> void sort(E[] input) {
|
||||
int gap = input.length;
|
||||
boolean swapped = true;
|
||||
while (gap > 1 || swapped) {
|
||||
if (gap > 1) {
|
||||
gap = (int) (gap / 1.3);
|
||||
}
|
||||
swapped = false;
|
||||
for (int i = 0; i + gap < input.length; i++) {
|
||||
if (input[i].compareTo(input[i + gap]) > 0) {
|
||||
E t = input[i];
|
||||
input[i] = input[i + gap];
|
||||
input[i + gap] = t;
|
||||
swapped = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
function combsort(t)
|
||||
local gapd, gap, swaps = 1.2473, #t, 0
|
||||
while gap + swaps > 1 do
|
||||
local k = 0
|
||||
swaps = 0
|
||||
if gap > 1 then gap = math.floor(gap / gapd) end
|
||||
for k = 1, #t - gap do
|
||||
if t[k] > t[k + gap] then
|
||||
t[k], t[k + gap], swaps = t[k + gap], t[k], swaps + 1
|
||||
end
|
||||
end
|
||||
end
|
||||
return t
|
||||
end
|
||||
|
||||
print(unpack(combsort{3,5,1,2,7,4,8,3,6,4,1}))
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
function list = combSort(list)
|
||||
|
||||
listSize = numel(list);
|
||||
gap = int32(listSize); %Coerce gap to an int so we can use the idivide function
|
||||
swaps = true; %Swap flag
|
||||
|
||||
while not((gap <= 1) && (swaps == false))
|
||||
|
||||
gap = idivide(gap,1.25,'floor'); %Int divide, floor the resulting operation
|
||||
|
||||
if gap < 1
|
||||
gap = 1;
|
||||
end
|
||||
|
||||
i = 1; %i equals 1 because all arrays are 1 based in MATLAB
|
||||
swaps = false;
|
||||
|
||||
%i + gap must be subtracted by 1 because the pseudo-code was writen
|
||||
%for 0 based arrays
|
||||
while not((i + gap - 1) >= listSize)
|
||||
|
||||
if (list(i) > list(i+gap))
|
||||
list([i i+gap]) = list([i+gap i]); %swap
|
||||
swaps = true;
|
||||
end
|
||||
i = i + 1;
|
||||
|
||||
end %while
|
||||
end %while
|
||||
end %combSort
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
>> combSort([4 3 1 5 6 2])
|
||||
|
||||
ans =
|
||||
|
||||
1 2 3 4 5 6
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
combSort[list_] := Module[{ gap = 0, listSize = 0, swaps = True},
|
||||
gap = listSize = Length[list];
|
||||
While[ !((gap <= 1) && (swaps == False)),
|
||||
|
||||
gap = Floor@Divide[gap, 1.25];
|
||||
If[ gap < 1, gap = 1]; i = 1; swaps = False;
|
||||
|
||||
While[ ! ((i + gap - 1) >= listSize),
|
||||
If[ list[[i]] > list[[i + gap]], swaps = True;
|
||||
list[[i ;; i + gap]] = list[[i + gap ;; i ;; -1]];
|
||||
];
|
||||
i++;
|
||||
]
|
||||
]
|
||||
]
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
/* NetRexx */
|
||||
|
||||
options replace format comments java crossref savelog symbols binary
|
||||
|
||||
placesList = [String -
|
||||
"UK London", "US New York" -
|
||||
, "US Boston", "US Washington" -
|
||||
, "UK Washington", "US Birmingham" -
|
||||
, "UK Birmingham", "UK Boston" -
|
||||
]
|
||||
sortedList = combSort(String[] Arrays.copyOf(placesList, placesList.length))
|
||||
|
||||
lists = [placesList, sortedList]
|
||||
loop ln = 0 to lists.length - 1
|
||||
cl = lists[ln]
|
||||
loop ct = 0 to cl.length - 1
|
||||
say cl[ct]
|
||||
end ct
|
||||
say
|
||||
end ln
|
||||
|
||||
return
|
||||
|
||||
method combSort(input = String[]) public constant binary returns String[]
|
||||
|
||||
swaps = isTrue
|
||||
gap = input.length
|
||||
loop label comb until gap = 1 & \swaps
|
||||
gap = int gap / 1.25
|
||||
if gap < 1 then
|
||||
gap = 1
|
||||
i_ = 0
|
||||
swaps = isFalse
|
||||
loop label swaps until i_ + gap >= input.length
|
||||
if input[i_].compareTo(input[i_ + gap]) > 0 then do
|
||||
swap = input[i_]
|
||||
input[i_] = input[i_ + gap]
|
||||
input[i_ + gap] = swap
|
||||
swaps = isTrue
|
||||
end
|
||||
i_ = i_ + 1
|
||||
end swaps
|
||||
end comb
|
||||
|
||||
return input
|
||||
|
||||
method isTrue public constant binary returns boolean
|
||||
return 1 == 1
|
||||
|
||||
method isFalse public constant binary returns boolean
|
||||
return \isTrue
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
let comb_sort ~input =
|
||||
let input_length = Array.length input in
|
||||
let gap = ref(input_length) in
|
||||
let swapped = ref true in
|
||||
while (!gap > 1 || !swapped) do
|
||||
if (!gap > 1) then
|
||||
gap := int_of_float (float !gap /. 1.3);
|
||||
|
||||
swapped := false;
|
||||
for i = 0 to input_length - !gap do
|
||||
if input.(i) > input.(i + !gap) then begin
|
||||
let tmp = input.(i) in
|
||||
input.(i) <- input.(i + !gap);
|
||||
input.(i + !gap) <- tmp;
|
||||
swapped := true;
|
||||
end
|
||||
done
|
||||
done
|
||||
;;
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
bundle Default {
|
||||
class Stooge {
|
||||
function : Main(args : String[]) ~ Nil {
|
||||
nums := [3, 5, 1, 9, 7, 6, 8, 2, 4];
|
||||
CombSort(nums);
|
||||
each(i : nums) {
|
||||
IO.Console->Print(nums[i])->Print(",");
|
||||
};
|
||||
IO.Console->PrintLine();
|
||||
}
|
||||
|
||||
function : CombSort(input : Int[]) ~ Nil {
|
||||
gap : Float := input->Size();
|
||||
swaps := true;
|
||||
while(gap > 1 | swaps) {
|
||||
gap /= 1.247330950103979;
|
||||
if(gap < 1) { gap := 1; };
|
||||
i : Int := 0;
|
||||
swaps := false;
|
||||
while(i + gap < input->Size()) {
|
||||
igap : Int := i + gap->As(Int);
|
||||
if (input[i] > input[igap]) {
|
||||
swap : Int := input[i];
|
||||
input[i] := input[igap];
|
||||
input[igap] := swap;
|
||||
swaps := true;
|
||||
};
|
||||
i += 1;
|
||||
};
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
declare
|
||||
proc {CombSort Arr}
|
||||
Low = {Array.low Arr}
|
||||
High = {Array.high Arr}
|
||||
Size = High - Low + 1
|
||||
Gap = {NewCell Size}
|
||||
Swapped = {NewCell true}
|
||||
proc {Swap I J}
|
||||
Arr.J := (Arr.I := Arr.J)
|
||||
end
|
||||
in
|
||||
for while:@Gap>1 orelse @Swapped do
|
||||
if @Gap > 1 then
|
||||
Gap := {Float.toInt {Floor {Int.toFloat @Gap} / 1.3}}
|
||||
end
|
||||
Swapped := false
|
||||
for I in Low..High-@Gap do
|
||||
if Arr.I > Arr.(I+@Gap) then
|
||||
{Swap I I+@Gap}
|
||||
Swapped := true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
Arr = {Tuple.toArray unit(3 1 4 1 5 9 2 6 5)}
|
||||
in
|
||||
{CombSort Arr}
|
||||
{Show {Array.toRecord unit Arr}}
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
combSort(v)={
|
||||
my(phi=(1+sqrt(5))/2,magic=1/(1-exp(-phi)),g=#v,swaps);
|
||||
while(g>1 | swaps,
|
||||
if(g>1, g\=magic);
|
||||
swaps=0;
|
||||
for(i=1,#v-g,
|
||||
if(v[i]>v[i+g],
|
||||
my(t=v[i]);
|
||||
v[i]=v[i+g];
|
||||
v[i+g]=t;
|
||||
swaps++
|
||||
)
|
||||
)
|
||||
);
|
||||
v
|
||||
};
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
function combSort($arr){
|
||||
$gap = count($arr);
|
||||
$swap = true;
|
||||
while ($gap > 1 || $swap){
|
||||
if($gap > 1) $gap /= 1.25;
|
||||
|
||||
$swap = false;
|
||||
$i = 0;
|
||||
while($i+$gap < count($arr)){
|
||||
if($arr[$i] > $arr[$i+$gap]){
|
||||
list($arr[$i], $arr[$i+$gap]) = array($arr[$i+$gap],$arr[$i]);
|
||||
$swap = true;
|
||||
}
|
||||
$i++;
|
||||
}
|
||||
}
|
||||
return $arr;
|
||||
}
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
/* From the pseudocode. */
|
||||
comb_sort: procedure (A);
|
||||
declare A(*) fixed;
|
||||
declare t fixed;
|
||||
declare (i, gap) fixed binary (31);
|
||||
declare swaps bit (1) aligned;
|
||||
|
||||
gap = hbound(A,1) - lbound(A,1); /* initialize the gap size. */
|
||||
do until (gap <= 1 & swaps);
|
||||
/* update the gap value for a next comb. */
|
||||
put skip data (gap);
|
||||
gap = gap / 1.25e0;
|
||||
put skip data (gap);
|
||||
swaps = '1'b;
|
||||
/* a single "comb" over the array. */
|
||||
do i = lbound(A,1) by 1 until (i + gap >= hbound(A,1));
|
||||
if A(i) > A(i+gap) then
|
||||
do;
|
||||
t = A(i); A(i) = A(i+gap); A(i+gap) = t;
|
||||
swaps = '0'b; /* Flag a swap has occurred, so */
|
||||
/* the list is not guaranteed sorted. */
|
||||
end;
|
||||
end;
|
||||
end;
|
||||
end comb_sort;
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
program CombSortDemo;
|
||||
|
||||
type
|
||||
TIntArray = array[1..40] of integer;
|
||||
|
||||
var
|
||||
data: TIntArray;
|
||||
i: integer;
|
||||
|
||||
procedure combSort(var a: TIntArray);
|
||||
var
|
||||
i, gap, temp: integer;
|
||||
swapped: boolean;
|
||||
begin
|
||||
gap := length(a);
|
||||
swapped := true;
|
||||
while (gap > 1) or swapped do
|
||||
begin
|
||||
gap := trunc(gap / 1.3);
|
||||
if (gap < 1) then
|
||||
gap := 1;
|
||||
swapped := false;
|
||||
for i := 1 to length(a) - gap do
|
||||
if a[i] > a[i+gap] then
|
||||
begin
|
||||
temp := a[i];
|
||||
a[i] := a[i+gap];
|
||||
a[i+gap] := temp;
|
||||
swapped := true;
|
||||
end;
|
||||
end;
|
||||
end;
|
||||
|
||||
begin
|
||||
Randomize;
|
||||
writeln('The data before sorting:');
|
||||
for i := low(data) to high(data) do
|
||||
begin
|
||||
data[i] := Random(high(data));
|
||||
write(data[i]:4);
|
||||
end;
|
||||
writeln;
|
||||
combSort(data);
|
||||
writeln('The data after sorting:');
|
||||
for i := low(data) to high(data) do
|
||||
begin
|
||||
write(data[i]:4);
|
||||
end;
|
||||
writeln;
|
||||
end.
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
sub comb_sort ( @a is copy ) {
|
||||
my $gap = +@a;
|
||||
my $swaps = 1;
|
||||
while $gap > 1 or $swaps {
|
||||
$gap = ( ($gap * 4) div 5 ) || 1 if $gap > 1;
|
||||
|
||||
$swaps = 0;
|
||||
for ^(+@a - $gap) -> $i {
|
||||
my $j = $i + $gap;
|
||||
if @a[$i] > @a[$j] {
|
||||
@a[$i, $j] .= reverse;
|
||||
$swaps = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
return @a;
|
||||
}
|
||||
|
||||
my @weights = (^50).map: { 100 + ( 1000.rand.Int / 10 ) };
|
||||
say @weights.sort.Str eq @weights.&comb_sort.Str ?? 'ok' !! 'not ok';
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
sub combSort {
|
||||
my @arr = @_;
|
||||
my $gap = @arr;
|
||||
my $swaps = 1;
|
||||
while ($gap > 1 || $swaps) {
|
||||
$gap /= 1.25 if $gap > 1;
|
||||
$swaps = 0;
|
||||
foreach my $i (0 .. $#arr - $gap) {
|
||||
if ($arr[$i] > $arr[$i+$gap]) {
|
||||
@arr[$i, $i+$gap] = @arr[$i+$gap, $i];
|
||||
$swaps = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
return @arr;
|
||||
}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
(de combSort (Lst)
|
||||
(let (Gap (length Lst) Swaps NIL)
|
||||
(while (or (> Gap 1) Swaps)
|
||||
(setq Gap (max 1 (/ (* Gap 4) 5)))
|
||||
(off Swaps)
|
||||
(use Lst
|
||||
(for (G (cdr (nth Lst Gap)) G (cdr G))
|
||||
(when (> (car Lst) (car G))
|
||||
(xchg Lst G)
|
||||
(on Swaps) )
|
||||
(pop 'Lst) ) ) ) )
|
||||
Lst )
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
function CombSort ($a) {
|
||||
$l = $a.Length
|
||||
$gap = 11
|
||||
while( $gap -lt $l )
|
||||
{
|
||||
$gap = [Math]::Floor( $gap*1.3 )
|
||||
}
|
||||
if( $l -gt 1 )
|
||||
{
|
||||
$hasChanged = $true
|
||||
:outer while ($hasChanged -or ( $gap -gt 1 ) ) {
|
||||
$count = 0
|
||||
$hasChanged = $false
|
||||
if( $gap -gt 1 ) {
|
||||
$gap = [Math]::Floor( $gap/1.3 )
|
||||
} else {
|
||||
$l--
|
||||
}
|
||||
for ($i = 0; $i -lt ( $l - $gap ); $i++) {
|
||||
if ($a[$i] -gt $a[$i+$gap]) {
|
||||
$a[$i], $a[$i+$gap] = $a[$i+$gap], $a[$i]
|
||||
$hasChanged = $true
|
||||
$count++
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
$a
|
||||
}
|
||||
|
||||
$l = 100; CombSort ( 1..$l | ForEach-Object { $Rand = New-Object Random }{ $Rand.Next( -( $l - 1 ), $l - 1 ) } )
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
;sorts an array of integers
|
||||
Procedure combSort11(Array a(1))
|
||||
Protected i, gap, swaps = 1
|
||||
Protected nElements = ArraySize(a())
|
||||
|
||||
gap = nElements
|
||||
While (gap > 1) Or (swapped = 1)
|
||||
gap * 10 / 13
|
||||
If gap = 9 Or gap = 10: gap = 11: EndIf
|
||||
If gap < 1: gap = 1: EndIf
|
||||
|
||||
i = 0
|
||||
swaps = 0
|
||||
While (i + gap) <= nElements
|
||||
If a(i) > a(i + gap)
|
||||
Swap a(i), a(i + gap)
|
||||
swaps = 1
|
||||
EndIf
|
||||
i + 1
|
||||
Wend
|
||||
Wend
|
||||
EndProcedure
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
;sorts an array of integers
|
||||
Procedure combSort(Array a(1))
|
||||
Protected i, gap, swaps = 1
|
||||
Protected nElements = ArraySize(a())
|
||||
|
||||
gap = nElements
|
||||
While (gap > 1) Or (swaps = 1)
|
||||
gap = Int(gap / 1.25)
|
||||
|
||||
i = 0
|
||||
swaps = 0
|
||||
While (i + gap) <= nElements
|
||||
If a(i) > a(i + gap)
|
||||
Swap a(i), a(i + gap)
|
||||
swaps = 1
|
||||
EndIf
|
||||
i + 1
|
||||
Wend
|
||||
Wend
|
||||
EndProcedure
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
>>> def combsort(input):
|
||||
gap = len(input)
|
||||
swaps = True
|
||||
while gap > 1 or swaps:
|
||||
gap = max(1, int(gap / 1.25)) # minimum gap is 1
|
||||
swaps = False
|
||||
for i in range(len(input) - gap):
|
||||
j = i+gap
|
||||
if input[i] > input[j]:
|
||||
input[i], input[j] = input[j], input[i]
|
||||
swaps = True
|
||||
|
||||
|
||||
>>> y = [88, 18, 31, 44, 4, 0, 8, 81, 14, 78, 20, 76, 84, 33, 73, 75, 82, 5, 62, 70]
|
||||
>>> combsort(y)
|
||||
>>> assert y == sorted(y)
|
||||
>>> y
|
||||
[0, 4, 5, 8, 14, 18, 20, 31, 33, 44, 62, 70, 73, 75, 76, 78, 81, 82, 84, 88]
|
||||
>>>
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
/*REXX program sorts an array using the comb-sort method. */
|
||||
call gen@ /*generate the array elements. */
|
||||
call show@ 'before sort' /*show the before array elements.*/
|
||||
call combSort highItem /*invoke the comb sort. */
|
||||
call show@ ' after sort' /*show the after array elements.*/
|
||||
exit /*stick a fork in it, we're done.*/
|
||||
/*──────────────────────────────────COMBSORT subroutine─────────────────*/
|
||||
combSort: procedure expose @.; parse arg n
|
||||
s=n-1 /*S = spread between COMBs. */
|
||||
|
||||
do until s<=1 & done
|
||||
s=trunc(s*.8) /* ÷ is slow, * is better. */
|
||||
done=1
|
||||
do j=1 until j+s>=n
|
||||
jps=j+s
|
||||
if @.j>@.jps then do; _=@.j; @.j=@.jps; @.jps=_; done=0; end
|
||||
end /*j*/
|
||||
end /*until*/
|
||||
|
||||
return
|
||||
/*──────────────────────────────────GEN@ subroutine─────────────────────*/
|
||||
gen@: @.= /*assign the default value. */
|
||||
@.1 ='--- polygon sides'
|
||||
@.2 ='============== ====='
|
||||
@.3 ='triangle 3'
|
||||
@.4 ='quadrilateral 4'
|
||||
@.5 ='pentagon 5'
|
||||
@.6 ='hexagon 6'
|
||||
@.7 ='heptagon 7'
|
||||
@.8 ='octagon 8'
|
||||
@.9 ='nonagon 9'
|
||||
@.10='decagon 10'
|
||||
@.11='dodecagon 12'
|
||||
do highItem=1 while @.highItem\=='' /*find how many entries in array.*/
|
||||
end
|
||||
highItem=highItem-1 /*adjust highItem slightly. */
|
||||
return
|
||||
/*──────────────────────────────────SHOW@ subroutine────────────────────*/
|
||||
show@: widthH=length(highItem) /*the maximum width of any line. */
|
||||
do j=1 for highItem
|
||||
say 'element' right(j,widthH) arg(1)":" @.j
|
||||
end
|
||||
say copies('─',79) /*show a nice separator line. */
|
||||
return
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
class Array
|
||||
def combsort!
|
||||
gap = size
|
||||
swaps = true
|
||||
until gap <= 1 and swaps
|
||||
gap = (gap / 1.25).to_int
|
||||
swaps = false
|
||||
0.upto(size - gap - 1) do |i|
|
||||
if self[i] > self[i+gap]
|
||||
self[i], self[i+gap] = self[i+gap], self[i]
|
||||
swaps = true
|
||||
end
|
||||
end
|
||||
end
|
||||
self
|
||||
end
|
||||
end
|
||||
|
||||
p [23, 76, 99, 58, 97, 57, 35, 89, 51, 38, 95, 92, 24, 46, 31, 24, 14, 12, 57, 78].combsort!
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
class SORT{T < $IS_LT{T}} is
|
||||
|
||||
private swap(inout a, inout b:T) is
|
||||
temp ::= a;
|
||||
a := b;
|
||||
b := temp;
|
||||
end;
|
||||
|
||||
-- ---------------------------------------------------------------------------------
|
||||
comb_sort(inout a:ARRAY{T}) is
|
||||
gap ::= a.size;
|
||||
swapped ::= true;
|
||||
loop until!(gap <= 1 and ~swapped);
|
||||
if gap > 1 then
|
||||
gap := (gap.flt / 1.25).int;
|
||||
end;
|
||||
i ::= 0;
|
||||
swapped := false;
|
||||
loop until! ( (i + gap) >= a.size );
|
||||
if (a[i] > a[i+gap]) then
|
||||
swap(inout a[i], inout a[i+gap]);
|
||||
swapped := true;
|
||||
end;
|
||||
i := i + 1;
|
||||
end;
|
||||
end;
|
||||
end;
|
||||
end;
|
||||
|
||||
class MAIN is
|
||||
main is
|
||||
a:ARRAY{INT} := |88, 18, 31, 44, 4, 0, 8, 81, 14, 78, 20, 76, 84, 33, 73, 75, 82, 5, 62, 70|;
|
||||
b ::= a.copy;
|
||||
SORT{INT}::comb_sort(inout b);
|
||||
#OUT + b + "\n";
|
||||
end;
|
||||
end;
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
proc combsort {input} {
|
||||
set gap [llength $input]
|
||||
while 1 {
|
||||
set gap [expr {int(floor($gap / 1.3))}]
|
||||
set swaps 0
|
||||
for {set i 0} {$i+$gap < [llength $input]} {incr i} {
|
||||
set j [expr {$i+$gap}]
|
||||
if {[lindex $input $i] > [lindex $input $j]} {
|
||||
set tmp [lindex $input $i]
|
||||
lset input $i [lindex $input $j]
|
||||
lset input $j $tmp
|
||||
incr swaps
|
||||
}
|
||||
}
|
||||
if {$gap <= 1 && !$swaps} break
|
||||
}
|
||||
return $input
|
||||
}
|
||||
|
||||
set data {23 76 99 58 97 57 35 89 51 38 95 92 24 46 31 24 14 12 57 78}
|
||||
puts [combsort $data]
|
||||
Loading…
Add table
Add a link
Reference in a new issue