使用 Sort 和 Sort_by 对数组进行排序

Question

我正在尝试围绕以下代码的工作原理构建一个心理 model，这让我感到困惑。 我正在尝试对字符串进行排序，以便每个重复的字母都在一起，但大写字母排在第一位。 解决了，下面的方法就可以了，但是我想知道为什么一定要先sort呢？ 它是否保持与第一类相同的 position ？ 因此，当您调用sort_by时，它会按小写字母排序，但大写字母仍保留在原来的位置？ 任何人都可以逐步分解正在发生的事情，以便我更好地理解这一点吗？

def alpha(str)
 str.chars.sort.sort_by { |ele| ele.downcase }.join
end

alpha("AaaaaZazzz") == "AaaaaaZzzz"

Answer 1

让我们重写你的方法如下。

def alpha(str)
 sorted_chars_by_case = str.chars.sort
 puts "sorted_chars = #{sorted_chars}"
 sorted_chars_by_downcased = sorted_chars_by_case.sort_by(&:downcase)
 puts "sorted_chars_by_downcased = #{sorted_chars_by_downcased}"
 sorted_chars_by_downcased.join
end

然后：

alpha("AaaaaZazzz")
  sorted_chars_by_case = ["A", "Z", "a", "a", "a", "a", "a", "z", "z", "z"]
  sorted_chars_indifferent = ["A", "a", "a", "a", "a", "a", "Z", "z", "z", "z"]
  #=> "AaaaaaZzzz"

如您所见，第一步，在将字符串转换为字符数组后，形成一个数组，其第一个元素是大写字母，按顺序排列，然后是小写字母，也按顺序排列。 ¹第二步是排序sorted_chars_by_case ，不参考case。 然后加入该数组以返回所需的字符串"AaaaaaZzzz" 。

虽然这给出了预期的结果，但这只是偶然的。 一个不同的排序方法很可能会返回，比如"aaaaAazZzz" ，因为"A"在第二次排序中被视为与"a"相同。

您想要的是两级排序； 按字符排序，不区分大小写，然后当有关系时（例如"A"和"a" ），首先对大写字母进行排序。 您可以通过对两个元素 arrays 进行排序来做到这一点。

def alpha(str)
  str.each_char.sort_by { |ele| [ele.downcase, ele] }.join
end

然后

alpha("AaaaaZazzz")
  #=> "AaaaaaZzzz"

排序 arrays 时，使用方法Array#<=>排序两个 arrays。 特别注意该文档的第三段。

例如，如果订购"A"和"z" ，Ruby 将比较 arrays

a1 = ["a", "A"]
a2 = ["z", "z"]

作为a1.first < a2.first #=> true ，我们看到a1 <=> a2 #=> -1 ，所以在排序中"A"在"z"之前。 这里a1.last和a2.last没有被检查。

现在假设正在订购"z"和"Z" 。 Ruby 比较 arrays

a1 = ["z", "z"]
a2 = ["z", "Z"]

由于a1.first等于a2.first ，因此比较a1.last和a2.last以打破平局。 因为"z" > "Z" #=> true , a1 <=> a2 #=> 1 ，所以"Z"在排序中在"z" " 之前。

---

请注意，我将str.chars替换为str.each_char 。 这通常是一件小事，但String#chars返回一个字符数组，而String#each_char返回一个枚举器，因此更节省空间。

有时您需要返回一个数组，因此您必须使用chars 。 一个示例是str.chars.cycle ，您在其中链接到Array方法cycle 。 另一方面，如果要链接到枚举器（ class枚举器的实例），则必须使用each_char ，例如str.each_char.with_object([])... 。

但是，您通常可以选择：使用Array#sort的str.chars.sort或使用Enumerable#sort的str.each_char.sort 。 在这些情况下， each_char是首选，因为减少了 memory 要求。 因此，规则是在链接到Array方法时使用chars ，否则使用each_char 。

^{1. sort_by(&:downcase)可以认为是sort_by { |ele| ele.downcase }的简写。 sort_by { |ele| ele.downcase } .}

Answer 2

您不能依赖 Ruby 中排序的稳定性

这是个有趣的问题。 排序是否保留相等元素的顺序是它的“稳定性”。 如果保证保持相等元素的顺序，则排序是稳定的，如果没有这样的保证，则排序是不稳定的。 不稳定的排序可能会按原始顺序返回相等的元素，也可能不返回。

在 MRI 2.7.1 中，sort 恰好是稳定的，但它实际上是由实现定义的。 请参阅https://stackoverflow.com/a/44486562/238886了解所有有趣的细节，包括您可以在 Ruby 中运行的代码，以确定您的排序是否稳定。 但是无论你的排序是否稳定，你都不应该依赖它。

稳定的排序确实会返回您期望的结果，并且无论您是否包含.sort都会返回：

2.7.1 :035 > "AaaaaZazzz".chars.sort_by { |ele| ele.downcase }.join
 => "AaaaaaZzzz" 
2.7.1 :036 > "AaaaaZazzz".chars.sort.sort_by { |ele| ele.downcase }.join
 => "AaaaaaZzzz" 

但是您可以在需要时使排序行为稳定

为了不依赖排序的稳定性，当您将代码移动到另一个 Ruby 版本或实现时，排序的稳定性可能会发生变化，您可以像这样强制稳定性：

 "AaaaaZazzz".chars.sort_by.with_index { |ele, i| [ele.downcase, i] }.join
 => "AaaaaaZzzz" 

不稳定排序如何表现

我们可以通过添加一个随机数作为二级排序顺序来强制 Ruby 2.7.1 的排序不稳定：

2.7.1 :040 > "AaaaaZazzz".chars.sort.sort_by { |ele, i| [ele.downcase, rand] }.join
 => "AaaaaaZzzz" 
2.7.1 :041 > "AaaaaZazzz".chars.sort.sort_by { |ele, i| [ele.downcase, rand] }.join
 => "aaaaAazzZz" 

请注意我们第一次得到与稳定排序相同的答案，但随后得到不同的答案？ 这展示了不稳定排序如何偶然给您提供与稳定排序相同的结果。 但你不能指望它。

Answer 3

首先，您根据底层编码的整理顺序按字母顺序对这段代码中的所有字符进行排序，然后以大写和小写字符被视为相同的方式对字符进行排序。 这取消了第一个排序的效果。 因此 output 等效于str.chars.sort_by(&:downcase) ，这将使 IMO 以更明智的方式编写表达式。

第sort没有效果，因此只是一个循环窃取器。 顺便说一句：由于未指定 Ruby 排序的稳定性，尤其是已知MRI Ruby 不稳定，因此您无法控制各个字符的相对顺序，这些字符在排序顺序中被认为是等效的。 另请注意，结果取决于区域设置，因为这决定了 - 例如 - 字母 Б 和 б 在排序顺序上被认为是相同的还是不同的。

Answer 4

我正在尝试围绕以下代码的工作原理构建一个心理 model，这让我感到困惑。 我正在尝试对字符串进行排序，以便每个重复的字母都在一起，但大写字母排在第一位。 解决了，下面的方法就可以了，但是我想知道为什么一定要先sort呢？ 它是否保持与第一类相同的 position ？ 因此，当您调用sort_by时，它会按小写字母排序，但大写字母仍保留在原来的位置？ 任何人都可以逐步分解正在发生的事情，以便我更好地理解这一点吗？

def alpha(str)
 str.chars.sort.sort_by { |ele| ele.downcase }
end

alpha("AaaaaZazzz") == "AaaaaaZzzz"