Question

我正在尝试将Bubble排序方法实现为Ruby的简单编码问题，但我遇到了一些麻烦。我理解的想法是查看第一个元素的值并将其与第二个元素的值进行比较，然后相应地交换它们，但我似乎无法在实际问题中这样做。有人愿意提供一个关于它如何在Ruby中起作用的简短例子吗？

Answer 1

使用while循环

正确实现冒泡排序

def bubble_sort(list)
  return list if list.size <= 1 # already sorted
  swapped = true
  while swapped do
    swapped = false
    0.upto(list.size-2) do |i|
      if list[i] > list[i+1]
        list[i], list[i+1] = list[i+1], list[i] # swap values
        swapped = true
      end
    end    
  end

  list
end

Answer 2

arr = [4,2,5,1]
loop until arr.each_cons(2).with_index.none?{|(x,y),i| arr[i],arr[i+1] = y,x if x > y}
p arr #=> [1, 2, 4, 5]

Answer 3

Source

def bubble_sort(list)
  return list if list.size <= 1 # already sorted

  loop do
    swapped = false
    0.upto(list.size-2) do |i|
      if list[i] > list[i+1]
        list[i], list[i+1] = list[i+1], list[i] # swap values
        swapped = true
      end
    end
    break unless swapped
  end

  list
end

虽然我肯定会推荐一些运行时间比bubblesort更好的东西：）

Answer 4

这是我的最佳答案版本。它只调用数组上的大小而不是每个循环。一旦它们移动到数组的末尾，它就不会比较元素。

while循环更快地退出一个循环。一旦你完成了整个数组并且只进行了一次交换，你就完成了，所以不需要用0交换进行另一次交换。

def bubble_sort(list)
  iterations = list.size - 2

  return list unless iterations > 0 # already sorted

  swaps = 2

  while swaps > 1 do
    swaps = 0

    0.upto(iterations) do |i|
      if list[i] > list[i + 1]
        list[i], list[i + 1] = list[i + 1], list[i] # swap values
        swaps += 1
      end
    end

    iterations -= 1
  end

  list
end

运行此测试所需的时间减少25％。

that_array = this_array = [22,66,4,44,5,7,392,22,8,77,33,118,99,6,1,62,29,14,139,2]
49.times {|variable| that_array = that_array + this_array}
bubble_sort that_array

Answer 5

重新编写@ VanDarg的代码以使用while循环（注意：代码未经过测试......自行承担风险）

def bubble_sort(list)
  return list if list.size <= 1 # already sorted

  swapped = true
  while swapped
    swapped = false # maybe this time, we won't find a swap
    0.upto(list.size-2) do |i|
      if list[i] > list[i+1]
        list[i], list[i+1] = list[i+1], list[i] # swap values
        swapped = true # found a swap... keep going
      end
    end
  end

  list
end

编辑更新的交换值，因为冒泡排序会在仍然进行掉期时继续排序 - 只要找不到更换，它就会停止排序。注意，这不遵循@ Doug的代码，但确实符合@ cLuv的修复

Answer 6

 def bubbleSort(list)
  sorted = false
  until sorted
    sorted = true
    for i in 0..(list.length - 2)
      if list[i] > list[i + 1]
        sorted = false
        list[i], list[i + 1] = list[i + 1], list[i]
      end
    end
  end
  return list
end

Answer 7

def bubble_sort array 
  array.each do
    swap_count = 0
    array.each_with_index do |a, index|
      break if index == (array.length - 1)
      if a > array[index+1]
        array[index],array[index+1] = array[index +1], array[index]
        swap_count += 1
      end
    end
    break if swap_count == 0 # this means it's ordered
  end
  array
end

Answer 8

直截了当：

def bubble_sort(n)
  return n if n.length <= 1

  0.upto(n.length - 1) do |t|
    0.upto(n.length - 2 - t) do |i|
      if n[i] > n[i + 1]
        n[i], n[i + 1] = n[i + 1], n[i]
      end
    end
  end

  n
end

Answer 9

这是我的代码。我喜欢使用（arr.length-1）。对于循环，你也可以使用诸如until，while，for，upto，loop do等迭代。有趣的尝试不同的东西，看它是如何运作的。

def bubble_sort(arr)  #10/17/13 took me 8mins to write it

return arr if arr.length <= 1

sorted = true

    while sorted
     sorted = false
     (arr.length-1).times do |i|
        if arr[i] > arr[i+1]
          arr[i], arr[i+1] = arr[i+1], arr[i]
          sorted = true
        end
       end
     end
    arr
    end

Answer 10

如果你不想使用这个有趣的交换线（IMO）：

    arr[i], arr[j] = arr[j], arr[i]

这是我的看法：

def bubble_sort(arr)
  temp = 0

  arr.each do |i|
    i = 0
    j = 1
    while (j < arr.length)
      if arr[i] > arr[j]
        temp = arr[i] 
        arr[i] = arr[j]
        arr[j] = temp 
        p arr
      end
    i+=1
    j+=1
    end
  end  
 arr
end

Answer 11

旧学校

def bubble_sort(random_numbers)
for i in 0..random_numbers.size 
  for j in i+1..random_numbers.size-1    
    random_numbers[i], random_numbers[j] = random_numbers[j], random_numbers[i] if(random_numbers[i] > random_numbers[j])
  end
end
random_numbers
end

Answer 12

以下是我使用XOR运算符：

def bubble(arr)
     n = arr.size - 1
     k = 1
     loop do
          swapped = false
          0.upto(n-k) do |i|
              if arr[i] > arr[i+1]
                 xor = arr[i]^arr[i+1]
                 arr[i] = xor^arr[i]
                 arr[i+1] = xor^arr[i+1]
                 swapped = true  
              end 
          end 
          break unless swapped
          k +=1 
     end
   return arr
end

Answer 13

class Array
a = [6, 5, 4, 3, 2, 1]
n = a.length

for j in 0..n-1
    for i in 0..n - 2 - j
           if a[i]>a[i+1]
                tmp = a[i]
                a[i] = a[i+1]
                a[i+1] = tmp
          end
     end
end

puts a.inspect
end

Answer 14

另一个略有不同的命名。

def bubble_sort(list)
  return list if list.size <= 1
  not_sorted = true

  while not_sorted
    not_sorted = false

    0.upto(list.size - 2) do |i|
      if list[i] > list[i + 1]
        list[i], list[i + 1] = list[i + 1], list[i]
        not_sorted = true
      end
    end
  end
  list
end

在Ruby中使用冒号排序方法

14 个答案: