Question

我尝试用ruby实现shell排序。

def shell_sort(list)
  d = list.length
  return -1 if d == 0
  (0...list.length).each do |i|
    d = d / 2
    puts "d:#{d}"
    (0...(list.length-d)).each do |j|
      if list[j] >= list[j+d]
         list[j], list[j+d] = list[j+d], list[j]
      end
    end
    puts list.inspect
    break if d == 1
  end
  list
end

puts shell_sort([10,9,8,7,6,5,4,3,2,1]).inspect

但结果不正确。

=>[2, 1, 3, 4, 5, 7, 6, 8, 9, 10]

我不知道哪里出了问题，希望有人可以帮助我。提前谢谢！

Answer 1

我认为您的算法需要稍微调整一下。

它失败的原因仅仅是因为在最后一次运行时（当d == 1时），最小元素（1）不足以使第一个元素一次性交换。

使其成功的最简单方法是重新启动＆＃34;元素切换位置时的内部循环。所以，有点粗略的解决方案就像是

(0...(list.length-d)).each do |j|
  if list[j] >= list[j+d]
    list[j], list[j+d] = list[j+d], list[j]
    d *= 2
    break
  end
end

这个解决方案当然远非最佳，但应尽可能少地使用所需的结果。

Answer 2

我在这里引用了Shell Sort：Shell Sort - Wikepedia，从中我已经理解你的算法错了。间隙序列的迭代是正常的，我的意思是你只迭代到d/2 == 1。

但是对于差距，让我们说2，如果0更大，您只需从list.length-2迭代到j并交换每个j+2和list[j]元素比list[j+2]。这甚至不是正确的插入排序，Shell Sort需要在间隙上进行插入排序。另外，Shell Sort要求在执行x gap排序之后，从任何位置开始的每个xth元素都将被排序（请参阅链接上的示例运行，您可以自己验证）。

在2间隙排序过程中可能出错的情况：

list = 5,4,3,2,1
j = 0 passed :
list = 3,4,5,2,1
j = 1 passed : 
list = 3,2,5,4,1
j = 2 passed
list = 3,2,1,4,5

完成后，您可以看到从0开始的每个第2个元素都不是按排序顺序排列的。我建议您首先学习插入排序，然后了解它在Shell排序中的使用位置和方式，如果您想自己动手，请再试一次。

无论如何，我已经写了一个（如果你愿意，可以保存以后）以你的方法为基础，有很多评论。希望你通过这个得到这个想法。还尝试使输出澄清算法的工作原理。

def shell_sort(list)
  d = list.length
  return -1 if d == 0

  # You select and iterate over your gap sequence here.
  until d/2 == 0 do
    d = d / 2

    # Now you pick up an index i, and make sure every dth element,
    # starting from i is sorted.
    # i = 0
    # while i < list.length do
    0.step(list.length) do |i|

      # Okay we picked up index i. Now it's just plain insertion sort.
      # Only difference is that we take elements with constant gap, 
      # rather than taking them up serially.
      # igap = i + d
      # while igap < list.length do
      (i+d).step(list.length-1, d) do |igap| 

         # Just like insertion sort, we take up the last most value.
         # So that we can shift values greater than list[igap] to its side,
         # and assign it to a proper position we find for it later.
         temp = list[igap]
         j = igap
         while j >= i do
           break if list[j] >= list[j - d]
           list[j] = list[j-d]
           j -= d
        end
        # Okay this is where it belongs.
        list[j] = temp

        #igap += d
      end

      # i += 1
    end
    puts "#{d} sort done, the list now : "
    puts list.inspect
   end
   list
end

list = [10,9,8,7,6,5,4,3,2,1]
puts "List before sort : "
puts list.inspect
shell_sort(list)
puts "Sorted list : "
puts list.inspect

Answer 3

你应该在阵列上进行最后一次运行。为了简化代码，我将交换部分提取为独立的功能，以便您现在可以看到应该在哪里执行此操作：

def exchange e, list
  (0...(list.length-e)).each do |j|
    if list[j] >= list[j+e]
      list[j], list[j+e] = list[j+e], list[j]
    end
  end
end

def shell_sort(list)
  d = list.length
  return -1 if d == 0
  (0...list.length).each do |i|
    d = d / 2
    puts "d:#{d}"
    exchange(d, list)
    puts list.inspect
    if d == 1
      exchange(d, list)
      break
    end
  end
  list
end

arr = [10,9,8,7,6,5,4,3,2,1]
p shell_sort(arr)

结果：

#> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

通过ruby实现shell排序

3 个答案: