这个快速排序正确吗?

Is this Quicksort correct?

我把主元改成了数组的第一个元素,这个快排算法还可以吗?数据数组中的变量 "l" 是否会成为所有分区步骤中的第一个元素?

x = 数据[l] // 枢轴

谢谢

  public void QuickSort(int[] data)
    {
        QuickSort(data, 0, data.Length - 1);

    }
    private void QuickSort(int[] data, int l, int r)
    {
        int i, j;
        int x;
        i = l;
        j = r;
        x = data[l];
        while (true)
        {
            while (data[i] < x)
            {
                i++;
            }
            while (data[j] > x)
            {
                j--;
            }
            if (l <= j)
            {
                int temporary = data[i];
                data[i] = data[j];
                data[j] = temporary;
                i++;
                j--;
            }
            if (i > j)
            {
                break;
            }
        }
        if (l < j)
        {
            QuickSort(data, l, j);
        }
        if (i < r)
        {
            QuickSort(data, i, r);
        }

    }
static public int Partition(int[] numbers, int left, int right)
        {
            int pivot = numbers[left];
            while (true)
            {
                while (numbers[left] < pivot)
                    left++;

                while (numbers[right] > pivot)
                    right--;

                if (left < right)
                {
                    int temp = numbers[right];
                    numbers[right] = numbers[left];
                    numbers[left] = temp;
                }
                else
                {
                    return right;
                }
            }
        }

        static public void QuickSort(int[] arr, int left, int right)
        {
            // For Recusrion  
            if (left < right)
            {
                int pivot = Partition(arr, left, right);

                if (pivot > 1)
                    QuickSort(arr, left, pivot - 1);

                if (pivot + 1 < right)
                    QuickSort(arr, pivot + 1, right);
            }
        }

你的逻辑不对 试试这个逻辑 先理解一下 跟你的差不多 但是有点区别