Sorting algorithms/Bubble sort: Difference between revisions
m
→{{header|Standard ML}}: fix syntax highlighting
(Sorting algorithms/Bubble sort in True BASIC) |
m (→{{header|Standard ML}}: fix syntax highlighting) |
||
| (15 intermediate revisions by 11 users not shown) | |||
Line 1,243:
-31 0 1 2 2 4 65 83 99 782
</pre>
==={{header|Chipmunk Basic}}===
The [[#Commodore_BASIC|Commodore BASIC]] solution works without any changes.
==={{header|Commodore BASIC}}===
Line 1,301 ⟶ 1,304:
dim list[size]
gosub fill
gosub sort
gosub show
end
sub fill
let list[index] = int(rnd * 100)
next index
return
sub sort
do
let
for index = 0 to size - 2
let temp1 = index + 1
let temp2 = list[index]
let list[index] = list[temp1]
let list[temp1] = temp2
let sort = 1
endif
loop sort = 1
return
sub show
next index
return</syntaxhighlight>
==={{header|FreeBASIC}}===
Line 1,803 ⟶ 1,811:
==={{header|Minimal BASIC}}===
{{trans|QuickBASIC}}
{{works with|Bywater BASIC|2.61}}
<syntaxhighlight lang="basic">
100 REM Sorting algorithms/Bubble sort
Line 1,894 ⟶ 1,903:
NEXT I
PRINT
END</syntaxhighlight>
{{out}} (2 samples)
<pre>Before: 91 97 3 62 17 48 89 7 2 66
After: 21 22 27 44 45 54 60 64 84 93</pre>
==={{header|Quite BASIC}}===
<syntaxhighlight lang="qbasic">100 rem Sorting algorithms/Bubble sort
110 LET n = 10
120 array a
130 GOSUB 310
140 PRINT "unsort ";
150 GOSUB 360
160 rem Sort the array
170 GOSUB 210
180 PRINT " sort ";
190 GOSUB 360
200 END
210 rem Bubble sort the list A of length N
220 FOR i = 1 TO n-1
230 FOR j = 1 TO n-i
240 IF a[j] <= a[j+1] THEN GOTO 280
250 LET x = a[j]
260 LET a[j] = a[j+1]
270 LET a[j+1] = x
280 NEXT j
290 NEXT i
300 RETURN
310 rem Create a RANDOM list of N integers
320 FOR i = 1 TO n
330 LET a[i] = FLOOR(RAND(100))
340 NEXT i
350 RETURN
360 rem Print the list a
370 FOR i = 1 TO n
380 PRINT a[i];" ";
390 NEXT i
400 PRINT
410 RETURN</syntaxhighlight>
{{out}}
<pre>unsort 19 78 39 54 63 68 66 52 94 2
sort 2 19 39 52 54 63 66 68 78 94 </pre>
==={{header|RapidQ}}===
Line 1,942 ⟶ 1,983:
NEXT I
PRINT
END</syntaxhighlight>
{{out}} (2 samples)
<pre>Before: 82 34 57 44 48 71 19 33 73 62
After: 4 9 10 15 21 24 27 80 93 96</pre>
==={{header|REALbasic}}===
Line 2,412 ⟶ 2,448:
{{out}}
<pre>1 2 3 4 5 6 7 8 9 10</pre>
=={{header|Befunge}}==
<syntaxhighlight lang="befunge">
000p&: v >20g:7g\1+7g2v
v00p7g00 _10p0>20p20g:7g\1+7g`|0p7+1g02p7g0<
>g1+00p&:^ |-\g00:+1g02 <
0 >$10gv
|-\g00:+1 <
>1->:7g\:#v_$>:#._25*,@
^ <
</syntaxhighlight>
=={{header|C}}==
Line 3,171 ⟶ 3,219:
=={{header|EasyLang}}==
<syntaxhighlight lang="easylang">
repeat
swap a[i] a[i + 1]
.
.
until
.
.
array[] = [ 5 1 19 25 12 1 14 7 ]
print array[]
</syntaxhighlight>
Line 3,484 ⟶ 3,525:
=={{header|Elena}}==
{{trans|C#}}
ELENA
<syntaxhighlight lang="elena">import system'routines;
import extensions;
Line 3,500 ⟶ 3,541:
madeChanges := false;
itemCount -= 1;
for(int i := 0
{
if (list[i] > list[i + 1])
Line 3,877 ⟶ 3,918:
(1 2 3)
</syntaxhighlight>
=={{header|GDScript}}==
Here is an implementation of Bubble Sort algorithm in GDScript for array of primitive types:
<syntaxhighlight lang="gdscript">
extends Node2D
func BubbleSort(_array : Array) -> void:
for i in range(_array.size() - 1):
var swapped : bool = false
for j in range(_array.size() - i - 1):
if _array[j] > _array[j + 1]:
var tmp = _array[j]
_array[j] = _array[j + 1]
_array[j + 1] = tmp
swapped = true
if not swapped:
break
return
func _ready() -> void:
var array : Array = range(-10, 10)
array.shuffle()
print("Initial array:")
print(array)
BubbleSort(array)
print("Sorted array:")
print(array)
return
</syntaxhighlight>
Possible output:
{{out}}
<pre>
Initial array:
[-7, -6, 2, -8, 4, -1, -3, -5, 5, -10, -4, 7, 3, 8, 0, -9, 6, 9, -2, 1]
Sorted array:
[-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</pre>
If you need to sort objects, this can be done in way like this:
<syntaxhighlight lang="gdscript">
class Comparable:
var Value
func _init(_val):
self.Value = _val
func compare(_other : Comparable) -> int:
# Here is the simple implementation of compare
# for primitive type wrapper.
return self.Value - _other.Value
func BubbleSortObjects(_array : Array) -> void:
for i in range(_array.size() - 1):
var swapped : bool = false
for j in range(_array.size() - i - 1):
if _array[j].compare(_array[j + 1]) > 0:
var tmp = _array[j]
_array[j] = _array[j + 1]
_array[j + 1] = tmp
swapped = true
if not swapped:
break
return
</syntaxhighlight>
This approach is slow though. To sort array of primitive types use Array.sort() method instead.
To sort array of objects you can use Array.sort_custom(func : Callable) method.
=={{header|Go}}==
Line 4,196 ⟶ 4,312:
For the most part, bubble sort works against J's strengths. However, once a single pass has been implemented as a list operation, <code>^:_</code> tells J to repeat this until the result stops changing.
=={{header|Jakt}}==
<syntaxhighlight lang="jakt">
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)
}
</syntaxhighlight>
=={{header|Janet}}==
Line 4,684 ⟶ 4,828:
1 2 3 4 5 6 7 8 9</pre>
=={{header|Maxima}}==
<syntaxhighlight lang="maxima">
bubble_sort(u) := block(
[n: length(u), swapped: true, temp],
while swapped do (
swapped: false,
for i: 1 thru n - 1 do (
if u[i] > u[i + 1] then (
temp: u[i],
u[i]: u[i + 1],
u[i + 1]: temp,
swapped: true
)
)
),
u
);
/* Example */
/* sample:[3,65,6,24,24,89,2,59,6]$
bubble_sort(%);
[2,3,6,6,24,24,59,65,89]
*/
</syntaxhighlight>
=={{header|MAXScript}}==
Line 6,511 ⟶ 6,679:
end
</syntaxhighlight>
=={{header|RPL}}==
The bubble algorithm is slow by construction, but since its RPL implementation uses basic stack handling, it is actually quicker than algorithms that work directly on the array.
{{works with|Halcyon Calc|4.2.7}}
≪ '''IF''' DUP SIZE 2 ≥ '''THEN'''
LIST→ → len
≪ len 1 '''FOR''' n
1 n 1 - '''START'''
'''IF''' DUP2 > '''THEN''' SWAP '''END'''
n ROLLD
'''NEXT'''
n ROLLD
-1 '''STEP'''
len →LIST
≫
'''END''' ≫
=={{header|Ruby}}==
Line 7,274 ⟶ 7,458:
=={{header|Standard ML}}==
Assumes a list of integers.
<syntaxhighlight lang="sml">
fun bubble_select [] = []
| bubble_select [a] = [a]
Line 7,282 ⟶ 7,466:
fun bubblesort [] = []
| bubblesort (x::xs) =bubble_select (x::(bubblesort xs))
</syntaxhighlight>
=={{header|Stata}}==
Line 7,594 ⟶ 7,778:
=={{header|Wren}}==
Based on the pseudo-code in the Wikipedia article.
<syntaxhighlight lang="
var n = a.count
if (n < 2) return
Line 7,611 ⟶ 7,795:
}
var
for (a in
System.print("Before: %(a)")
bubbleSort.call(a)
| |||