上方没有C#实现，我补充一下，如下所示：

//快速排序（目标数组，数组的起始位置，数组的终止位置）
static void QuickSort(int[] array, int left = 0, int right = -1)
{
    if (right.Equals(-1)) right = array.Length - 1;
    try
    {
        int keyValuePosition;   //记录关键值的下标
        //当传递的目标数组含有两个以上的元素时，进行递归调用。（即：当传递的目标数组只含有一个元素时，此趟排序结束）
        if (left < right)
        {
            keyValuePosition = Partion(array, left, right);  //获取关键值的下标（快排的核心）
            QuickSort(array, left, keyValuePosition - 1);    //递归调用，快排划分出来的左区间
            QuickSort(array, keyValuePosition + 1, right);   //递归调用，快排划分出来的右区间
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine("Exception: {0}", ex);
    }
}

///快速排序的核心部分：确定关键值在数组中的位置，以此将数组划分成左右两区间，关键值游离在外。（返回关键值应在数组中的下标）
static int Partion(int[] array, int left, int right)
{
    int leftIndex = left;        //记录目标数组的起始位置（后续动态的左侧下标）
    int rightIndex = right;      //记录目标数组的结束位置（后续动态的右侧下标）
    int keyValue = array[left];  //数组的第一个元素作为关键值
    int temp;
    //当 （左侧动态下标 == 右侧动态下标） 时跳出循环
    while (leftIndex < rightIndex)
    {
        while (leftIndex < rightIndex && array[leftIndex] <= keyValue)  //左侧动态下标逐渐增加，直至找到大于keyValue的下标
        {
            leftIndex++;
        }
        while (leftIndex < rightIndex && array[rightIndex] > keyValue)  //右侧动态下标逐渐减小，直至找到小于或等于keyValue的下标
        {
            rightIndex--;
        }
        if (leftIndex < rightIndex)  //如果leftIndex < rightIndex，则交换左右动态下标所指定的值；当leftIndex==rightIndex时，跳出整个循环
        {
            temp = array[leftIndex];
            array[leftIndex] = array[rightIndex];
            array[rightIndex] = temp;
        }
    }

    //当左右两个动态下标相等时（即：左右下标指向同一个位置），此时便可以确定keyValue的准确位置
    temp = keyValue;
    if (temp < array[rightIndex])   //当keyValue < 左右下标同时指向的值，将keyValue与rightIndex - 1指向的值交换，并返回rightIndex - 1
    {
        array[left] = array[rightIndex - 1];
        array[rightIndex - 1] = temp;
        return rightIndex - 1;
    }
    else //当keyValue >= 左右下标同时指向的值，将keyValue与rightIndex指向的值交换，并返回rightIndex
    {
        array[left] = array[rightIndex];
        array[rightIndex] = temp;
        return rightIndex;
    }
}

补充一下迭代法的 python 实现：

def _partition(array:list, start:int, end:int) -> int:
    """
    将数组指定片段进行左右划分，首先选择中位元素为中值。\n
    比中位元素小的置于其左，与中位元素相等或比中位元素大的置于其右，\n
    最后返回中位元素的下标位置。
    """
    # 以中位元素为中值划分，尽量避免极端情况
    mid = (start + end) >> 1
    array[start], array[mid] = array[mid], array[start]
    
    # 划分的实现
    i, j = start, end
    x = array[start]
    while (i < j):
        if (i < j and array[j] >= x): j -= 1
        array[i] = array[j]
        if (i < j and array[i] < x): i += 1
        array[j] = array[i]
    array[i] = x

    return i


def quickSort(array:list) -> list:
    """
    迭代法快速排序，队列结构辅助实现。
    """
    sorted_array = array.copy()
    length = len(sorted_array)
    # 使用队列保存每次划分的二元组：(起始下标，终止下标)
    queue = []
    queue.append((0, length - 1))

    # 队列为空，则所有划分操作执行完毕
    while len(queue):
        left, right = queue.pop(0)
        pos = _partition(sorted_array, left, right)
        # 默认长度为 1 的序列有序，那么区间长度 > 1 才需要划分，才需要保存到队列中
        if (left < pos - 1): queue.append((left, pos - 1))
        if (pos + 1 < right): queue.append((pos + 1, right))
    
    return sorted_array


if __name__ == "__main__":
    array = [21, -17, 1, -27, 41, 17, -5, -49]
    sorted_array = quickSort(array)
    print("排序前：{array1}\n排序后：{array2}".format(array1=array, array2=sorted_array))