有没有一种方法可以在 Ruby 中使用带有 any 方法的 while 循环来执行冒泡排序算法?
Is there a way to do Bubble Sort algorithm in Ruby using a while loop with an any method?
我正在尝试使用带有 any 可枚举的 while 循环来优化冒泡排序算法,但无法找到使其工作的方法。现在,我遇到了一个错误,但我想知道我在概念上是否走在正确的轨道上?
我附上了一些示例,代码应该 return 以获得更好的上下文。
def bubble_sort(arr)
while arr.any? { |ele, idx| ele > arr[idx + 1] }
if arr[idx] > arr[idx + 1]
arr[idx], arr[idx + 1] = arr[idx + 1], arr[idx]
end
end
return arr
end
p bubble_sort([2, 8, 5, 2, 6]) # => [2, 2, 5, 6, 8]
p bubble_sort([10, 8, 7, 1, 2, 3]) # => [1, 2, 3, 7, 8, 10]
def bubble_sort(arr)
sorted = false
while !sorted
did_a_swap = false
arr.each_index do |idx|
next unless arr[idx + 1]
if arr[idx] > arr[idx + 1]
did_a_swap = true
arr[idx], arr[idx + 1] = arr[idx + 1], arr[idx]
end
end
sorted = !did_a_swap
end
return arr
end
p bubble_sort([2, 8, 5, 2, 6]) # => [2, 2, 5, 6, 8]
p bubble_sort([10, 8, 7, 1, 2, 3]) # => [1, 2, 3, 7, 8, 10]
如果您接受每次至少有一个未排序的对时都对数组进行完整遍历,那么您可以使用 while !sorted
并将 sorted
定义为 这个 运行 是零掉期吗?
def bubble_sort(arr)
length = arr.length
(0..length-2).each do |i|
(0..(length-i-2)).each do |j|
if arr[j] > arr[j+1]
arr[j+1], arr[j] = arr[j], arr[j+1]
end
end
end
arr
end
def bubble_sort(array)
array_length = array.length
return array if array_length <= 1
unsorted_until_index = array_length - 1
sorted = false
until sorted
sorted = true
for i in (0..unsorted_until_index)
if array[i+1]
if array[i] > array[i+1]
array[i], array[i+1] = array[i+1], array[i]
sorted = false
end
end
end
unsorted_until_index -= 1
end
return array
end
我看到很多答案,每个人都在 while 循环中迭代或循环数组的长度。冒泡排序之所以称为冒泡排序,是因为在每次传递中,最高的未排序值“冒泡”到其正确位置。这样就可以在即将到来的 while 循环中省略这些元素。而不是直到,可以使用 while !sorted
。
我正在尝试使用带有 any 可枚举的 while 循环来优化冒泡排序算法,但无法找到使其工作的方法。现在,我遇到了一个错误,但我想知道我在概念上是否走在正确的轨道上?
我附上了一些示例,代码应该 return 以获得更好的上下文。
def bubble_sort(arr)
while arr.any? { |ele, idx| ele > arr[idx + 1] }
if arr[idx] > arr[idx + 1]
arr[idx], arr[idx + 1] = arr[idx + 1], arr[idx]
end
end
return arr
end
p bubble_sort([2, 8, 5, 2, 6]) # => [2, 2, 5, 6, 8]
p bubble_sort([10, 8, 7, 1, 2, 3]) # => [1, 2, 3, 7, 8, 10]
def bubble_sort(arr)
sorted = false
while !sorted
did_a_swap = false
arr.each_index do |idx|
next unless arr[idx + 1]
if arr[idx] > arr[idx + 1]
did_a_swap = true
arr[idx], arr[idx + 1] = arr[idx + 1], arr[idx]
end
end
sorted = !did_a_swap
end
return arr
end
p bubble_sort([2, 8, 5, 2, 6]) # => [2, 2, 5, 6, 8]
p bubble_sort([10, 8, 7, 1, 2, 3]) # => [1, 2, 3, 7, 8, 10]
如果您接受每次至少有一个未排序的对时都对数组进行完整遍历,那么您可以使用 while !sorted
并将 sorted
定义为 这个 运行 是零掉期吗?
def bubble_sort(arr)
length = arr.length
(0..length-2).each do |i|
(0..(length-i-2)).each do |j|
if arr[j] > arr[j+1]
arr[j+1], arr[j] = arr[j], arr[j+1]
end
end
end
arr
end
def bubble_sort(array)
array_length = array.length
return array if array_length <= 1
unsorted_until_index = array_length - 1
sorted = false
until sorted
sorted = true
for i in (0..unsorted_until_index)
if array[i+1]
if array[i] > array[i+1]
array[i], array[i+1] = array[i+1], array[i]
sorted = false
end
end
end
unsorted_until_index -= 1
end
return array
end
我看到很多答案,每个人都在 while 循环中迭代或循环数组的长度。冒泡排序之所以称为冒泡排序,是因为在每次传递中,最高的未排序值“冒泡”到其正确位置。这样就可以在即将到来的 while 循环中省略这些元素。而不是直到,可以使用 while !sorted
。