Ruby中的快速排序算法-堆栈级别太深

我正在尝试用Ruby实现一个快速排序算法。我得到了一个简单的工作非常快，但它涉及到创建临时数组的飞行。我正在尝试实现一种更精简的快速排序，它只在不需要创建额外数组的情况下交换元素

有人知道为什么这个代码不起作用吗？我一直在遵循详细的模式，但我不能让它正常工作

def quicksort(arr = [], left = 0, right = 0)
  right = arr.length - 1 if right < 1
  if left < right
    index = partition(arr, left, right)
    quicksort(arr, left, index - 1)
    quicksort(arr, index, right)
  end
  arr
end

def partition(arr, left, right)
  pivot = arr[(left + right) / 2]
  while left <= right
    left += 1 while arr[left] < pivot
    right -= 1 while arr[right] > pivot
    if left <= right
      arr[left], arr[right] = arr[right], arr[left]
      left += 1
      right -= 1
    end
  end
  left
end

arr = [8, 10, 13, 5, 6, 20, 2, 43, 9, 11, 15]
p quicksort(arr)

def快速排序（arr=[]，左=0，右=0）
右=arr.length-1，如果右<1
如果左<右
索引=分区（arr、左、右）
快速排序（arr，左，索引-1）
快速排序（arr，索引，右侧）
结束
啊
结束
def分区（arr、左、右）
枢轴=arr[（左+右）/2]
而左枢轴
如果left如果我们抛出一个调试
p“left#{left}，Right#{Right}

def quicksort(arr = [], left = 0, right = 0)
  right = arr.length - 1 if right < 1
  if left < right
    index = partition(arr, left, right)
    quicksort(arr, left, index - 1)
    ...

问题是
right=arr.length-1，如果right<1
。如果
right
曾经<1，它会被设置回数组的末尾。
left
总是0，所以
left
总是小于
right
快速排序（arr，0，index-1）

会一次又一次地递归。

快速排序（arr，index，right）

从未到达

---

您的

分区

很好，可以在

pivot

中计算出良好的视觉效果

让您绊倒的是那些默认值。您正在为

right

设置一个小于1的默认值。但只有在根本没有传入的情况下才应该设置它

def quicksort(arr, left = 0, right = arr.length - 1)
  if left < right
    index = partition(arr, left, right)
    quicksort(arr, left, index - 1)
    quicksort(arr, index, right)
  end
  arr
end

---

如果对大型数组进行排序，堆栈空间可以限制为O（log（n）），但最坏情况下的时间复杂度将保持在O（n^2）。我不知道ruby语法，但理想的做法是只在较小的分区上递归，然后在较大的分区上循环：

def quicksort(arr, left = 0, right = arr.length - 1)
  while left < right
    index = partition(arr, left, right)
    if((index - left) < (right-index))
        quicksort(arr, left, index - 1)
        left = index
    else
        quicksort(arr, index, right)
        right = index-1
  end
  arr
end

def快速排序（arr，左=0，右=arr.length-1）
而左<右
索引=分区（arr、左、右）
如果（（索引-左）<（右索引））
快速排序（arr，左，索引-1）
左=索引
其他的
快速排序（arr，索引，右侧）
右=索引-1
结束
啊
结束

# Using the ! convention for functions which alter their arguments.
def quicksort!(array)
  _quicksort!(array, 0, array.length - 1)
end

private def _quicksort!(array, left, right)
  ...
end

def quicksort(arr, left = 0, right = arr.length - 1)
  while left < right
    index = partition(arr, left, right)
    if((index - left) < (right-index))
        quicksort(arr, left, index - 1)
        left = index
    else
        quicksort(arr, index, right)
        right = index-1
  end
  arr
end