Initial data commit
This commit is contained in:
Ingy döt Net
parent
72d218235f
commit
f23f22d71c
199087 changed files with 3378941 additions and 0 deletions
3
Task/Sorting-algorithms-Bubble-sort/00-META.yaml
Normal file
3
Task/Sorting-algorithms-Bubble-sort/00-META.yaml
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
---
|
||||
from: http://rosettacode.org/wiki/Sorting_algorithms/Bubble_sort
|
||||
note: Sorting Algorithms
|
||||
36
Task/Sorting-algorithms-Bubble-sort/00-TASK.txt
Normal file
36
Task/Sorting-algorithms-Bubble-sort/00-TASK.txt
Normal file
|
|
@ -0,0 +1,36 @@
|
|||
{{Sorting Algorithm}}
|
||||
|
||||
A '''bubble''' sort is generally considered to be the simplest sorting algorithm.
|
||||
|
||||
A '''bubble''' sort is also known as a '''sinking''' sort.
|
||||
|
||||
Because of its simplicity and ease of visualization, it is often taught in introductory computer science courses.
|
||||
|
||||
Because of its abysmal O(n<sup>2</sup>) performance, it is not used often for large (or even medium-sized) datasets.
|
||||
|
||||
The bubble sort works by passing sequentially over a list, comparing each value to the one immediately after it. If the first value is greater than the second, their positions are switched. Over a number of passes, at most equal to the number of elements in the list, all of the values drift into their correct positions (large values "bubble" rapidly toward the end, pushing others down around them).
|
||||
Because each pass finds the maximum item and puts it at the end, the portion of the list to be sorted can be reduced at each pass.
|
||||
A boolean variable is used to track whether any changes have been made in the current pass; when a pass completes without changing anything, the algorithm exits.
|
||||
|
||||
This can be expressed in pseudo-code as follows (assuming 1-based indexing):
|
||||
'''repeat'''
|
||||
'''if''' itemCount <= 1
|
||||
'''return'''
|
||||
hasChanged := false
|
||||
'''decrement''' itemCount
|
||||
'''repeat with''' index '''from''' 1 '''to''' itemCount
|
||||
'''if''' (item '''at''' index) > (item '''at''' (index + 1))
|
||||
swap (item '''at''' index) with (item '''at''' (index + 1))
|
||||
hasChanged := true
|
||||
'''until''' hasChanged = '''false'''
|
||||
|
||||
|
||||
;Task:
|
||||
Sort an array of elements using the bubble sort algorithm. The elements must have a total order and the index of the array can be of any discrete type. For languages where this is not possible, sort an array of integers.
|
||||
|
||||
|
||||
;References:
|
||||
* The article on [[wp:Bubble_sort|Wikipedia]].
|
||||
* Dance [http://www.youtube.com/watch?v=lyZQPjUT5B4&feature=youtu.be interpretation].
|
||||
<br><br>
|
||||
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
F bubble_sort(&seq)
|
||||
V changed = 1B
|
||||
L changed == 1B
|
||||
changed = 0B
|
||||
L(i) 0 .< seq.len - 1
|
||||
I seq[i] > seq[i + 1]
|
||||
swap(&seq[i], &seq[i + 1])
|
||||
changed = 1B
|
||||
|
||||
V testset = Array(0.<100)
|
||||
V testcase = copy(testset)
|
||||
random:shuffle(&testcase)
|
||||
assert(testcase != testset)
|
||||
bubble_sort(&testcase)
|
||||
assert(testcase == testset)
|
||||
|
|
@ -0,0 +1,59 @@
|
|||
* Bubble Sort 01/11/2014 & 23/06/2016
|
||||
BUBBLE CSECT
|
||||
USING BUBBLE,R13,R12 establish base registers
|
||||
SAVEAREA B STM-SAVEAREA(R15) skip savearea
|
||||
DC 17F'0' my savearea
|
||||
STM STM R14,R12,12(R13) save calling context
|
||||
ST R13,4(R15) link mySA->prevSA
|
||||
ST R15,8(R13) link prevSA->mySA
|
||||
LR R13,R15 set mySA & set 4K addessability
|
||||
LA R12,2048(R13) .
|
||||
LA R12,2048(R12) set 8K addessability
|
||||
L RN,N n
|
||||
BCTR RN,0 n-1
|
||||
DO UNTIL=(LTR,RM,Z,RM) repeat ------------------------+
|
||||
LA RM,0 more=false |
|
||||
LA R1,A @a(i) |
|
||||
LA R2,4(R1) @a(i+1) |
|
||||
LA RI,1 i=1 |
|
||||
DO WHILE=(CR,RI,LE,RN) for i=1 to n-1 ------------+ |
|
||||
L R3,0(R1) a(i) | |
|
||||
IF C,R3,GT,0(R2) if a(i)>a(i+1) then ---+ | |
|
||||
L R9,0(R1) r9=a(i) | | |
|
||||
L R3,0(R2) r3=a(i+1) | | |
|
||||
ST R3,0(R1) a(i)=r3 | | |
|
||||
ST R9,0(R2) a(i+1)=r9 | | |
|
||||
LA RM,1 more=true | | |
|
||||
ENDIF , end if <---------------+ | |
|
||||
LA RI,1(RI) i=i+1 | |
|
||||
LA R1,4(R1) next a(i) | |
|
||||
LA R2,4(R2) next a(i+1) | |
|
||||
ENDDO , end for <------------------+ |
|
||||
ENDDO , until not more <---------------+
|
||||
LA R3,PG pgi=0
|
||||
LA RI,1 i=1
|
||||
DO WHILE=(C,RI,LE,N) do i=1 to n -------+
|
||||
LR R1,RI i |
|
||||
SLA R1,2 . |
|
||||
L R2,A-4(R1) a(i) |
|
||||
XDECO R2,XDEC edit a(i) |
|
||||
MVC 0(4,R3),XDEC+8 output a(i) |
|
||||
LA R3,4(R3) pgi=pgi+4 |
|
||||
LA RI,1(RI) i=i+1 |
|
||||
ENDDO , end do <-----------+
|
||||
XPRNT PG,L'PG print buffer
|
||||
L R13,4(0,R13) restore caller savearea
|
||||
LM R14,R12,12(R13) restore context
|
||||
XR R15,R15 set return code to 0
|
||||
BR R14 return to caller
|
||||
A DC F'4',F'65',F'2',F'-31',F'0',F'99',F'2',F'83',F'782',F'1'
|
||||
DC F'45',F'82',F'69',F'82',F'104',F'58',F'88',F'112',F'89',F'74'
|
||||
N DC A((N-A)/L'A) number of items of a *
|
||||
PG DC CL80' '
|
||||
XDEC DS CL12
|
||||
LTORG
|
||||
REGEQU
|
||||
RI EQU 6 i
|
||||
RN EQU 7 n-1
|
||||
RM EQU 8 more
|
||||
END BUBBLE
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
define z_HL $00
|
||||
define z_L $00
|
||||
define z_H $01
|
||||
define temp $02
|
||||
define temp2 $03
|
||||
|
||||
set_table:
|
||||
dex
|
||||
txa
|
||||
sta $1200,y
|
||||
iny
|
||||
bne set_table ;stores $ff at $1200, $fe at $1201, etc.
|
||||
|
||||
lda #$12
|
||||
sta z_H
|
||||
lda #$00
|
||||
sta z_L
|
||||
|
||||
lda #0
|
||||
tax
|
||||
tay ;clear regs
|
||||
|
||||
JSR BUBBLESORT
|
||||
BRK
|
||||
|
||||
BUBBLESORT:
|
||||
lda (z_HL),y
|
||||
sta temp
|
||||
iny ;look at the next item
|
||||
lda (z_HL),y
|
||||
dey ;go back 1 to the "current item"
|
||||
sta temp2
|
||||
cmp temp
|
||||
bcs doNothing
|
||||
|
||||
;we had to re-arrange an item.
|
||||
lda temp
|
||||
iny
|
||||
sta (z_HL),y ;store the higher value at base+y+1
|
||||
inx ;sort count. If zero at the end, we're done.
|
||||
dey
|
||||
lda temp2
|
||||
sta (z_HL),y ;store the lower value at base+y
|
||||
|
||||
doNothing:
|
||||
iny
|
||||
cpy #$ff
|
||||
bne BUBBLESORT
|
||||
ldy #0
|
||||
txa ;check the value of the counter
|
||||
beq DoneSorting
|
||||
ldx #0 ;reset the counter
|
||||
jmp BUBBLESORT
|
||||
DoneSorting:
|
||||
rts
|
||||
|
|
@ -0,0 +1,168 @@
|
|||
/* ARM assembly AARCH64 Raspberry PI 3B */
|
||||
/* program bubbleSort64.s */
|
||||
|
||||
/*******************************************/
|
||||
/* Constantes file */
|
||||
/*******************************************/
|
||||
/* for this file see task include a file in language AArch64 assembly */
|
||||
.include "../includeConstantesARM64.inc"
|
||||
|
||||
/*********************************/
|
||||
/* Initialized data */
|
||||
/*********************************/
|
||||
.data
|
||||
szMessSortOk: .asciz "Table sorted.\n"
|
||||
szMessSortNok: .asciz "Table not sorted !!!!!.\n"
|
||||
sMessResult: .asciz "Value : @ \n"
|
||||
szCarriageReturn: .asciz "\n"
|
||||
|
||||
.align 4
|
||||
TableNumber: .quad 1,3,6,2,5,9,10,8,4,7
|
||||
#TableNumber: .quad 10,9,8,7,6,5,4,3,2,1
|
||||
.equ NBELEMENTS, (. - TableNumber) / 8
|
||||
/*********************************/
|
||||
/* UnInitialized data */
|
||||
/*********************************/
|
||||
.bss
|
||||
sZoneConv: .skip 24
|
||||
/*********************************/
|
||||
/* code section */
|
||||
/*********************************/
|
||||
.text
|
||||
.global main
|
||||
main: // entry of program
|
||||
ldr x0,qAdrTableNumber // address number table
|
||||
mov x1,0
|
||||
mov x2,NBELEMENTS // number of élements
|
||||
bl bubbleSort
|
||||
ldr x0,qAdrTableNumber // address number table
|
||||
bl displayTable
|
||||
|
||||
ldr x0,qAdrTableNumber // address number table
|
||||
mov x1,NBELEMENTS // number of élements
|
||||
bl isSorted // control sort
|
||||
cmp x0,1 // sorted ?
|
||||
beq 1f
|
||||
ldr x0,qAdrszMessSortNok // no !! error sort
|
||||
bl affichageMess
|
||||
b 100f
|
||||
1: // yes
|
||||
ldr x0,qAdrszMessSortOk
|
||||
bl affichageMess
|
||||
100: // standard end of the program
|
||||
mov x0,0 // return code
|
||||
mov x8,EXIT // request to exit program
|
||||
svc 0 // perform the system call
|
||||
|
||||
qAdrsZoneConv: .quad sZoneConv
|
||||
qAdrszCarriageReturn: .quad szCarriageReturn
|
||||
qAdrsMessResult: .quad sMessResult
|
||||
qAdrTableNumber: .quad TableNumber
|
||||
qAdrszMessSortOk: .quad szMessSortOk
|
||||
qAdrszMessSortNok: .quad szMessSortNok
|
||||
/******************************************************************/
|
||||
/* control sorted table */
|
||||
/******************************************************************/
|
||||
/* x0 contains the address of table */
|
||||
/* x1 contains the number of elements > 0 */
|
||||
/* x0 return 0 if not sorted 1 if sorted */
|
||||
isSorted:
|
||||
stp x2,lr,[sp,-16]! // save registers
|
||||
stp x3,x4,[sp,-16]! // save registers
|
||||
mov x2,0
|
||||
ldr x4,[x0,x2,lsl 3]
|
||||
1:
|
||||
add x2,x2,1
|
||||
cmp x2,x1
|
||||
bge 99f
|
||||
ldr x3,[x0,x2, lsl 3]
|
||||
cmp x3,x4
|
||||
blt 98f
|
||||
mov x4,x3
|
||||
b 1b
|
||||
98:
|
||||
mov x0,0 // not sorted
|
||||
b 100f
|
||||
99:
|
||||
mov x0,1 // sorted
|
||||
100:
|
||||
ldp x3,x4,[sp],16 // restaur 2 registers
|
||||
ldp x2,lr,[sp],16 // restaur 2 registers
|
||||
ret // return to address lr x30
|
||||
/******************************************************************/
|
||||
/* bubble sort */
|
||||
/******************************************************************/
|
||||
/* x0 contains the address of table */
|
||||
/* x1 contains the first element */
|
||||
/* x2 contains the number of element */
|
||||
bubbleSort:
|
||||
stp x1,lr,[sp,-16]! // save registers
|
||||
stp x2,x3,[sp,-16]! // save registers
|
||||
stp x4,x5,[sp,-16]! // save registers
|
||||
stp x6,x7,[sp,-16]! // save registers
|
||||
stp x8,x9,[sp,-16]! // save registers
|
||||
sub x2,x2,1 // compute i = n - 1
|
||||
add x8,x1,1
|
||||
1: // start loop 1
|
||||
mov x3,x1 // start index
|
||||
mov x9,0
|
||||
sub x7,x2,1
|
||||
2: // start loop 2
|
||||
add x4,x3,1
|
||||
ldr x5,[x0,x3,lsl 3] // load value A[j]
|
||||
ldr x6,[x0,x4,lsl 3] // load value A[j+1]
|
||||
cmp x6,x5 // compare value
|
||||
bge 3f
|
||||
str x6,[x0,x3,lsl 3] // if smaller inversion
|
||||
str x5,[x0,x4,lsl 3]
|
||||
mov x9,1 // top table not sorted
|
||||
3:
|
||||
add x3,x3,1 // increment index j
|
||||
cmp x3,x7 // end ?
|
||||
ble 2b // no -> loop 2
|
||||
cmp x9,0 // table sorted ?
|
||||
beq 100f // yes -> end
|
||||
|
||||
sub x2,x2,1 // decrement i
|
||||
cmp x2,x8 // end ?
|
||||
bge 1b // no -> loop 1
|
||||
|
||||
100:
|
||||
ldp x8,x9,[sp],16 // restaur 2 registers
|
||||
ldp x6,x7,[sp],16 // restaur 2 registers
|
||||
ldp x4,x5,[sp],16 // restaur 2 registers
|
||||
ldp x2,x3,[sp],16 // restaur 2 registers
|
||||
ldp x1,lr,[sp],16 // restaur 2 registers
|
||||
ret // return to address lr x30
|
||||
|
||||
/******************************************************************/
|
||||
/* Display table elements */
|
||||
/******************************************************************/
|
||||
/* x0 contains the address of table */
|
||||
displayTable:
|
||||
stp x1,lr,[sp,-16]! // save registers
|
||||
stp x2,x3,[sp,-16]! // save registers
|
||||
mov x2,x0 // table address
|
||||
mov x3,0
|
||||
1: // loop display table
|
||||
ldr x0,[x2,x3,lsl 3]
|
||||
ldr x1,qAdrsZoneConv
|
||||
bl conversion10 // décimal conversion
|
||||
ldr x0,qAdrsMessResult
|
||||
ldr x1,qAdrsZoneConv
|
||||
bl strInsertAtCharInc // insert result at @ character
|
||||
bl affichageMess // display message
|
||||
add x3,x3,1
|
||||
cmp x3,NBELEMENTS - 1
|
||||
ble 1b
|
||||
ldr x0,qAdrszCarriageReturn
|
||||
bl affichageMess
|
||||
100:
|
||||
ldp x2,x3,[sp],16 // restaur 2 registers
|
||||
ldp x1,lr,[sp],16 // restaur 2 registers
|
||||
ret // return to address lr x30
|
||||
/********************************************************/
|
||||
/* File Include fonctions */
|
||||
/********************************************************/
|
||||
/* for this file see task include a file in language AArch64 assembly */
|
||||
.include "../includeARM64.inc"
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
(defun bubble (xs)
|
||||
(if (endp (rest xs))
|
||||
(mv nil xs)
|
||||
(let ((x1 (first xs))
|
||||
(x2 (second xs)))
|
||||
(if (> x1 x2)
|
||||
(mv-let (_ ys)
|
||||
(bubble (cons x1 (rest (rest xs))))
|
||||
(declare (ignore _))
|
||||
(mv t (cons x2 ys)))
|
||||
(mv-let (has-changed ys)
|
||||
(bubble (rest xs))
|
||||
(mv has-changed (cons x1 ys)))))))
|
||||
|
||||
(defun bsort-r (xs limit)
|
||||
(declare (xargs :measure (nfix limit)))
|
||||
(if (zp limit)
|
||||
xs
|
||||
(mv-let (has-changed ys)
|
||||
(bubble xs)
|
||||
(if has-changed
|
||||
(bsort-r ys (1- limit))
|
||||
ys))))
|
||||
|
||||
(defun bsort (xs)
|
||||
(bsort-r xs (len xs)))
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
begin
|
||||
comment Sorting algorithms/Bubble sort - Algol 60;
|
||||
integer nA;
|
||||
nA:=20;
|
||||
|
||||
begin
|
||||
integer array A[1:20];
|
||||
|
||||
procedure bubblesort(lb,ub);
|
||||
value lb,ub; integer lb,ub;
|
||||
begin
|
||||
integer i;
|
||||
boolean swapped;
|
||||
swapped :=true;
|
||||
for i:=1 while swapped do begin
|
||||
swapped:=false;
|
||||
for i:=lb step 1 until ub-1 do if A[i]>A[i+1] then begin
|
||||
integer temp;
|
||||
temp :=A[i];
|
||||
A[i] :=A[i+1];
|
||||
A[i+1]:=temp;
|
||||
swapped:=true
|
||||
end
|
||||
end
|
||||
end bubblesort;
|
||||
|
||||
procedure inittable(lb,ub);
|
||||
value lb,ub; integer lb,ub;
|
||||
begin
|
||||
integer i;
|
||||
for i:=lb step 1 until ub do A[i]:=entier(rand*100)
|
||||
end inittable;
|
||||
|
||||
procedure writetable(lb,ub);
|
||||
value lb,ub; integer lb,ub;
|
||||
begin
|
||||
integer i;
|
||||
for i:=lb step 1 until ub do outinteger(1,A[i]);
|
||||
outstring(1,"\n")
|
||||
end writetable;
|
||||
|
||||
|
||||
inittable(1,nA);
|
||||
writetable(1,nA);
|
||||
bubblesort(1,nA);
|
||||
writetable(1,nA)
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
MODE DATA = INT;
|
||||
PROC swap = (REF[]DATA slice)VOID:
|
||||
(
|
||||
DATA tmp = slice[1];
|
||||
slice[1] := slice[2];
|
||||
slice[2] := tmp
|
||||
);
|
||||
|
||||
PROC sort = (REF[]DATA array)VOID:
|
||||
(
|
||||
BOOL sorted;
|
||||
INT shrinkage := 0;
|
||||
FOR size FROM UPB array - 1 BY -1 WHILE
|
||||
sorted := TRUE;
|
||||
shrinkage +:= 1;
|
||||
FOR i FROM LWB array TO size DO
|
||||
IF array[i+1] < array[i] THEN
|
||||
swap(array[i:i+1]);
|
||||
sorted := FALSE
|
||||
FI
|
||||
OD;
|
||||
NOT sorted
|
||||
DO SKIP OD
|
||||
);
|
||||
|
||||
main:(
|
||||
[10]INT random := (1,6,3,5,2,9,8,4,7,0);
|
||||
|
||||
printf(($"Before: "10(g(3))l$,random));
|
||||
sort(random);
|
||||
printf(($"After: "10(g(3))l$,random))
|
||||
)
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
begin
|
||||
% As algol W does not allow overloading, we have to have type-specific %
|
||||
% sorting procedures - this bubble sorts an integer array %
|
||||
% as there is no way for the procedure to determine the array bounds, we %
|
||||
% pass the lower and upper bounds in lb and ub %
|
||||
procedure bubbleSortIntegers( integer array item( * )
|
||||
; integer value lb
|
||||
; integer value ub
|
||||
) ;
|
||||
begin
|
||||
integer lower, upper;
|
||||
|
||||
lower := lb;
|
||||
upper := ub;
|
||||
|
||||
while
|
||||
begin
|
||||
logical swapped;
|
||||
upper := upper - 1;
|
||||
swapped := false;
|
||||
for i := lower until upper
|
||||
do begin
|
||||
if item( i ) > item( i + 1 )
|
||||
then begin
|
||||
integer val;
|
||||
val := item( i );
|
||||
item( i ) := item( i + 1 );
|
||||
item( i + 1 ) := val;
|
||||
swapped := true;
|
||||
end if_must_swap ;
|
||||
end for_i ;
|
||||
swapped
|
||||
end
|
||||
do begin end;
|
||||
end bubbleSortIntegers ;
|
||||
|
||||
begin % test the bubble sort %
|
||||
integer array data( 1 :: 10 );
|
||||
|
||||
procedure writeData ;
|
||||
begin
|
||||
write( data( 1 ) );
|
||||
for i := 2 until 10 do writeon( data( i ) );
|
||||
end writeData ;
|
||||
|
||||
% initialise data to unsorted values %
|
||||
integer dPos;
|
||||
dPos := 1;
|
||||
for i := 16, 2, -6, 9, 90, 14, 0, 23, 8, 9
|
||||
do begin
|
||||
data( dPos ) := i;
|
||||
dPos := dPos + 1;
|
||||
end for_i ;
|
||||
|
||||
i_w := 3; s_w := 1; % set output format %
|
||||
writeData;
|
||||
bubbleSortIntegers( data, 1, 10 );
|
||||
writeData;
|
||||
end test
|
||||
end.
|
||||
|
|
@ -0,0 +1,156 @@
|
|||
/* ARM assembly Raspberry PI */
|
||||
/* program bubbleSort.s */
|
||||
|
||||
/* REMARK 1 : this program use routines in a include file
|
||||
see task Include a file language arm assembly
|
||||
for the routine affichageMess conversion10
|
||||
see at end of this program the instruction include */
|
||||
/* for constantes see task include a file in arm assembly */
|
||||
/************************************/
|
||||
/* Constantes */
|
||||
/************************************/
|
||||
.include "../constantes.inc"
|
||||
|
||||
/*********************************/
|
||||
/* Initialized data */
|
||||
/*********************************/
|
||||
.data
|
||||
szMessSortOk: .asciz "Table sorted.\n"
|
||||
szMessSortNok: .asciz "Table not sorted !!!!!.\n"
|
||||
sMessResult: .asciz "Value : @ \n"
|
||||
szCarriageReturn: .asciz "\n"
|
||||
|
||||
.align 4
|
||||
#TableNumber: .int 1,3,6,2,5,9,10,8,4,7
|
||||
TableNumber: .int 10,9,8,7,6,5,4,3,2,1
|
||||
.equ NBELEMENTS, (. - TableNumber) / 4
|
||||
/*********************************/
|
||||
/* UnInitialized data */
|
||||
/*********************************/
|
||||
.bss
|
||||
sZoneConv: .skip 24
|
||||
/*********************************/
|
||||
/* code section */
|
||||
/*********************************/
|
||||
.text
|
||||
.global main
|
||||
main: @ entry of program
|
||||
|
||||
1:
|
||||
ldr r0,iAdrTableNumber @ address number table
|
||||
mov r1,#0
|
||||
mov r2,#NBELEMENTS @ number of élements
|
||||
bl bubbleSort
|
||||
ldr r0,iAdrTableNumber @ address number table
|
||||
bl displayTable
|
||||
|
||||
ldr r0,iAdrTableNumber @ address number table
|
||||
mov r1,#NBELEMENTS @ number of élements
|
||||
bl isSorted @ control sort
|
||||
cmp r0,#1 @ sorted ?
|
||||
beq 2f
|
||||
ldr r0,iAdrszMessSortNok @ no !! error sort
|
||||
bl affichageMess
|
||||
b 100f
|
||||
2: @ yes
|
||||
ldr r0,iAdrszMessSortOk
|
||||
bl affichageMess
|
||||
100: @ standard end of the program
|
||||
mov r0, #0 @ return code
|
||||
mov r7, #EXIT @ request to exit program
|
||||
svc #0 @ perform the system call
|
||||
|
||||
iAdrszCarriageReturn: .int szCarriageReturn
|
||||
iAdrsMessResult: .int sMessResult
|
||||
iAdrTableNumber: .int TableNumber
|
||||
iAdrszMessSortOk: .int szMessSortOk
|
||||
iAdrszMessSortNok: .int szMessSortNok
|
||||
/******************************************************************/
|
||||
/* control sorted table */
|
||||
/******************************************************************/
|
||||
/* r0 contains the address of table */
|
||||
/* r1 contains the number of elements > 0 */
|
||||
/* r0 return 0 if not sorted 1 if sorted */
|
||||
isSorted:
|
||||
push {r2-r4,lr} @ save registers
|
||||
mov r2,#0
|
||||
ldr r4,[r0,r2,lsl #2]
|
||||
1:
|
||||
add r2,#1
|
||||
cmp r2,r1
|
||||
movge r0,#1
|
||||
bge 100f
|
||||
ldr r3,[r0,r2, lsl #2]
|
||||
cmp r3,r4
|
||||
movlt r0,#0
|
||||
blt 100f
|
||||
mov r4,r3
|
||||
b 1b
|
||||
100:
|
||||
pop {r2-r4,lr}
|
||||
bx lr @ return
|
||||
/******************************************************************/
|
||||
/* bubble sort */
|
||||
/******************************************************************/
|
||||
/* r0 contains the address of table */
|
||||
/* r1 contains the first element */
|
||||
/* r2 contains the number of element */
|
||||
bubbleSort:
|
||||
push {r1-r9,lr} @ save registers
|
||||
sub r2,r2,#1 @ compute i = n - 1
|
||||
add r8,r1,#1
|
||||
1: @ start loop 1
|
||||
mov r3,r1 @ start index
|
||||
mov r9,#0
|
||||
sub r7,r2,#1
|
||||
2: @ start loop 2
|
||||
add r4,r3,#1
|
||||
ldr r5,[r0,r3,lsl #2] @ load value A[j]
|
||||
ldr r6,[r0,r4,lsl #2] @ load value A[j+1]
|
||||
cmp r6,r5 @ compare value
|
||||
strlt r6,[r0,r3,lsl #2] @ if smaller inversion
|
||||
strlt r5,[r0,r4,lsl #2]
|
||||
movlt r9,#1 @ top table not sorted
|
||||
add r3,#1 @ increment index j
|
||||
cmp r3,r7 @ end ?
|
||||
ble 2b @ no -> loop 2
|
||||
cmp r9,#0 @ table sorted ?
|
||||
beq 100f @ yes -> end
|
||||
|
||||
sub r2,r2,#1 @ decrement i
|
||||
cmp r2,r8 @ end ?
|
||||
bge 1b @ no -> loop 1
|
||||
|
||||
100:
|
||||
pop {r1-r9,lr}
|
||||
bx lr @ return
|
||||
|
||||
/******************************************************************/
|
||||
/* Display table elements */
|
||||
/******************************************************************/
|
||||
/* r0 contains the address of table */
|
||||
displayTable:
|
||||
push {r0-r3,lr} @ save registers
|
||||
mov r2,r0 @ table address
|
||||
mov r3,#0
|
||||
1: @ loop display table
|
||||
ldr r0,[r2,r3,lsl #2]
|
||||
ldr r1,iAdrsZoneConv @
|
||||
bl conversion10 @ décimal conversion
|
||||
ldr r0,iAdrsMessResult
|
||||
ldr r1,iAdrsZoneConv @ insert conversion
|
||||
bl strInsertAtCharInc
|
||||
bl affichageMess @ display message
|
||||
add r3,#1
|
||||
cmp r3,#NBELEMENTS - 1
|
||||
ble 1b
|
||||
ldr r0,iAdrszCarriageReturn
|
||||
bl affichageMess
|
||||
100:
|
||||
pop {r0-r3,lr}
|
||||
bx lr
|
||||
iAdrsZoneConv: .int sZoneConv
|
||||
/***************************************************/
|
||||
/* ROUTINES INCLUDE */
|
||||
/***************************************************/
|
||||
.include "../affichage.inc"
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
{ # read every line into an array
|
||||
line[NR] = $0
|
||||
}
|
||||
END { # sort it with bubble sort
|
||||
do {
|
||||
haschanged = 0
|
||||
for(i=1; i < NR; i++) {
|
||||
if ( line[i] > line[i+1] ) {
|
||||
t = line[i]
|
||||
line[i] = line[i+1]
|
||||
line[i+1] = t
|
||||
haschanged = 1
|
||||
}
|
||||
}
|
||||
} while ( haschanged == 1 )
|
||||
# print it
|
||||
for(i=1; i <= NR; i++) {
|
||||
print line[i]
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,45 @@
|
|||
# Test this example file from command line with:
|
||||
#
|
||||
# awk -f file.awk /dev/null
|
||||
#
|
||||
# Code by Jari Aalto <jari.aalto A T cante net>
|
||||
# Licensed and released under GPL-2+, see http://spdx.org/licenses
|
||||
|
||||
function alen(array, dummy, len) {
|
||||
for (dummy in array)
|
||||
len++;
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
function sort(array, haschanged, len, tmp, i)
|
||||
{
|
||||
len = alen(array)
|
||||
haschanged = 1
|
||||
|
||||
while ( haschanged == 1 )
|
||||
{
|
||||
haschanged = 0
|
||||
|
||||
for (i = 1; i <= len - 1; i++)
|
||||
{
|
||||
if (array[i] > array[i+1])
|
||||
{
|
||||
tmp = array[i]
|
||||
array[i] = array[i + 1]
|
||||
array[i + 1] = tmp
|
||||
haschanged = 1
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
# An Example. Sorts array to order: b, c, z
|
||||
{
|
||||
array[1] = "c"
|
||||
array[2] = "z"
|
||||
array[3] = "b"
|
||||
sort(array)
|
||||
print array[1] " " array[2] " " array[3]
|
||||
exit
|
||||
}
|
||||
|
|
@ -0,0 +1,56 @@
|
|||
PROC PrintArray(INT ARRAY a INT size)
|
||||
INT i
|
||||
|
||||
Put('[)
|
||||
FOR i=0 TO size-1
|
||||
DO
|
||||
IF i>0 THEN Put(' ) FI
|
||||
PrintI(a(i))
|
||||
OD
|
||||
Put(']) PutE()
|
||||
RETURN
|
||||
|
||||
PROC BubbleSort(INT ARRAY a INT size)
|
||||
INT count,changed,i,tmp
|
||||
|
||||
count=size
|
||||
IF count<=1 THEN RETURN FI
|
||||
|
||||
DO
|
||||
changed=0
|
||||
count==-1
|
||||
FOR i=0 TO count-1
|
||||
DO
|
||||
IF a(i)>a(i+1) THEN
|
||||
tmp=a(i) a(i)=a(i+1) a(i+1)=tmp
|
||||
changed=1
|
||||
FI
|
||||
OD
|
||||
UNTIL changed=0
|
||||
OD
|
||||
RETURN
|
||||
|
||||
PROC Test(INT ARRAY a INT size)
|
||||
PrintE("Array before sort:")
|
||||
PrintArray(a,size)
|
||||
BubbleSort(a,size)
|
||||
PrintE("Array after sort:")
|
||||
PrintArray(a,size)
|
||||
PutE()
|
||||
RETURN
|
||||
|
||||
PROC Main()
|
||||
INT ARRAY
|
||||
a(10)=[1 4 65535 0 3 7 4 8 20 65530],
|
||||
b(21)=[10 9 8 7 6 5 4 3 2 1 0
|
||||
65535 65534 65533 65532 65531
|
||||
65530 65529 65528 65527 65526],
|
||||
c(8)=[101 102 103 104 105 106 107 108],
|
||||
d(12)=[1 65535 1 65535 1 65535 1
|
||||
65535 1 65535 1 65535]
|
||||
|
||||
Test(a,10)
|
||||
Test(b,21)
|
||||
Test(c,8)
|
||||
Test(d,12)
|
||||
RETURN
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
public function bubbleSort(toSort:Array):Array
|
||||
{
|
||||
var changed:Boolean = false;
|
||||
|
||||
while (!changed)
|
||||
{
|
||||
changed = true;
|
||||
|
||||
for (var i:int = 0; i < toSort.length - 1; i++)
|
||||
{
|
||||
if (toSort[i] > toSort[i + 1])
|
||||
{
|
||||
var tmp:int = toSort[i];
|
||||
toSort[i] = toSort[i + 1];
|
||||
toSort[i + 1] = tmp;
|
||||
|
||||
changed = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return toSort;
|
||||
}
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
generic
|
||||
type Element is private;
|
||||
with function "=" (E1, E2 : Element) return Boolean is <>;
|
||||
with function "<" (E1, E2 : Element) return Boolean is <>;
|
||||
type Index is (<>);
|
||||
type Arr is array (Index range <>) of Element;
|
||||
procedure Bubble_Sort (A : in out Arr);
|
||||
|
||||
procedure Bubble_Sort (A : in out Arr) is
|
||||
Finished : Boolean;
|
||||
Temp : Element;
|
||||
begin
|
||||
loop
|
||||
Finished := True;
|
||||
for J in A'First .. Index'Pred (A'Last) loop
|
||||
if A (Index'Succ (J)) < A (J) then
|
||||
Finished := False;
|
||||
Temp := A (Index'Succ (J));
|
||||
A (Index'Succ (J)) := A (J);
|
||||
A (J) := Temp;
|
||||
end if;
|
||||
end loop;
|
||||
exit when Finished;
|
||||
end loop;
|
||||
end Bubble_Sort;
|
||||
|
||||
-- Example of usage:
|
||||
with Ada.Text_IO; use Ada.Text_IO;
|
||||
with Bubble_Sort;
|
||||
procedure Main is
|
||||
type Arr is array (Positive range <>) of Integer;
|
||||
procedure Sort is new
|
||||
Bubble_Sort
|
||||
(Element => Integer,
|
||||
Index => Positive,
|
||||
Arr => Arr);
|
||||
A : Arr := (1, 3, 256, 0, 3, 4, -1);
|
||||
begin
|
||||
Sort (A);
|
||||
for J in A'Range loop
|
||||
Put (Integer'Image (A (J)));
|
||||
end loop;
|
||||
New_Line;
|
||||
end Main;
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
-- In-place bubble sort.
|
||||
on bubbleSort(theList, l, r) -- Sort items l thru r of theList.
|
||||
set listLen to (count theList)
|
||||
if (listLen < 2) then return
|
||||
-- Convert negative and/or transposed range indices.
|
||||
if (l < 0) then set l to listLen + l + 1
|
||||
if (r < 0) then set r to listLen + r + 1
|
||||
if (l > r) then set {l, r} to {r, l}
|
||||
|
||||
-- The list as a script property to allow faster references to its items.
|
||||
script o
|
||||
property lst : theList
|
||||
end script
|
||||
|
||||
set lPlus1 to l + 1
|
||||
repeat with j from r to lPlus1 by -1
|
||||
set lv to o's lst's item l
|
||||
-- Hereafter lv is only set when necessary and from rv rather than from the list.
|
||||
repeat with i from lPlus1 to j
|
||||
set rv to o's lst's item i
|
||||
if (lv > rv) then
|
||||
set o's lst's item (i - 1) to rv
|
||||
set o's lst's item i to lv
|
||||
else
|
||||
set lv to rv
|
||||
end if
|
||||
end repeat
|
||||
end repeat
|
||||
|
||||
return -- nothing.
|
||||
end bubbleSort
|
||||
property sort : bubbleSort
|
||||
|
||||
-- Demo:
|
||||
local aList
|
||||
set aList to {61, 23, 11, 55, 1, 94, 71, 98, 70, 33, 29, 77, 58, 95, 2, 52, 68, 29, 27, 37, 74, 38, 45, 73, 10}
|
||||
sort(aList, 1, -1) -- Sort items 1 thru -1 of aList.
|
||||
return aList
|
||||
|
|
@ -0,0 +1 @@
|
|||
{1, 2, 10, 11, 23, 27, 29, 29, 33, 37, 38, 45, 52, 55, 58, 61, 68, 70, 71, 73, 74, 77, 94, 95, 98}
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
0 GOSUB 7 : IC = I%(0)
|
||||
1 FOR HC = -1 TO 0
|
||||
2 LET IC = IC - 1
|
||||
3 FOR I = 1 TO IC
|
||||
4 IF I%(I) > I%(I + 1) THEN H = I%(I) : I%(I) = I%(I + 1) : I%(I + 1) = H : HC = -2 * (IC > 1)
|
||||
5 NEXT I, HC
|
||||
6 GOSUB 9 : END
|
||||
7 DIM I%(18000) : I%(0) = 50
|
||||
8 FOR I = 1 TO I%(0) : I%(I) = INT (RND(1) * 65535) - 32767 : NEXT
|
||||
9 FOR I = 1 TO I%(0) : PRINT I%(I)" "; : NEXT I : PRINT : RETURN
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
bubbleSort: function [items][
|
||||
len: size items
|
||||
loop len [j][
|
||||
i: 1
|
||||
while [i =< len-j] [
|
||||
if items\[i] < items\[i-1] [
|
||||
tmp: items\[i]
|
||||
items\[i]: items\[i-1]
|
||||
items\[i-1]: tmp
|
||||
]
|
||||
i: i + 1
|
||||
]
|
||||
]
|
||||
items
|
||||
]
|
||||
|
||||
print bubbleSort [3 1 2 8 5 7 9 4 6]
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
var =
|
||||
(
|
||||
dog
|
||||
cat
|
||||
pile
|
||||
abc
|
||||
)
|
||||
MsgBox % bubblesort(var)
|
||||
|
||||
bubblesort(var) ; each line of var is an element of the array
|
||||
{
|
||||
StringSplit, array, var, `n
|
||||
hasChanged = 1
|
||||
size := array0
|
||||
While hasChanged
|
||||
{
|
||||
hasChanged = 0
|
||||
Loop, % (size - 1)
|
||||
{
|
||||
i := array%A_Index%
|
||||
aj := A_Index + 1
|
||||
j := array%aj%
|
||||
If (j < i)
|
||||
{
|
||||
temp := array%A_Index%
|
||||
array%A_Index% := array%aj%
|
||||
array%aj% := temp
|
||||
hasChanged = 1
|
||||
}
|
||||
}
|
||||
}
|
||||
Loop, % size
|
||||
sorted .= array%A_Index% . "`n"
|
||||
Return sorted
|
||||
}
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
Dim a(11): ordered=false
|
||||
print "Original set"
|
||||
For n = 0 to 9
|
||||
a[n]=int(rand*20+1)
|
||||
print a[n]+", ";
|
||||
next n
|
||||
#algorithm
|
||||
while ordered=false
|
||||
ordered=true
|
||||
For n = 0 to 9
|
||||
if a[n]> a[n+1] then
|
||||
x=a[n]
|
||||
a[n]=a[n+1]
|
||||
a[n+1]=x
|
||||
ordered=false
|
||||
end if
|
||||
next n
|
||||
end while
|
||||
|
||||
print
|
||||
print "Ordered set"
|
||||
For n = 1 to 10
|
||||
print a[n]+", ";
|
||||
next n
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
DIM test(9)
|
||||
test() = 4, 65, 2, -31, 0, 99, 2, 83, 782, 1
|
||||
PROCbubblesort(test(), 10)
|
||||
FOR i% = 0 TO 9
|
||||
PRINT test(i%) ;
|
||||
NEXT
|
||||
PRINT
|
||||
END
|
||||
|
||||
DEF PROCbubblesort(a(), n%)
|
||||
LOCAL i%, l%
|
||||
REPEAT
|
||||
l% = 0
|
||||
FOR i% = 1 TO n%-1
|
||||
IF a(i%-1) > a(i%) THEN
|
||||
SWAP a(i%-1),a(i%)
|
||||
l% = i%
|
||||
ENDIF
|
||||
NEXT
|
||||
n% = l%
|
||||
UNTIL l% = 0
|
||||
ENDPROC
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
get "libhdr"
|
||||
|
||||
let bubblesort(v, length) be
|
||||
$( let sorted = false
|
||||
until sorted
|
||||
$( sorted := true
|
||||
length := length - 1
|
||||
for i=0 to length-1
|
||||
if v!i > v!(i+1)
|
||||
$( let x = v!i
|
||||
v!i := v!(i+1)
|
||||
v!(i+1) := x
|
||||
sorted := false
|
||||
$)
|
||||
$)
|
||||
$)
|
||||
|
||||
let start() be
|
||||
$( let v = table 10,8,6,4,2,1,3,5,7,9
|
||||
bubblesort(v, 10)
|
||||
for i=0 to 9 do writef("%N ", v!i)
|
||||
wrch('*N')
|
||||
$)
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
LOCAL t[] = { 5, 7, 1, 3, 10, 2, 9, 4, 8, 6 }
|
||||
total = 10
|
||||
WHILE total > 1
|
||||
FOR x = 0 TO total-1
|
||||
IF t[x] > t[x+1] THEN SWAP t[x], t[x+1]
|
||||
NEXT
|
||||
DECR total
|
||||
WEND
|
||||
PRINT COIL$(10, STR$(t[_-1]))
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
t$ = "Kiev Amsterdam Lima Moscow Warschau Vienna Paris Madrid Bonn Bern Rome"
|
||||
total = AMOUNT(t$)
|
||||
WHILE total > 1
|
||||
FOR x = 1 TO total-1
|
||||
IF TOKEN$(t$, x) > TOKEN$(t$, x+1) THEN t$ = EXCHANGE$(t$, x, x+1)
|
||||
NEXT
|
||||
DECR total
|
||||
WEND
|
||||
PRINT t$
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <iterator>
|
||||
|
||||
template <typename RandomAccessIterator>
|
||||
void bubble_sort(RandomAccessIterator begin, RandomAccessIterator end) {
|
||||
bool swapped = true;
|
||||
while (begin != end-- && swapped) {
|
||||
swapped = false;
|
||||
for (auto i = begin; i != end; ++i) {
|
||||
if (*(i + 1) < *i) {
|
||||
std::iter_swap(i, i + 1);
|
||||
swapped = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int main() {
|
||||
int a[] = {100, 2, 56, 200, -52, 3, 99, 33, 177, -199};
|
||||
bubble_sort(std::begin(a), std::end(a));
|
||||
copy(std::begin(a), std::end(a), std::ostream_iterator<int>(std::cout, " "));
|
||||
std::cout << "\n";
|
||||
}
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
using System;
|
||||
using System.Collections.Generic;
|
||||
|
||||
namespace RosettaCode.BubbleSort
|
||||
{
|
||||
public static class BubbleSortMethods
|
||||
{
|
||||
//The "this" keyword before the method parameter identifies this as a C# extension
|
||||
//method, which can be called using instance method syntax on any generic list,
|
||||
//without having to modify the generic List<T> code provided by the .NET framework.
|
||||
public static void BubbleSort<T>(this List<T> list) where T : IComparable
|
||||
{
|
||||
bool madeChanges;
|
||||
int itemCount = list.Count;
|
||||
do
|
||||
{
|
||||
madeChanges = false;
|
||||
itemCount--;
|
||||
for (int i = 0; i < itemCount; i++)
|
||||
{
|
||||
if (list[i].CompareTo(list[i + 1]) > 0)
|
||||
{
|
||||
T temp = list[i + 1];
|
||||
list[i + 1] = list[i];
|
||||
list[i] = temp;
|
||||
madeChanges = true;
|
||||
}
|
||||
}
|
||||
} while (madeChanges);
|
||||
}
|
||||
}
|
||||
|
||||
//A short test program to demonstrate the BubbleSort. The compiler will change the
|
||||
//call to testList.BubbleSort() into one to BubbleSortMethods.BubbleSort<T>(testList).
|
||||
class Program
|
||||
{
|
||||
static void Main()
|
||||
{
|
||||
List<int> testList = new List<int> { 3, 7, 3, 2, 1, -4, 10, 12, 4 };
|
||||
testList.BubbleSort();
|
||||
foreach (var t in testList) Console.Write(t + " ");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
#include <stdio.h>
|
||||
|
||||
void bubble_sort (int *a, int n) {
|
||||
int i, t, j = n, s = 1;
|
||||
while (s) {
|
||||
s = 0;
|
||||
for (i = 1; i < j; i++) {
|
||||
if (a[i] < a[i - 1]) {
|
||||
t = a[i];
|
||||
a[i] = a[i - 1];
|
||||
a[i - 1] = t;
|
||||
s = 1;
|
||||
}
|
||||
}
|
||||
j--;
|
||||
}
|
||||
}
|
||||
|
||||
int main () {
|
||||
int a[] = {4, 65, 2, -31, 0, 99, 2, 83, 782, 1};
|
||||
int n = sizeof a / sizeof a[0];
|
||||
int i;
|
||||
for (i = 0; i < n; i++)
|
||||
printf("%d%s", a[i], i == n - 1 ? "\n" : " ");
|
||||
bubble_sort(a, n);
|
||||
for (i = 0; i < n; i++)
|
||||
printf("%d%s", a[i], i == n - 1 ? "\n" : " ");
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
% Bubble-sort an array in place.
|
||||
bubble_sort = proc [T: type] (a: array[T])
|
||||
where T has lt: proctype (T,T) returns (bool)
|
||||
|
||||
bound_lo: int := array[T]$low(a)
|
||||
bound_hi: int := array[T]$high(a)
|
||||
|
||||
for hi: int in int$from_to_by(bound_hi, bound_lo, -1) do
|
||||
for i: int in int$from_to(bound_lo, hi-1) do
|
||||
if a[hi] < a[i] then
|
||||
temp: T := a[i]
|
||||
a[i] := a[hi]
|
||||
a[hi] := temp
|
||||
end
|
||||
end
|
||||
end
|
||||
end bubble_sort
|
||||
|
||||
% Print an array
|
||||
print_arr = proc [T: type] (a: array[T], w: int, s: stream)
|
||||
where T has unparse: proctype (T) returns (string)
|
||||
for el: T in array[T]$elements(a) do
|
||||
stream$putright(s, T$unparse(el), w)
|
||||
end
|
||||
stream$putc(s, '\n')
|
||||
end print_arr
|
||||
|
||||
start_up = proc ()
|
||||
ai = array[int]
|
||||
po: stream := stream$primary_output()
|
||||
test: ai := ai$[7, -5, 0, 2, 99, 16, 4, 20, 47, 19]
|
||||
|
||||
stream$puts(po, "Before: ") print_arr[int](test, 3, po)
|
||||
bubble_sort[int](test)
|
||||
stream$puts(po, "After: ") print_arr[int](test, 3, po)
|
||||
end start_up
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
# bubble_sort(var [value1 value2...]) sorts a list of integers.
|
||||
function(bubble_sort var)
|
||||
math(EXPR last "${ARGC} - 1") # Prepare to sort ARGV[1]..ARGV[last].
|
||||
set(again YES)
|
||||
while(again)
|
||||
set(again NO)
|
||||
math(EXPR last "${last} - 1") # Decrement last index.
|
||||
foreach(index RANGE 1 ${last}) # Loop for each index.
|
||||
math(EXPR index_plus_1 "${index} + 1")
|
||||
set(a "${ARGV${index}}") # a = ARGV[index]
|
||||
set(b "${ARGV${index_plus_1}}") # b = ARGV[index + 1]
|
||||
if(a GREATER "${b}") # If a > b...
|
||||
set(ARGV${index} "${b}") # ...then swap a, b
|
||||
set(ARGV${index_plus_1} "${a}") # inside ARGV.
|
||||
set(again YES)
|
||||
endif()
|
||||
endforeach(index)
|
||||
endwhile()
|
||||
|
||||
set(answer)
|
||||
math(EXPR last "${ARGC} - 1")
|
||||
foreach(index RANGE 1 "${last}")
|
||||
list(APPEND answer "${ARGV${index}}")
|
||||
endforeach(index)
|
||||
set("${var}" "${answer}" PARENT_SCOPE)
|
||||
endfunction(bubble_sort)
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
bubble_sort(result 33 11 44 22 66 55)
|
||||
message(STATUS "${result}")
|
||||
|
|
@ -0,0 +1,145 @@
|
|||
IDENTIFICATION DIVISION.
|
||||
PROGRAM-ID. BUBBLESORT.
|
||||
AUTHOR. DAVE STRATFORD.
|
||||
DATE-WRITTEN. MARCH 2010.
|
||||
INSTALLATION. HEXAGON SYSTEMS LIMITED.
|
||||
|
||||
ENVIRONMENT DIVISION.
|
||||
CONFIGURATION SECTION.
|
||||
SOURCE-COMPUTER. ICL VME.
|
||||
OBJECT-COMPUTER. ICL VME.
|
||||
|
||||
INPUT-OUTPUT SECTION.
|
||||
FILE-CONTROL.
|
||||
SELECT FA-INPUT-FILE ASSIGN FL01.
|
||||
SELECT FB-OUTPUT-FILE ASSIGN FL02.
|
||||
|
||||
DATA DIVISION.
|
||||
FILE SECTION.
|
||||
|
||||
FD FA-INPUT-FILE.
|
||||
01 FA-INPUT-REC.
|
||||
03 FA-DATA PIC S9(6).
|
||||
|
||||
FD FB-OUTPUT-FILE.
|
||||
01 FB-OUTPUT-REC PIC S9(6).
|
||||
|
||||
WORKING-STORAGE SECTION.
|
||||
01 WA-IDENTITY.
|
||||
03 WA-PROGNAME PIC X(10) VALUE "BUBBLESORT".
|
||||
03 WA-VERSION PIC X(6) VALUE "000001".
|
||||
|
||||
01 WB-TABLE.
|
||||
03 WB-ENTRY PIC 9(8) COMP SYNC OCCURS 100000
|
||||
INDEXED BY WB-IX-1.
|
||||
|
||||
01 WC-VARS.
|
||||
03 WC-SIZE PIC S9(8) COMP SYNC.
|
||||
03 WC-TEMP PIC S9(8) COMP SYNC.
|
||||
03 WC-END PIC S9(8) COMP SYNC.
|
||||
03 WC-LAST-CHANGE PIC S9(8) COMP SYNC.
|
||||
|
||||
01 WF-CONDITION-FLAGS.
|
||||
03 WF-EOF-FLAG PIC X.
|
||||
88 END-OF-FILE VALUE "Y".
|
||||
03 WF-EMPTY-FILE-FLAG PIC X.
|
||||
88 EMPTY-FILE VALUE "Y".
|
||||
|
||||
PROCEDURE DIVISION.
|
||||
A-MAIN SECTION.
|
||||
A-000.
|
||||
PERFORM B-INITIALISE.
|
||||
IF NOT EMPTY-FILE
|
||||
PERFORM C-SORT.
|
||||
PERFORM D-FINISH.
|
||||
|
||||
A-999.
|
||||
STOP RUN.
|
||||
|
||||
B-INITIALISE SECTION.
|
||||
B-000.
|
||||
DISPLAY "*** " WA-PROGNAME " VERSION "
|
||||
WA-VERSION " STARTING ***".
|
||||
|
||||
MOVE ALL "N" TO WF-CONDITION-FLAGS.
|
||||
OPEN INPUT FA-INPUT-FILE.
|
||||
SET WB-IX-1 TO 0.
|
||||
|
||||
READ FA-INPUT-FILE AT END MOVE "Y" TO WF-EOF-FLAG
|
||||
WF-EMPTY-FILE-FLAG.
|
||||
|
||||
PERFORM BA-READ-INPUT UNTIL END-OF-FILE.
|
||||
|
||||
CLOSE FA-INPUT-FILE.
|
||||
|
||||
SET WC-SIZE TO WB-IX-1.
|
||||
|
||||
B-999.
|
||||
EXIT.
|
||||
|
||||
BA-READ-INPUT SECTION.
|
||||
BA-000.
|
||||
SET WB-IX-1 UP BY 1.
|
||||
MOVE FA-DATA TO WB-ENTRY(WB-IX-1).
|
||||
|
||||
READ FA-INPUT-FILE AT END MOVE "Y" TO WF-EOF-FLAG.
|
||||
|
||||
BA-999.
|
||||
EXIT.
|
||||
|
||||
C-SORT SECTION.
|
||||
C-000.
|
||||
DISPLAY "SORT STARTING".
|
||||
|
||||
MOVE WC-SIZE TO WC-END.
|
||||
PERFORM E-BUBBLE UNTIL WC-END = 1.
|
||||
|
||||
DISPLAY "SORT FINISHED".
|
||||
|
||||
C-999.
|
||||
EXIT.
|
||||
|
||||
D-FINISH SECTION.
|
||||
D-000.
|
||||
OPEN OUTPUT FB-OUTPUT-FILE.
|
||||
SET WB-IX-1 TO 1.
|
||||
|
||||
PERFORM DA-WRITE-OUTPUT UNTIL WB-IX-1 > WC-SIZE.
|
||||
|
||||
CLOSE FB-OUTPUT-FILE.
|
||||
|
||||
DISPLAY "*** " WA-PROGNAME " FINISHED ***".
|
||||
|
||||
D-999.
|
||||
EXIT.
|
||||
|
||||
DA-WRITE-OUTPUT SECTION.
|
||||
DA-000.
|
||||
WRITE FB-OUTPUT-REC FROM WB-ENTRY(WB-IX-1).
|
||||
SET WB-IX-1 UP BY 1.
|
||||
|
||||
DA-999.
|
||||
EXIT.
|
||||
|
||||
E-BUBBLE SECTION.
|
||||
E-000.
|
||||
MOVE 1 TO WC-LAST-CHANGE.
|
||||
|
||||
PERFORM F-PASS VARYING WB-IX-1 FROM 1 BY 1
|
||||
UNTIL WB-IX-1 = WC-END.
|
||||
|
||||
MOVE WC-LAST-CHANGE TO WC-END.
|
||||
|
||||
E-999.
|
||||
EXIT.
|
||||
|
||||
F-PASS SECTION.
|
||||
F-000.
|
||||
IF WB-ENTRY(WB-IX-1) > WB-ENTRY(WB-IX-1 + 1)
|
||||
SET WC-LAST-CHANGE TO WB-IX-1
|
||||
MOVE WB-ENTRY(WB-IX-1) TO WC-TEMP
|
||||
MOVE WB-ENTRY(WB-IX-1 + 1) TO WB-ENTRY(WB-IX-1)
|
||||
MOVE WC-TEMP TO WB-ENTRY(WB-IX-1 + 1).
|
||||
|
||||
F-999.
|
||||
EXIT.
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
identification division.
|
||||
program-id. BUBBLSRT.
|
||||
data division.
|
||||
working-storage section.
|
||||
01 changed-flag pic x.
|
||||
88 hasChanged value 'Y'.
|
||||
88 hasNOTChanged value 'N'.
|
||||
01 itemCount pic 99.
|
||||
01 tempItem pic 99.
|
||||
01 itemArray.
|
||||
03 itemArrayCount pic 99.
|
||||
03 item pic 99 occurs 99 times
|
||||
indexed by itemIndex.
|
||||
*
|
||||
procedure division.
|
||||
main.
|
||||
* place the values to sort into itemArray
|
||||
move 10 to itemArrayCount
|
||||
move 28 to item (1)
|
||||
move 44 to item (2)
|
||||
move 46 to item (3)
|
||||
move 24 to item (4)
|
||||
move 19 to item (5)
|
||||
move 2 to item (6)
|
||||
move 17 to item (7)
|
||||
move 11 to item (8)
|
||||
move 24 to item (9)
|
||||
move 4 to item (10)
|
||||
* store the starting count in itemCount and perform the sort
|
||||
move itemArrayCount to itemCount
|
||||
perform bubble-sort
|
||||
* output the results
|
||||
perform varying itemIndex from 1 by 1
|
||||
until itemIndex > itemArrayCount
|
||||
display item (itemIndex) ';' with no advancing
|
||||
end-perform
|
||||
* thats it!
|
||||
stop run.
|
||||
*
|
||||
bubble-sort.
|
||||
perform with test after until hasNOTchanged
|
||||
set hasNOTChanged to true
|
||||
subtract 1 from itemCount
|
||||
perform varying itemIndex from 1 by 1
|
||||
until itemIndex > itemCount
|
||||
if item (itemIndex) > item (itemIndex + 1)
|
||||
move item (itemIndex) to tempItem
|
||||
move item (itemIndex + 1) to item (itemIndex)
|
||||
move tempItem to item (itemIndex + 1)
|
||||
set hasChanged to true
|
||||
end-if
|
||||
end-perform
|
||||
end-perform
|
||||
.
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
(ns bubblesort
|
||||
(:import java.util.ArrayList))
|
||||
|
||||
(defn bubble-sort
|
||||
"Sort in-place.
|
||||
arr must implement the Java List interface and should support
|
||||
random access, e.g. an ArrayList."
|
||||
([arr] (bubble-sort compare arr))
|
||||
([cmp arr]
|
||||
(letfn [(swap! [i j]
|
||||
(let [t (.get arr i)]
|
||||
(doto arr
|
||||
(.set i (.get arr j))
|
||||
(.set j t))))
|
||||
(sorter [stop-i]
|
||||
(let [changed (atom false)]
|
||||
(doseq [i (range stop-i)]
|
||||
(if (pos? (cmp (.get arr i) (.get arr (inc i))))
|
||||
(do
|
||||
(swap! i (inc i))
|
||||
(reset! changed true))))
|
||||
@changed))]
|
||||
(doseq [stop-i (range (dec (.size arr)) -1 -1)
|
||||
:while (sorter stop-i)])
|
||||
arr)))
|
||||
|
||||
(println (bubble-sort (ArrayList. [10 9 8 7 6 5 4 3 2 1])))
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
(defn- bubble-step
|
||||
"was-changed: whether any elements prior to the current first element
|
||||
were swapped;
|
||||
returns a two-element vector [partially-sorted-sequence is-sorted]"
|
||||
[less? xs was-changed]
|
||||
(if (< (count xs) 2)
|
||||
[xs (not was-changed)]
|
||||
(let [[x1 x2 & xr] xs
|
||||
first-is-smaller (less? x1 x2)
|
||||
is-changed (or was-changed (not first-is-smaller))
|
||||
[smaller larger] (if first-is-smaller [x1 x2] [x2 x1])
|
||||
[result is-sorted] (bubble-step
|
||||
less? (cons larger xr) is-changed)]
|
||||
[(cons smaller result) is-sorted])))
|
||||
|
||||
(defn bubble-sort
|
||||
"Takes an optional less-than predicate and a sequence.
|
||||
Returns the sorted sequence.
|
||||
Very inefficient (O(n²))"
|
||||
([xs] (bubble-sort <= xs))
|
||||
([less? xs]
|
||||
(let [[result is-sorted] (bubble-step less? xs false)]
|
||||
(if is-sorted
|
||||
result
|
||||
(recur less? result)))))
|
||||
|
||||
(println (bubble-sort [10 9 8 7 6 5 4 3 2 1]))
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
5 REM ===============================================
|
||||
10 REM HTTP://ROSETTACODE.ORG/
|
||||
20 REM TASK=SORTING ALGORITHMS/BUBBLE SORT
|
||||
30 REM LANGUAGE=COMMODORE 64 BASIC V2
|
||||
40 REM DATE=2020-08-17
|
||||
50 REM CODING BY=ALVALONGO
|
||||
60 REM FILE=BUBLE.PRG
|
||||
70 REM ============================================
|
||||
|
||||
100 PRINT "SORTING ALGORITHMS/BUBBLE SORT"
|
||||
110 GOSUB 700
|
||||
120 GOSUB 800
|
||||
130 PRINT "RESULT:"
|
||||
140 GOSUB 600
|
||||
150 END
|
||||
|
||||
600 REM DISPLAY DATA================================
|
||||
610 FOR K=1 TO N
|
||||
620 PRINT A(K);
|
||||
630 NEXT K
|
||||
640 PRINT
|
||||
650 RETURN
|
||||
|
||||
700 REM LOAD DATA ==================================
|
||||
720 READ N
|
||||
730 DIM A(N)
|
||||
740 FOR I=1 TO N
|
||||
750 READ A(I)
|
||||
760 NEXT I
|
||||
770 RETURN
|
||||
|
||||
800 REM BUBBLE SORT ================================
|
||||
810 FOR I=1 TO N
|
||||
815 PRINT "I=";I
|
||||
820 GOSUB 600
|
||||
830 SW=-1
|
||||
840 FOR J=1 TO N-I
|
||||
850 IF A(J)>A(J+1) THEN T=A(J):A(J)=A(J+1):A(J+1)=T:SW=0
|
||||
860 NEXT J
|
||||
865 PRINT "SW=";SW
|
||||
870 IF SW THEN I=N
|
||||
880 NEXT I
|
||||
890 RETURN
|
||||
|
||||
900 REM DATA==========================================
|
||||
910 DATA 15
|
||||
920 DATA 64,34,25,12,22,11,90,13,59,47,19,89,10,17,31
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
(defun bubble-sort (sequence &optional (compare #'<))
|
||||
"sort a sequence (array or list) with an optional comparison function (cl:< is the default)"
|
||||
(loop with sorted = nil until sorted do
|
||||
(setf sorted t)
|
||||
(loop for a below (1- (length sequence)) do
|
||||
(unless (funcall compare (elt sequence a)
|
||||
(elt sequence (1+ a)))
|
||||
(rotatef (elt sequence a)
|
||||
(elt sequence (1+ a)))
|
||||
(setf sorted nil)))))
|
||||
|
|
@ -0,0 +1 @@
|
|||
(bubble-sort (list 5 4 3 2 1))
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
(defun bubble-sort-vector (vector predicate &aux (len (1- (length vector))))
|
||||
(do ((swapped t)) ((not swapped) vector)
|
||||
(setf swapped nil)
|
||||
(do ((i (min 0 len) (1+ i))) ((eql i len))
|
||||
(when (funcall predicate (aref vector (1+ i)) (aref vector i))
|
||||
(rotatef (aref vector i) (aref vector (1+ i)))
|
||||
(setf swapped t)))))
|
||||
|
||||
(defun bubble-sort-list (list predicate)
|
||||
(do ((swapped t)) ((not swapped) list)
|
||||
(setf swapped nil)
|
||||
(do ((list list (rest list))) ((endp (rest list)))
|
||||
(when (funcall predicate (second list) (first list))
|
||||
(rotatef (first list) (second list))
|
||||
(setf swapped t)))))
|
||||
|
||||
(defun bubble-sort (sequence predicate)
|
||||
(etypecase sequence
|
||||
(list (bubble-sort-list sequence predicate))
|
||||
(vector (bubble-sort-vector sequence predicate))))
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
include "cowgol.coh";
|
||||
|
||||
# Comparator interface, on the model of C, i.e:
|
||||
# foo < bar => -1, foo == bar => 0, foo > bar => 1
|
||||
typedef CompRslt is int(-1, 1);
|
||||
interface Comparator(foo: intptr, bar: intptr): (rslt: CompRslt);
|
||||
|
||||
# Bubble sort an array of pointer-sized integers given a comparator function
|
||||
# (This is the closest you can get to polymorphism in Cowgol).
|
||||
sub bubbleSort(A: [intptr], len: intptr, comp: Comparator) is
|
||||
loop
|
||||
var swapped: uint8 := 0;
|
||||
var i: intptr := 1;
|
||||
var a := @next A;
|
||||
while i < len loop
|
||||
if comp([@prev a], [a]) == 1 then
|
||||
var t := [a];
|
||||
[a] := [@prev a];
|
||||
[@prev a] := t;
|
||||
swapped := 1;
|
||||
end if;
|
||||
a := @next a;
|
||||
i := i + 1;
|
||||
end loop;
|
||||
if swapped == 0 then
|
||||
return;
|
||||
end if;
|
||||
end loop;
|
||||
end sub;
|
||||
|
||||
# Test: sort a list of numbers
|
||||
sub NumComp implements Comparator is
|
||||
# Compare the inputs as numbers
|
||||
if foo < bar then rslt := -1;
|
||||
elseif foo > bar then rslt := 1;
|
||||
else rslt := 0;
|
||||
end if;
|
||||
end sub;
|
||||
|
||||
# Numbers
|
||||
var numbers: intptr[] := {
|
||||
65,13,4,84,29,5,96,73,5,11,17,76,38,26,44,20,36,12,44,51,79,8,99,7,19,95,26
|
||||
};
|
||||
|
||||
# Sort the numbers in place
|
||||
bubbleSort(&numbers as [intptr], @sizeof numbers, NumComp);
|
||||
|
||||
# Print the numbers (hopefully in order)
|
||||
var i: @indexof numbers := 0;
|
||||
while i < @sizeof numbers loop
|
||||
print_i32(numbers[i] as uint32);
|
||||
print_char(' ');
|
||||
i := i + 1;
|
||||
end loop;
|
||||
print_nl();
|
||||
|
|
@ -0,0 +1,56 @@
|
|||
define sort = 0, index = 0, size = 10
|
||||
define temp1 = 0, temp2 = 0
|
||||
|
||||
dim list[size]
|
||||
|
||||
gosub fill
|
||||
gosub sort
|
||||
gosub show
|
||||
|
||||
end
|
||||
|
||||
sub fill
|
||||
|
||||
for index = 0 to size - 1
|
||||
|
||||
let list[index] = int(rnd * 100)
|
||||
|
||||
next index
|
||||
|
||||
return
|
||||
|
||||
sub sort
|
||||
|
||||
do
|
||||
|
||||
let sort = 0
|
||||
for index = 0 to size - 2
|
||||
|
||||
let temp1 = index + 1
|
||||
|
||||
if list[index] > list[temp1] then
|
||||
|
||||
let temp2 = list[index]
|
||||
let list[index] = list[temp1]
|
||||
let list[temp1] = temp2
|
||||
let sort = 1
|
||||
|
||||
endif
|
||||
|
||||
next index
|
||||
|
||||
wait
|
||||
|
||||
loop sort = 1
|
||||
|
||||
return
|
||||
|
||||
sub show
|
||||
|
||||
for index = 0 to size - 1
|
||||
|
||||
print index ," : ", list[index]
|
||||
|
||||
next index
|
||||
|
||||
return
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
import std.stdio, std.algorithm : swap;
|
||||
|
||||
T[] bubbleSort(T)(T[] data) pure nothrow
|
||||
{
|
||||
foreach_reverse (n; 0 .. data.length)
|
||||
{
|
||||
bool swapped;
|
||||
foreach (i; 0 .. n)
|
||||
if (data[i] > data[i + 1]) {
|
||||
swap(data[i], data[i + 1]);
|
||||
swapped = true;
|
||||
}
|
||||
if (!swapped)
|
||||
break;
|
||||
}
|
||||
return data;
|
||||
}
|
||||
|
||||
|
||||
void main()
|
||||
{
|
||||
auto array = [28, 44, 46, 24, 19, 2, 17, 11, 25, 4];
|
||||
writeln(array.bubbleSort());
|
||||
}
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
program TestBubbleSort;
|
||||
|
||||
{$APPTYPE CONSOLE}
|
||||
|
||||
{.$DEFINE DYNARRAY} // remove '.' to compile with dynamic array
|
||||
|
||||
type
|
||||
TItem = Integer; // declare ordinal type for array item
|
||||
{$IFDEF DYNARRAY}
|
||||
TArray = array of TItem; // dynamic array
|
||||
{$ELSE}
|
||||
TArray = array[0..15] of TItem; // static array
|
||||
{$ENDIF}
|
||||
|
||||
procedure BubbleSort(var A: TArray);
|
||||
var
|
||||
Item: TItem;
|
||||
K, L, J: Integer;
|
||||
|
||||
begin
|
||||
L:= Low(A) + 1;
|
||||
repeat
|
||||
K:= High(A);
|
||||
for J:= High(A) downto L do begin
|
||||
if A[J - 1] > A[J] then begin
|
||||
Item:= A[J - 1];
|
||||
A[J - 1]:= A[J];
|
||||
A[J]:= Item;
|
||||
K:= J;
|
||||
end;
|
||||
end;
|
||||
L:= K + 1;
|
||||
until L > High(A);
|
||||
end;
|
||||
|
||||
var
|
||||
A: TArray;
|
||||
I: Integer;
|
||||
|
||||
begin
|
||||
{$IFDEF DYNARRAY}
|
||||
SetLength(A, 16);
|
||||
{$ENDIF}
|
||||
for I:= Low(A) to High(A) do
|
||||
A[I]:= Random(100);
|
||||
for I:= Low(A) to High(A) do
|
||||
Write(A[I]:3);
|
||||
Writeln;
|
||||
BubbleSort(A);
|
||||
for I:= Low(A) to High(A) do
|
||||
Write(A[I]:3);
|
||||
Writeln;
|
||||
Readln;
|
||||
end.
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
/* Bubble sort an array of integers */
|
||||
proc nonrec bubblesort([*] int a) void:
|
||||
bool sorted;
|
||||
int i, temp;
|
||||
sorted := false;
|
||||
while not sorted do
|
||||
sorted := true;
|
||||
for i from 1 upto dim(a,1)-1 do
|
||||
if a[i-1] > a[i] then
|
||||
sorted := false;
|
||||
temp := a[i-1];
|
||||
a[i-1] := a[i];
|
||||
a[i] := temp
|
||||
fi
|
||||
od
|
||||
od
|
||||
corp
|
||||
|
||||
/* Test */
|
||||
proc nonrec main() void:
|
||||
int i;
|
||||
[10] int a = (9, -5, 3, 3, 24, -16, 3, -120, 250, 17);
|
||||
|
||||
write("Before sorting: ");
|
||||
for i from 0 upto 9 do write(a[i]:5) od;
|
||||
writeln();
|
||||
|
||||
bubblesort(a);
|
||||
write("After sorting: ");
|
||||
for i from 0 upto 9 do write(a[i]:5) od
|
||||
corp
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
func bubbleSort(list) {
|
||||
var done = false
|
||||
while !done {
|
||||
done = true
|
||||
for i in 1..(list.Length()-1) {
|
||||
if list[i - 1] > list[i] {
|
||||
var x = list[i]
|
||||
list[i] = list[i - 1]
|
||||
list[i - 1] = x
|
||||
done = false
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var xs = [3,1,5,4,2,6]
|
||||
bubbleSort(xs)
|
||||
print(xs)
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
def bubbleSort(target) {
|
||||
__loop(fn {
|
||||
var changed := false
|
||||
for i in 0..(target.size() - 2) {
|
||||
def [a, b] := target(i, i + 2)
|
||||
if (a > b) {
|
||||
target(i, i + 2) := [b, a]
|
||||
changed := true
|
||||
}
|
||||
}
|
||||
changed
|
||||
})
|
||||
}
|
||||
|
|
@ -0,0 +1,151 @@
|
|||
[Bubble sort demo for Rosetta Code website]
|
||||
[EDSAC program. Initial Orders 2]
|
||||
|
||||
[Sorts a list of double-word integers.
|
||||
List must be loaded at an even address.
|
||||
First item gives number of items to follow.
|
||||
Address of list is placed in location 49.
|
||||
List can then be referred to with code letter L.]
|
||||
T49K
|
||||
P300F [<---------- address of list here]
|
||||
|
||||
[Subroutine R2, reads positive integers during input of orders.
|
||||
Items separated by F; list ends with #TZ.]
|
||||
GKT20FVDL8FA40DUDTFI40FA40FS39FG@S2FG23FA5@T5@E4@E13Z
|
||||
|
||||
[Tell R2 where to store integers it reads from tape.]
|
||||
T #L ['T m D' in documentation, but this also works]
|
||||
|
||||
[Lists of integers, comment out all except one]
|
||||
[10 integers from digits of pi]
|
||||
10F314159F265358F979323F846264F338327F950288F419716F939937F510582F097494#TZ
|
||||
|
||||
[32 integers from digits of e ]
|
||||
[32F
|
||||
27182818F28459045F23536028F74713526F62497757F24709369F99595749F66967627F
|
||||
72407663F03535475F94571382F17852516F64274274F66391932F00305992F18174135F
|
||||
96629043F57290033F42952605F95630738F13232862F79434907F63233829F88075319F
|
||||
52510190F11573834F18793070F21540891F49934884F16750924F47614606F68082264#TZ]
|
||||
|
||||
[Library subroutine P7, prints positive integer at 0D.
|
||||
35 locations; load at aneven address.]
|
||||
T 56 K
|
||||
GKA3FT26@H28#@NDYFLDT4DS27@TFH8@S8@T1FV4DAFG31@SFLDUFOFFFSFL4F
|
||||
T4DA1FA27@G11@XFT28#ZPFT27ZP1024FP610D@524D!FO30@SFL8FE22@
|
||||
|
||||
[The EDSAC code below implements the following Pascal program,
|
||||
where the integers to be sorted are in a 1-based array x.
|
||||
Since the assembler used (EdsacPC by Martin Campbell-Kelly)
|
||||
doesn't allow square brackets inside comments, they are
|
||||
replaced here by curly brackets.]
|
||||
[
|
||||
swapped := true;
|
||||
j := n; // number of items
|
||||
while (swapped and (j >= 2)) do begin
|
||||
swapped := false;
|
||||
for i := 1 to j - 1 do begin
|
||||
// Using temp in the comparison makes the EDSAC code a bit simpler
|
||||
temp := x{i};
|
||||
if (x{i + 1} < temp) then begin
|
||||
x{i} := x{i + 1};
|
||||
x{i + 1} := temp;
|
||||
swapped := true;
|
||||
end;
|
||||
end;
|
||||
dec(j);
|
||||
end;
|
||||
]
|
||||
[Main routine]
|
||||
T 100 K
|
||||
G K
|
||||
[0] P F P F [double-word temporary store]
|
||||
[2] P F [flag for swapped, >= 0 if true, < 0 if false]
|
||||
[3] P F ['A' order for x{j}; implicitly defines j]
|
||||
[4] P 2 F [to change list index by 1, i.e.change address by 2]
|
||||
[5] A #L ['A' order for number of items]
|
||||
[6] A 2#L ['A' order for x{1}]
|
||||
[7] A 4#L ['A' order for x{2}]
|
||||
[8] I2046 F [add to convert 'A' order to 'T' and dec address by 2]
|
||||
[9] K4096 F [(1) minimum 17-bit value (2) teleprinter null]
|
||||
[10] P D [constant 1, used in printing]
|
||||
[11] # F [figure shift]
|
||||
[12] & F [line feed]
|
||||
[13] @ F [carriage return]
|
||||
|
||||
[Enter here with acc = 0]
|
||||
[14] T 2 @ [swapped := true]
|
||||
A L [get count, n in Pascal program above]
|
||||
L 1 F [times 4 by shifting]
|
||||
A 5 @ [make 'A' order for x{n}; initializes j := n]
|
||||
|
||||
[Start 'while' loop of Pascal program.
|
||||
Here acc = 'A' order for x{j}]
|
||||
[18] U 3 @ [update j]
|
||||
S 7 @ [subtract 'A' order for x{2}]
|
||||
G 56 @ [if j < 2 then done]
|
||||
T F [acc := 0]
|
||||
A 2 @ [test for swapped, acc >= 0 if so]
|
||||
G 56 @ [if not swapped then done]
|
||||
A 9 @ [change acc from >= 0 to < 0]
|
||||
T 2 @ [swapped := false until swap occurs]
|
||||
A 6 @ ['A' order for x{1}; initializes i := 1]
|
||||
|
||||
[Start 'for' loop of Pascal program.
|
||||
Here acc = 'A' order for x{i}]
|
||||
[27] U 36 @ [store order]
|
||||
S 3 @ [subtract 'A' order for x{j}]
|
||||
E 52 @ [out of 'for' loop if i >= j]
|
||||
T F [clear acc]
|
||||
A 36 @ [load 'A' order for x{i}]
|
||||
A 4 @ [inc address by 2]
|
||||
U 38 @ [plant 'A' order for x{i + 1}]
|
||||
A 8 @ ['A' to 'T', and dec address by 2]
|
||||
T 42 @ [plant 'T' order for x{i}]
|
||||
[36] A #L [load x{i}; this order implicitly defines i]
|
||||
T #@ [temp := x{i}]
|
||||
[38] A #L [load x{i + 1}]
|
||||
S #@ [acc := x{i + 1} - temp]
|
||||
E 49 @ [don't swap if x{i + 1} >= temp]
|
||||
|
||||
[Here to swap x{i} and x{i + 1}]
|
||||
A #@ [restore acc := x{i + 1} after test]
|
||||
[42] T #L [x{i} := x{i + 1}]
|
||||
A 42 @ [load 'T' order for x{i}]
|
||||
A 4 @ [inc address by 2]
|
||||
T 47 @ [plant 'T' order for x{i + 1}]
|
||||
A #@ [load temp]
|
||||
[47] T #L [to x{i + 1}]
|
||||
T 2 @ [swapped := 0 (true)]
|
||||
|
||||
[49] T F [clear acc]
|
||||
A 38 @ [load 'A' order for x{i + 1}]
|
||||
G 27 @ [loop (unconditional) to inc i]
|
||||
|
||||
[52] T F
|
||||
A 3 @ [load 'A' order for x{j}]
|
||||
S 4 @ [dec address by 2]
|
||||
G 18 @ [loop (unconditional) to dec j]
|
||||
|
||||
[Print the sorted list of integers]
|
||||
[56] O 11 @ [figure shift]
|
||||
T F [clear acc]
|
||||
A 5 @ [load 'A' order for head of list]
|
||||
T 65 @ [plant in code below]
|
||||
S L [load negative number of items]
|
||||
[61] T @ [use first word of temp store for count]
|
||||
A 65 @ [load 'A' order for item]
|
||||
A 4 @ [inc address by 2]
|
||||
T 65 @ [store back]
|
||||
[65] A #L [load next item in list]
|
||||
T D [to 0D for printing]
|
||||
[67] A 67 @ [for subroutine return]
|
||||
G 56 F [print integer, clears acc]
|
||||
O 13 @ [print CR]
|
||||
O 12 @ [print LF]
|
||||
A @ [negative count]
|
||||
A 10 @ [add 1]
|
||||
G 61 @ [loop back till count = 0]
|
||||
[74] O 9 @ [null to flush teleprinter buffer]
|
||||
Z F [stop]
|
||||
E 14 Z [define entry point]
|
||||
P F [acc = 0 on entry]
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
PROGRAM BUBBLE_SORT
|
||||
|
||||
DIM FLIPS%,N,J
|
||||
|
||||
DIM A%[100]
|
||||
|
||||
BEGIN
|
||||
|
||||
! init random number generator
|
||||
RANDOMIZE(TIMER)
|
||||
! fills array A% with random data
|
||||
FOR N=1 TO UBOUND(A%,1) DO
|
||||
A%[N]=RND(1)*256
|
||||
END FOR
|
||||
! sort array
|
||||
FLIPS%=TRUE
|
||||
WHILE FLIPS% DO
|
||||
FLIPS%=FALSE
|
||||
FOR N=1 TO UBOUND(A%,1)-1 DO
|
||||
IF A%[N]>A%[N+1] THEN
|
||||
SWAP(A%[N],A%[N+1])
|
||||
FLIPS%=TRUE
|
||||
END IF
|
||||
END FOR
|
||||
END WHILE
|
||||
! print sorted array
|
||||
FOR N=1 TO UBOUND(A%,1) DO
|
||||
PRINT(A%[N];)
|
||||
END FOR
|
||||
PRINT
|
||||
END PROGRAM
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
proc bubbleSort . a[] .
|
||||
repeat
|
||||
changed = 0
|
||||
for i = 1 to len a[] - 1
|
||||
if a[i] > a[i + 1]
|
||||
swap a[i] a[i + 1]
|
||||
changed = 1
|
||||
.
|
||||
.
|
||||
until changed = 0
|
||||
.
|
||||
.
|
||||
array[] = [ 5 1 19 25 12 1 14 7 ]
|
||||
call bubbleSort array[]
|
||||
print array[]
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
;; sorts a vector of objects in place
|
||||
;; proc is an user defined comparison procedure
|
||||
|
||||
(define (bubble-sort V proc)
|
||||
(define length (vector-length V))
|
||||
(for* ((i (in-range 0 (1- length))) (j (in-range (1+ i) length)))
|
||||
(unless (proc (vector-ref V i) (vector-ref V j)) (vector-swap! V i j)))
|
||||
V)
|
||||
|
||||
|
||||
(define V #( albert antoinette elvis zen simon))
|
||||
(define (sort/length a b) ;; sort by string length
|
||||
(< (string-length a) (string-length b)))
|
||||
|
||||
(bubble-sort V sort/length)
|
||||
→ #(zen simon elvis albert antoinette)
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
class
|
||||
APPLICATION
|
||||
create
|
||||
make
|
||||
|
||||
feature
|
||||
make
|
||||
-- Create and print sorted set
|
||||
do
|
||||
create my_set.make
|
||||
my_set.put_front (2)
|
||||
my_set.put_front (6)
|
||||
my_set.put_front (1)
|
||||
my_set.put_front (5)
|
||||
my_set.put_front (3)
|
||||
my_set.put_front (9)
|
||||
my_set.put_front (8)
|
||||
my_set.put_front (4)
|
||||
my_set.put_front (10)
|
||||
my_set.put_front (7)
|
||||
print ("Before: ")
|
||||
across my_set as ic loop print (ic.item.out + " ") end
|
||||
print ("%NAfter : ")
|
||||
my_set.sort
|
||||
across my_set as ic loop print (ic.item.out + " ") end
|
||||
end
|
||||
|
||||
my_set: MY_SORTED_SET [INTEGER]
|
||||
-- Set to be sorted
|
||||
end
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
class
|
||||
MY_SORTED_SET [G -> COMPARABLE]
|
||||
inherit
|
||||
TWO_WAY_SORTED_SET [G]
|
||||
redefine
|
||||
sort
|
||||
end
|
||||
create
|
||||
make
|
||||
|
||||
feature
|
||||
sort
|
||||
-- Sort with bubble sort
|
||||
local
|
||||
l_unchanged: BOOLEAN
|
||||
l_item_count: INTEGER
|
||||
l_temp: G
|
||||
do
|
||||
from
|
||||
l_item_count := count
|
||||
until
|
||||
l_unchanged
|
||||
loop
|
||||
l_unchanged := True
|
||||
l_item_count := l_item_count - 1
|
||||
across 1 |..| l_item_count as ic loop
|
||||
if Current [ic.item] > Current [ic.item + 1] then
|
||||
l_temp := Current [ic.item]
|
||||
Current [ic.item] := Current [ic.item + 1]
|
||||
Current [ic.item + 1] := l_temp
|
||||
l_unchanged := False
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
import system'routines;
|
||||
import extensions;
|
||||
|
||||
extension op
|
||||
{
|
||||
bubbleSort()
|
||||
{
|
||||
var list := self.clone();
|
||||
|
||||
bool madeChanges := true;
|
||||
int itemCount := list.Length;
|
||||
while (madeChanges)
|
||||
{
|
||||
madeChanges := false;
|
||||
itemCount -= 1;
|
||||
for(int i := 0, i < itemCount, i += 1)
|
||||
{
|
||||
if (list[i] > list[i + 1])
|
||||
{
|
||||
list.exchange(i,i+1);
|
||||
madeChanges := true
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
^ list
|
||||
}
|
||||
}
|
||||
|
||||
public program()
|
||||
{
|
||||
var list := new int[]{3, 7, 3, 2, 1, -4, 10, 12, 4};
|
||||
console.printLine(list.bubbleSort().asEnumerable())
|
||||
}
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
defmodule Sort do
|
||||
def bsort(list) when is_list(list) do
|
||||
t = bsort_iter(list)
|
||||
|
||||
if t == list, do: t, else: bsort(t)
|
||||
end
|
||||
|
||||
def bsort_iter([x, y | t]) when x > y, do: [y | bsort_iter([x | t])]
|
||||
def bsort_iter([x, y | t]), do: [x | bsort_iter([y | t])]
|
||||
def bsort_iter(list), do: list
|
||||
end
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
-module( bubble_sort ).
|
||||
|
||||
-export( [list/1, task/0] ).
|
||||
|
||||
list( To_be_sorted ) -> sort( To_be_sorted, [], true ).
|
||||
|
||||
task() ->
|
||||
List = "asdqwe123",
|
||||
Sorted = list( List ),
|
||||
io:fwrite( "List ~p is sorted ~p~n", [List, Sorted] ).
|
||||
|
||||
|
||||
sort( [], Acc, true ) -> lists:reverse( Acc );
|
||||
sort( [], Acc, false ) -> sort( lists:reverse(Acc), [], true );
|
||||
sort( [X, Y | T], Acc, _Done ) when X > Y -> sort( [X | T], [Y | Acc], false );
|
||||
sort( [X | T], Acc, Done ) -> sort( T, [X | Acc], Done ).
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
function bubble_sort(sequence s)
|
||||
object tmp
|
||||
integer changed
|
||||
for j = length(s) to 1 by -1 do
|
||||
changed = 0
|
||||
for i = 1 to j-1 do
|
||||
if compare(s[i], s[i+1]) > 0 then
|
||||
tmp = s[i]
|
||||
s[i] = s[i+1]
|
||||
s[i+1] = tmp
|
||||
changed = 1
|
||||
end if
|
||||
end for
|
||||
if not changed then
|
||||
exit
|
||||
end if
|
||||
end for
|
||||
return s
|
||||
end function
|
||||
|
||||
include misc.e
|
||||
constant s = {4, 15, "delta", 2, -31, 0, "alfa", 19, "gamma", 2, 13, "beta", 782, 1}
|
||||
|
||||
puts(1,"Before: ")
|
||||
pretty_print(1,s,{2})
|
||||
puts(1,"\nAfter: ")
|
||||
pretty_print(1,bubble_sort(s),{2})
|
||||
|
|
@ -0,0 +1,65 @@
|
|||
## இந்த நிரல் ஒரு பட்டியலில் உள்ள எண்களை Bubble Sort என்ற முறைப்படி ஏறுவரிசையிலும் பின்னர் அதையே இறங்குவரிசையிலும் அடுக்கித் தரும்
|
||||
|
||||
## மாதிரிக்கு நாம் ஏழு எண்களை எடுத்துக்கொள்வோம்
|
||||
|
||||
எண்கள் = [5, 1, 10, 8, 1, 21, 4, 2]
|
||||
எண்கள்பிரதி = எண்கள்
|
||||
|
||||
பதிப்பி "ஆரம்பப் பட்டியல்:"
|
||||
பதிப்பி எண்கள்
|
||||
|
||||
நீளம் = len(எண்கள்)
|
||||
குறைநீளம் = நீளம் - 1
|
||||
|
||||
@(குறைநீளம் != -1) வரை
|
||||
மாற்றம் = -1
|
||||
@(எண் = 0, எண் < குறைநீளம், எண் = எண் + 1) ஆக
|
||||
முதலெண் = எடு(எண்கள், எண்)
|
||||
இரண்டாமெண் = எடு(எண்கள், எண் + 1)
|
||||
@(முதலெண் > இரண்டாமெண்) ஆனால்
|
||||
|
||||
## பெரிய எண்களை ஒவ்வொன்றாகப் பின்னே நகர்த்துகிறோம்
|
||||
|
||||
வெளியேஎடு(எண்கள், எண்)
|
||||
நுழைக்க(எண்கள், எண், இரண்டாமெண்)
|
||||
வெளியேஎடு(எண்கள், எண் + 1)
|
||||
நுழைக்க(எண்கள், எண் + 1, முதலெண்)
|
||||
மாற்றம் = எண்
|
||||
முடி
|
||||
முடி
|
||||
குறைநீளம் = மாற்றம்
|
||||
முடி
|
||||
|
||||
பதிப்பி "ஏறு வரிசையில் அமைக்கப்பட்ட பட்டியல்:"
|
||||
பதிப்பி எண்கள்
|
||||
|
||||
## இதனை இறங்குவரிசைக்கு மாற்றுவதற்கு எளிய வழி
|
||||
|
||||
தலைகீழ்(எண்கள்)
|
||||
|
||||
## இப்போது, நாம் ஏற்கெனவே எடுத்துவைத்த எண்களின் பிரதியை Bubble Sort முறைப்படி இறங்குவரிசைக்கு மாற்றுவோம்
|
||||
|
||||
நீளம் = len(எண்கள்பிரதி)
|
||||
குறைநீளம் = நீளம் - 1
|
||||
|
||||
@(குறைநீளம் != -1) வரை
|
||||
மாற்றம் = -1
|
||||
@(எண் = 0, எண் < குறைநீளம், எண் = எண் + 1) ஆக
|
||||
முதலெண் = எடு(எண்கள்பிரதி, எண்)
|
||||
இரண்டாமெண் = எடு(எண்கள்பிரதி, எண் + 1)
|
||||
@(முதலெண் < இரண்டாமெண்) ஆனால்
|
||||
|
||||
## சிறிய எண்களை ஒவ்வொன்றாகப் பின்னே நகர்த்துகிறோம்
|
||||
|
||||
வெளியேஎடு(எண்கள்பிரதி, எண்)
|
||||
நுழைக்க(எண்கள்பிரதி, எண், இரண்டாமெண்)
|
||||
வெளியேஎடு(எண்கள்பிரதி, எண் + 1)
|
||||
நுழைக்க(எண்கள்பிரதி, எண் + 1, முதலெண்)
|
||||
மாற்றம் = எண்
|
||||
முடி
|
||||
முடி
|
||||
குறைநீளம் = மாற்றம்
|
||||
முடி
|
||||
|
||||
பதிப்பி "இறங்கு வரிசையில் அமைக்கப்பட்ட பட்டியல்:"
|
||||
பதிப்பி எண்கள்பிரதி
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
let BubbleSort (lst : list<int>) =
|
||||
let rec sort accum rev lst =
|
||||
match lst, rev with
|
||||
| [], true -> accum |> List.rev
|
||||
| [], false -> accum |> List.rev |> sort [] true
|
||||
| x::y::tail, _ when x > y -> sort (y::accum) false (x::tail)
|
||||
| head::tail, _ -> sort (head::accum) rev tail
|
||||
sort [] true lst
|
||||
|
|
@ -0,0 +1,115 @@
|
|||
rem bubble sort benchmark example
|
||||
rem compile with FTCBASIC
|
||||
|
||||
use time.inc
|
||||
use random.inc
|
||||
|
||||
define const size = 32000
|
||||
|
||||
dim list[size]
|
||||
|
||||
define sorting = 0, index = 0, elements = 0
|
||||
define timestamp = 0, sorttime = 0
|
||||
define temp1 = 0, temp2 = 0
|
||||
|
||||
cls
|
||||
|
||||
print "Bubble sort benchmark test"
|
||||
|
||||
do
|
||||
|
||||
print "How many elements to generate and sort (max " \
|
||||
print size \
|
||||
print ")? " \
|
||||
|
||||
input elements
|
||||
|
||||
loop elements > size
|
||||
|
||||
gosub fill
|
||||
gosub sort
|
||||
|
||||
print "done!"
|
||||
print "sort time: " \
|
||||
print sorttime
|
||||
print "Press any key to view sorted data..."
|
||||
|
||||
pause
|
||||
|
||||
gosub output
|
||||
|
||||
pause
|
||||
end
|
||||
|
||||
sub fill
|
||||
|
||||
print "filling..."
|
||||
|
||||
0 index
|
||||
|
||||
do
|
||||
|
||||
gosub generaterand
|
||||
|
||||
let @list[index] = rand
|
||||
|
||||
+1 index
|
||||
|
||||
loop index < elements
|
||||
|
||||
return
|
||||
|
||||
sub sort
|
||||
|
||||
print "sorting..."
|
||||
|
||||
gosub systemtime
|
||||
let timestamp = loworder
|
||||
|
||||
do
|
||||
|
||||
0 sorting
|
||||
|
||||
0 index
|
||||
|
||||
do
|
||||
|
||||
let temp1 = index + 1
|
||||
|
||||
if @list[index] > @list[temp1] then
|
||||
|
||||
let temp2 = @list[index]
|
||||
|
||||
let @list[index] = @list[temp1]
|
||||
let @list[temp1] = temp2
|
||||
|
||||
let sorting = 1
|
||||
|
||||
endif
|
||||
|
||||
+1 index
|
||||
|
||||
loop index < elements - 1
|
||||
|
||||
loop sorting = 1
|
||||
|
||||
gosub systemtime
|
||||
let sorttime = ( loworder - timestamp ) / 18
|
||||
|
||||
return
|
||||
|
||||
sub output
|
||||
|
||||
print "printing..."
|
||||
|
||||
0 index
|
||||
|
||||
do
|
||||
|
||||
print @list[index]
|
||||
|
||||
+1 index
|
||||
|
||||
loop index < elements
|
||||
|
||||
return
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
USING: fry kernel locals math math.order sequences
|
||||
sequences.private ;
|
||||
IN: rosetta.bubble
|
||||
|
||||
<PRIVATE
|
||||
|
||||
:: ?exchange ( i seq quot -- ? )
|
||||
i i 1 + [ seq nth-unsafe ] bi@ quot call +gt+ = :> doit?
|
||||
doit? [ i i 1 + seq exchange ] when
|
||||
doit? ; inline
|
||||
|
||||
: 1pass ( seq quot -- ? )
|
||||
[ [ length 1 - iota ] keep ] dip
|
||||
'[ _ _ ?exchange ] [ or ] map-reduce ; inline
|
||||
|
||||
PRIVATE>
|
||||
|
||||
: sort! ( seq quot -- )
|
||||
over empty?
|
||||
[ 2drop ] [ '[ _ _ 1pass ] loop ] if ; inline
|
||||
|
||||
: natural-sort! ( seq -- )
|
||||
[ <=> ] sort! ;
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
10 [ 10000 random ] replicate
|
||||
[ "Before: " write . ]
|
||||
[ "Natural: " write [ natural-sort! ] keep . ]
|
||||
[ "Reverse: " write [ [ >=< ] sort! ] keep . ] tri
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
v Sorts the (pre-loaded) stack
|
||||
with bubblesort.
|
||||
v <
|
||||
\l0=?;l&
|
||||
>&:1=?v1-&2[$:{:{](?${
|
||||
>~{ao ^
|
||||
>~}l &{ v
|
||||
o","{n:&-1^?=0:&<
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
defer bubble-test
|
||||
' > is bubble-test
|
||||
|
||||
: bubble { addr cnt -- }
|
||||
cnt 1 do
|
||||
addr cnt i - cells bounds do
|
||||
i 2@ bubble-test if i 2@ swap i 2! then
|
||||
cell +loop
|
||||
loop ;
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
: bubble ( addr cnt -- )
|
||||
dup 1 do
|
||||
2dup i - cells bounds do
|
||||
i 2@ bubble-test if i 2@ swap i 2! then
|
||||
cell +loop
|
||||
loop ;
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
: bubble ( addr len -- )
|
||||
begin
|
||||
1- 2dup true -rot ( sorted addr len-1 )
|
||||
cells bounds ?do
|
||||
i 2@ bubble-test if
|
||||
i 2@ swap i 2!
|
||||
drop false ( mark unsorted )
|
||||
then
|
||||
cell +loop ( sorted )
|
||||
until 2drop ;
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
SUBROUTINE Bubble_Sort(a)
|
||||
REAL, INTENT(in out), DIMENSION(:) :: a
|
||||
REAL :: temp
|
||||
INTEGER :: i, j
|
||||
LOGICAL :: swapped
|
||||
|
||||
DO j = SIZE(a)-1, 1, -1
|
||||
swapped = .FALSE.
|
||||
DO i = 1, j
|
||||
IF (a(i) > a(i+1)) THEN
|
||||
temp = a(i)
|
||||
a(i) = a(i+1)
|
||||
a(i+1) = temp
|
||||
swapped = .TRUE.
|
||||
END IF
|
||||
END DO
|
||||
IF (.NOT. swapped) EXIT
|
||||
END DO
|
||||
END SUBROUTINE Bubble_Sort
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
' version 21-10-2016
|
||||
' compile with: fbc -s console
|
||||
' for boundry checks on array's compile with: fbc -s console -exx
|
||||
|
||||
Sub bubblesort(bs() As Long)
|
||||
' sort from lower bound to the highter bound
|
||||
' array's can have subscript range from -2147483648 to +2147483647
|
||||
Dim As Long lb = LBound(bs)
|
||||
Dim As Long ub = UBound(bs)
|
||||
Dim As Long done, i
|
||||
|
||||
Do
|
||||
done = 0
|
||||
For i = lb To ub -1
|
||||
' replace "<" with ">" for downwards sort
|
||||
If bs(i) > bs(i +1) Then
|
||||
Swap bs(i), bs(i +1)
|
||||
done = 1
|
||||
End If
|
||||
Next
|
||||
Loop Until done = 0
|
||||
|
||||
End Sub
|
||||
|
||||
' ------=< MAIN >=------
|
||||
|
||||
Dim As Long i, array(-7 To 7)
|
||||
|
||||
Dim As Long a = LBound(array), b = UBound(array)
|
||||
|
||||
Randomize Timer
|
||||
For i = a To b : array(i) = i : Next
|
||||
For i = a To b ' little shuffle
|
||||
Swap array(i), array(Int(Rnd * (b - a +1)) + a)
|
||||
Next
|
||||
|
||||
Print "unsort ";
|
||||
For i = a To b : Print Using "####"; array(i); : Next : Print
|
||||
bubblesort(array()) ' sort the array
|
||||
Print " sort ";
|
||||
For i = a To b : Print Using "####"; array(i); : Next : Print
|
||||
|
||||
' empty keyboard buffer
|
||||
While InKey <> "" : Wend
|
||||
Print : Print "hit any key to end program"
|
||||
Sleep
|
||||
End
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
include "NSLog.incl"
|
||||
|
||||
local fn BubbleSort( array as CFMutableArrayRef ) as CFArrayRef
|
||||
NSUInteger i, x, y, count = len(array)
|
||||
BOOL swapped = YES
|
||||
|
||||
while (swapped)
|
||||
swapped = NO
|
||||
for i = 1 to count -1
|
||||
x = fn NumberIntegerValue( array[i-1] )
|
||||
y = fn NumberIntegerValue( array[i] )
|
||||
if ( x > y )
|
||||
MutableArrayExchangeObjects( array, (i-1), i )
|
||||
swapped = YES
|
||||
end if
|
||||
next
|
||||
wend
|
||||
end fn = array
|
||||
|
||||
CFMutableArrayRef array
|
||||
CFArrayRef unsortedArray, sortedArray
|
||||
NSUInteger i
|
||||
|
||||
array = fn MutableArrayWithCapacity(0)
|
||||
for i = 0 to 20
|
||||
MutableArrayAddObject( array, fn NumberWithInteger( rnd(100) ) )
|
||||
next
|
||||
|
||||
unsortedArray = fn ArrayWithArray( array )
|
||||
sortedArray = fn BubbleSort( array )
|
||||
|
||||
NSLog( @"\n-----------------\nUnsorted : Sorted\n-----------------" )
|
||||
for i = 0 to 20
|
||||
NSLog( @"%8ld : %-8ld", fn NumberIntegerValue( unsortedArray[i] ), fn NumberIntegerValue( sortedArray[i] ) )
|
||||
next
|
||||
|
||||
randomize
|
||||
|
||||
HandleEvents
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
(fun bubbles (vs)
|
||||
(let done? F n (len vs))
|
||||
|
||||
(while (not done?)
|
||||
(set done? T n (- n 1))
|
||||
|
||||
(for (n i)
|
||||
(let x (# vs i) j (+ i 1) y (# vs j))
|
||||
(if (> x y) (set done? F (# vs i) y (# vs j) x))))
|
||||
|
||||
vs)
|
||||
|
||||
(bubbles '(2 1 3))
|
||||
---
|
||||
(1 2 3)
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
10 REM GENERATE A RANDOM BUNCH OF INTEGERS
|
||||
20 DIM ARR(20)
|
||||
30 RANDOMIZE TIMER
|
||||
40 FOR I=0 TO 19
|
||||
50 ARR(I)=INT(RND*100)
|
||||
60 NEXT I
|
||||
70 REM bubble sort the list, printing it at the end of every pass
|
||||
80 MX = 19
|
||||
90 CHANGED = 0
|
||||
100 FOR I = 0 TO 19
|
||||
110 PRINT ARR(I);
|
||||
120 NEXT I
|
||||
130 PRINT
|
||||
140 FOR I = 0 TO MX-1
|
||||
150 IF ARR(I)>ARR(I+1) THEN GOSUB 1000
|
||||
160 NEXT I
|
||||
170 MX = MX - 1
|
||||
180 IF CHANGED*MX = 0 THEN END
|
||||
190 GOTO 90
|
||||
1000 TEMP = ARR(I)
|
||||
1010 ARR(I) = ARR(I+1)
|
||||
1020 ARR(I+1) = TEMP
|
||||
1030 CHANGED = 1
|
||||
1040 RETURN
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
Public Sub Main()
|
||||
Dim byToSort As Byte[] = [249, 28, 111, 36, 171, 98, 29, 448, 44, 147, 154, 46, 102, 183, 24,
|
||||
120, 19, 123, 2, 17, 226, 11, 211, 25, 191, 205, 77]
|
||||
Dim byCount As Byte
|
||||
Dim bSorting As Boolean
|
||||
|
||||
Print "To sort: -"
|
||||
ShowWorking(byToSort)
|
||||
Print
|
||||
Repeat
|
||||
bSorting = False
|
||||
For byCount = 0 To byToSort.Max - 1
|
||||
If byToSort[byCount] > byToSort[byCount + 1] Then
|
||||
Swap byToSort[byCount], byToSort[byCount + 1]
|
||||
bSorting = True
|
||||
Endif
|
||||
Next
|
||||
If bSorting Then ShowWorking(byToSort)
|
||||
Until bSorting = False
|
||||
End
|
||||
'-----------------------------------------
|
||||
Public Sub ShowWorking(byToSort As Byte[])
|
||||
Dim byCount As Byte
|
||||
|
||||
For byCount = 0 To byToSort.Max
|
||||
Print Str(byToSort[byCount]);
|
||||
If byCount <> byToSort.Max Then Print ",";
|
||||
Next
|
||||
|
||||
Print
|
||||
|
||||
End
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
package main
|
||||
|
||||
import "fmt"
|
||||
|
||||
func main() {
|
||||
list := []int{31, 41, 59, 26, 53, 58, 97, 93, 23, 84}
|
||||
fmt.Println("unsorted:", list)
|
||||
|
||||
bubblesort(list)
|
||||
fmt.Println("sorted! ", list)
|
||||
}
|
||||
|
||||
func bubblesort(a []int) {
|
||||
for itemCount := len(a) - 1; ; itemCount-- {
|
||||
hasChanged := false
|
||||
for index := 0; index < itemCount; index++ {
|
||||
if a[index] > a[index+1] {
|
||||
a[index], a[index+1] = a[index+1], a[index]
|
||||
hasChanged = true
|
||||
}
|
||||
}
|
||||
if hasChanged == false {
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"sort"
|
||||
"fmt"
|
||||
)
|
||||
|
||||
func main() {
|
||||
list := []int{31, 41, 59, 26, 53, 58, 97, 93, 23, 84}
|
||||
fmt.Println("unsorted:", list)
|
||||
|
||||
bubblesort(sort.IntSlice(list))
|
||||
fmt.Println("sorted! ", list)
|
||||
}
|
||||
|
||||
func bubblesort(a sort.Interface) {
|
||||
for itemCount := a.Len() - 1; ; itemCount-- {
|
||||
hasChanged := false
|
||||
for index := 0; index < itemCount; index++ {
|
||||
if a.Less(index+1, index) {
|
||||
a.Swap(index, index+1)
|
||||
hasChanged = true
|
||||
}
|
||||
}
|
||||
if !hasChanged {
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
def makeSwap = { a, i, j = i+1 -> print "."; a[[i,j]] = a[[j,i]] }
|
||||
|
||||
def checkSwap = { a, i, j = i+1 -> [(a[i] > a[j])].find { it }.each { makeSwap(a, i, j) } }
|
||||
|
||||
def bubbleSort = { list ->
|
||||
boolean swapped = true
|
||||
while (swapped) { swapped = (1..<list.size()).any { checkSwap(list, it-1) } }
|
||||
list
|
||||
}
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
println bubbleSort([23,76,99,58,97,57,35,89,51,38,95,92,24,46,31,24,14,12,57,78,4])
|
||||
println bubbleSort([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,7 @@
|
|||
bsort :: Ord a => [a] -> [a]
|
||||
bsort s = case _bsort s of
|
||||
t | t == s -> t
|
||||
| otherwise -> bsort t
|
||||
where _bsort (x:x2:xs) | x > x2 = x2:(_bsort (x:xs))
|
||||
| otherwise = x:(_bsort (x2:xs))
|
||||
_bsort s = s
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
import Data.Maybe (fromMaybe)
|
||||
import Control.Monad
|
||||
|
||||
bsort :: Ord a => [a] -> [a]
|
||||
bsort s = maybe s bsort $ _bsort s
|
||||
where _bsort (x:x2:xs) = if x > x2
|
||||
then Just $ x2 : fromMaybe (x:xs) (_bsort $ x:xs)
|
||||
else liftM (x:) $ _bsort (x2:xs)
|
||||
_bsort _ = Nothing
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
import Data.Maybe (fromMaybe)
|
||||
import Control.Monad
|
||||
|
||||
bubbleSortBy :: (a -> a -> Bool) -> [a] -> [a]
|
||||
bubbleSortBy f as = case innerSort $ reverse as of
|
||||
Nothing -> as
|
||||
Just v -> let (x:xs) = reverse v
|
||||
in x : bubbleSortBy f xs
|
||||
where innerSort (a:b:cs) = if b `f` a
|
||||
then liftM (a:) $ innerSort (b:cs)
|
||||
else Just $ b : fromMaybe (a:cs)
|
||||
(innerSort $ a:cs)
|
||||
innerSort _ = Nothing
|
||||
|
||||
bsort :: Ord a => [a] -> [a]
|
||||
bsort = bubbleSortBy (<)
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
class BubbleSort {
|
||||
@:generic
|
||||
public static function sort<T>(arr:Array<T>) {
|
||||
var madeChanges = false;
|
||||
var itemCount = arr.length;
|
||||
do {
|
||||
madeChanges = false;
|
||||
itemCount--;
|
||||
for (i in 0...itemCount) {
|
||||
if (Reflect.compare(arr[i], arr[i + 1]) > 0) {
|
||||
var temp = arr[i + 1];
|
||||
arr[i + 1] = arr[i];
|
||||
arr[i] = temp;
|
||||
madeChanges = true;
|
||||
}
|
||||
}
|
||||
} while (madeChanges);
|
||||
}
|
||||
}
|
||||
|
||||
class Main {
|
||||
static function main() {
|
||||
var integerArray = [1, 10, 2, 5, -1, 5, -19, 4, 23, 0];
|
||||
var floatArray = [1.0, -3.2, 5.2, 10.8, -5.7, 7.3,
|
||||
3.5, 0.0, -4.1, -9.5];
|
||||
var stringArray = ['We', 'hold', 'these', 'truths', 'to',
|
||||
'be', 'self-evident', 'that', 'all',
|
||||
'men', 'are', 'created', 'equal'];
|
||||
Sys.println('Unsorted Integers: ' + integerArray);
|
||||
BubbleSort.sort(integerArray);
|
||||
Sys.println('Sorted Integers: ' + integerArray);
|
||||
Sys.println('Unsorted Floats: ' + floatArray);
|
||||
BubbleSort.sort(floatArray);
|
||||
Sys.println('Sorted Floats: ' + floatArray);
|
||||
Sys.println('Unsorted Strings: ' + stringArray);
|
||||
BubbleSort.sort(stringArray);
|
||||
Sys.println('Sorted Strings: ' + stringArray);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
SUBROUTINE Bubble_Sort(a)
|
||||
REAL :: a(1)
|
||||
|
||||
DO j = LEN(a)-1, 1, -1
|
||||
swapped = 0
|
||||
DO i = 1, j
|
||||
IF (a(i) > a(i+1)) THEN
|
||||
temp = a(i)
|
||||
a(i) = a(i+1)
|
||||
a(i+1) = temp
|
||||
swapped = 1
|
||||
ENDIF
|
||||
ENDDO
|
||||
IF (swapped == 0) RETURN
|
||||
ENDDO
|
||||
END
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
100 PROGRAM "BubblSrt.bas"
|
||||
110 RANDOMIZE
|
||||
120 NUMERIC ARRAY(-5 TO 9)
|
||||
130 CALL INIT(ARRAY)
|
||||
140 CALL WRITE(ARRAY)
|
||||
150 CALL BUBBLESORT(ARRAY)
|
||||
160 CALL WRITE(ARRAY)
|
||||
170 DEF INIT(REF A)
|
||||
180 FOR I=LBOUND(A) TO UBOUND(A)
|
||||
190 LET A(I)=RND(98)+1
|
||||
200 NEXT
|
||||
210 END DEF
|
||||
220 DEF WRITE(REF A)
|
||||
230 FOR I=LBOUND(A) TO UBOUND(A)
|
||||
240 PRINT A(I);
|
||||
250 NEXT
|
||||
260 PRINT
|
||||
270 END DEF
|
||||
280 DEF BUBBLESORT(REF A)
|
||||
290 DO
|
||||
300 LET CH=0
|
||||
310 FOR I=LBOUND(A) TO UBOUND(A)-1
|
||||
320 IF A(I)>A(I+1) THEN LET T=A(I):LET A(I)=A(I+1):LET A(I+1)=T:LET CH=1
|
||||
330 NEXT
|
||||
340 LOOP WHILE CH
|
||||
350 END DEF
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
procedure main() #: demonstrate various ways to sort a list and string
|
||||
demosort(bubblesort,[3, 14, 1, 5, 9, 2, 6, 3],"qwerty")
|
||||
end
|
||||
|
||||
procedure bubblesort(X,op) #: return sorted list
|
||||
local i,swapped
|
||||
|
||||
op := sortop(op,X) # select how and what we sort
|
||||
|
||||
swapped := 1
|
||||
while \swapped := &null do # the sort
|
||||
every i := 2 to *X do
|
||||
if op(X[i],X[i-1]) then
|
||||
X[i-1] :=: X[swapped := i]
|
||||
return X
|
||||
end
|
||||
|
|
@ -0,0 +1,59 @@
|
|||
invocable all # for op
|
||||
|
||||
procedure sortop(op,X) #: select how to sort
|
||||
|
||||
op := case op of {
|
||||
"string": "<<"
|
||||
"numeric": "<"
|
||||
&null: if type(!X) == "string" then "<<" else "<"
|
||||
default: op
|
||||
}
|
||||
return proc(op, 2) | runerr(123, image(op))
|
||||
end
|
||||
|
||||
procedure cmp(a,b) #: example custom comparison procedure
|
||||
return a < b # Imagine a complex comparison test here!
|
||||
end
|
||||
|
||||
procedure demosort(sortproc,L,s) # demonstrate sort on L and s
|
||||
|
||||
write("Sorting Demo using ",image(sortproc))
|
||||
writes(" on list : ")
|
||||
writex(L)
|
||||
displaysort(sortproc,L) # default string sort
|
||||
displaysort(sortproc,L,"numeric") # explicit numeric sort
|
||||
displaysort(sortproc,L,"string") # explicit string sort
|
||||
displaysort(sortproc,L,">>") # descending string sort
|
||||
displaysort(sortproc,L,">") # descending numeric sort
|
||||
displaysort(sortproc,L,cmp) # ascending custom comparison
|
||||
displaysort(sortproc,L,"cmp") # ascending custom comparison
|
||||
|
||||
writes(" on string : ")
|
||||
writex(s)
|
||||
displaysort(sortproc,s) # sort characters in a string
|
||||
write()
|
||||
return
|
||||
end
|
||||
|
||||
procedure displaysort(sortproc,X,op) #: helper to show sort behavior
|
||||
local t,SX
|
||||
writes(" with op = ",left(image(op)||":",15))
|
||||
X := copy(X)
|
||||
t := &time
|
||||
SX := sortproc(X,op)
|
||||
writex(SX," (",&time - t," ms)")
|
||||
return
|
||||
end
|
||||
|
||||
procedure writex(X,suf[]) #: helper for displaysort
|
||||
if type(X) == "string" then
|
||||
writes(image(X))
|
||||
else {
|
||||
writes("[")
|
||||
every writes(" ",image(!X))
|
||||
writes(" ]")
|
||||
}
|
||||
every writes(!suf)
|
||||
write()
|
||||
return
|
||||
end
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
List do(
|
||||
bubblesort := method(
|
||||
t := true
|
||||
while( t,
|
||||
t := false
|
||||
for( j, 0, self size - 2,
|
||||
if( self at( j ) start > self at( j+1 ) start,
|
||||
self swapIndices( j,j+1 )
|
||||
t := true
|
||||
)
|
||||
)
|
||||
)
|
||||
return( self )
|
||||
)
|
||||
)
|
||||
|
|
@ -0,0 +1 @@
|
|||
bubbleSort=: (([ (<. , >.) {.@]) , }.@])/^:_
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
?. 10 $ 10
|
||||
4 6 8 6 5 8 6 6 6 9
|
||||
bubbleSort ?. 10 $ 10
|
||||
4 5 6 6 6 6 6 8 8 9
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
fn bubble_sort<T>(anon mut array: [T]) {
|
||||
mut item_count = array.size()
|
||||
mut has_changed = true
|
||||
while item_count > 1 and has_changed {
|
||||
has_changed = true
|
||||
item_count--
|
||||
for i in 0..item_count {
|
||||
if array[i] > array[i + 1] {
|
||||
let temp = array[i]
|
||||
array[i] = array[i + 1]
|
||||
array[i + 1] = temp
|
||||
has_changed = true
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
fn main() {
|
||||
mut array = [7, 8, 9, 6, 5, 3, 1, 10, 4, 2]
|
||||
println("{}", array)
|
||||
bubble_sort(array)
|
||||
println("{}", array)
|
||||
}
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
(defn bubble-sort!
|
||||
[arr]
|
||||
(def arr-len (length arr))
|
||||
(when (< arr-len 2)
|
||||
(break arr))
|
||||
# at this point there are two or more elements
|
||||
(loop [i :down-to [(dec arr-len) 0]]
|
||||
(for j 0 i
|
||||
(def left-elt (get arr j))
|
||||
(def right-elt (get arr (inc j)))
|
||||
(when (> left-elt right-elt)
|
||||
(put arr j right-elt)
|
||||
(put arr (inc j) left-elt))))
|
||||
arr)
|
||||
|
||||
(comment
|
||||
|
||||
(let [n 100
|
||||
arr (seq [i :range [0 n]]
|
||||
(* n (math/random)))]
|
||||
(deep= (bubble-sort! (array ;arr))
|
||||
(sort (array ;arr))))
|
||||
# => true
|
||||
|
||||
)
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
public static <E extends Comparable<? super E>> void bubbleSort(E[] comparable) {
|
||||
boolean changed = false;
|
||||
do {
|
||||
changed = false;
|
||||
for (int a = 0; a < comparable.length - 1; a++) {
|
||||
if (comparable[a].compareTo(comparable[a + 1]) > 0) {
|
||||
E tmp = comparable[a];
|
||||
comparable[a] = comparable[a + 1];
|
||||
comparable[a + 1] = tmp;
|
||||
changed = true;
|
||||
}
|
||||
}
|
||||
} while (changed);
|
||||
}
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
if (comparable[a].compareTo(comparable[b]) < 0){
|
||||
//same swap code as before
|
||||
}
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
Array.prototype.bubblesort = function() {
|
||||
var done = false;
|
||||
while (!done) {
|
||||
done = true;
|
||||
for (var i = 1; i<this.length; i++) {
|
||||
if (this[i-1] > this[i]) {
|
||||
done = false;
|
||||
[this[i-1], this[i]] = [this[i], this[i-1]]
|
||||
}
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
Array.prototype.bubblesort = function() {
|
||||
var done = false;
|
||||
while (! done) {
|
||||
done = true;
|
||||
for (var i = 1; i < this.length; i++) {
|
||||
if (this[i - 1] > this[i]) {
|
||||
done = false;
|
||||
var tmp = this[i - 1];
|
||||
this[i - 1] = this[i];
|
||||
this[i] = tmp;
|
||||
}
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
var my_arr = ["G", "F", "C", "A", "B", "E", "D"];
|
||||
my_arr.bubblesort();
|
||||
print(my_arr);
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
<script>
|
||||
Array.prototype.bubblesort = function() {
|
||||
var done = false;
|
||||
while (!done) {
|
||||
done = true;
|
||||
for (var i = 1; i<this.length; i++) {
|
||||
if (this[i-1] > this[i]) {
|
||||
done = false;
|
||||
[this[i-1], this[i]] = [this[i], this[i-1]]
|
||||
}
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
var my_arr = ["G", "F", "C", "A", "B", "E", "D"];
|
||||
my_arr.bubblesort();
|
||||
output='';
|
||||
for (var i = 0; i < my_arr.length; i++) {
|
||||
output+=my_arr[i];
|
||||
if (i < my_arr.length-1) output+=',';
|
||||
}
|
||||
document.write(output);
|
||||
</script>
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
def bubble_sort:
|
||||
def swap(i;j): .[i] as $x | .[i]=.[j] | .[j]=$x;
|
||||
|
||||
# input/output: [changed, list]
|
||||
reduce range(0; length) as $i
|
||||
( [false, .];
|
||||
if $i > 0 and (.[0]|not) then .
|
||||
else reduce range(0; (.[1]|length) - $i - 1) as $j
|
||||
(.[0] = false;
|
||||
.[1] as $list
|
||||
| if $list[$j] > $list[$j + 1] then [true, ($list|swap($j; $j+1))]
|
||||
else .
|
||||
end )
|
||||
end ) | .[1] ;
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
(
|
||||
[3,2,1],
|
||||
[1,2,3],
|
||||
["G", "F", "C", "A", "B", "E", "D"]
|
||||
) | bubble_sort
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
$ jq -c -n -f Bubble_sort.jq
|
||||
[1,2,3]
|
||||
[1,2,3]
|
||||
["A","B","C","D","E","F","G"]
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
function bubblesort!(arr::AbstractVector)
|
||||
for _ in 2:length(arr), j in 1:length(arr)-1
|
||||
if arr[j] > arr[j+1]
|
||||
arr[j], arr[j+1] = arr[j+1], arr[j]
|
||||
end
|
||||
end
|
||||
return arr
|
||||
end
|
||||
|
||||
v = rand(-10:10, 10)
|
||||
println("# unordered: $v\n -> ordered: ", bubblesort!(v))
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
import java.util.Comparator
|
||||
|
||||
fun <T> bubbleSort(a: Array<T>, c: Comparator<T>) {
|
||||
var changed: Boolean
|
||||
do {
|
||||
changed = false
|
||||
for (i in 0..a.size - 2) {
|
||||
if (c.compare(a[i], a[i + 1]) > 0) {
|
||||
val tmp = a[i]
|
||||
a[i] = a[i + 1]
|
||||
a[i + 1] = tmp
|
||||
changed = true
|
||||
}
|
||||
}
|
||||
} while (changed)
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Add a link
Reference in a new issue