Java快速排序。在循环时识别分区中的更改

如果在分区方法中我想初始化l=start或l=start+1和end=end-1，我需要对分区循环进行哪些更改？如果这些值被初始化为l=start-1；r=结束；比循环工作得好，但它不满足不变量。有什么想法吗

 public class qs {
          private qs(){}

    /**
     * Sort an array in ascending order
     * @param arr array to sor  */
       public static void quickSort(int[] arr){
        qs(arr, 0, arr.length);
            }

    /**
             * Sort a region of an array in ascending order.
             * Elements outside the given region are unchanged.
             * requires: 0 <= start <= end <= arr.length
             * @param arr   array to sort
             * @param start start of region (inclusive)
             * @param end   end of region (exclusive)
             */
            private static void qs(int[] arr, int start, int end){
                if (end <= start+1){    //region of length 0 or 1
                    return;
                }
                int x = arr[start];
                int p = partition(arr, start+1, end, x);
                    //now swap arr[start] with arr[p-1]
                arr[start] = arr[p-1];
                arr[p-1] = x;
                qs(arr, start, p-1);
                qs(arr, p, end);



            }

            /**
             * Partition a region of an array.
             * Rearranges elements in region so that small ones
             *   all have smaller indexes than the big ones.
             * Elements outside the region are unchanged.
             * requires: 0 <= start <= end <= arr.length
             * @param arr   array to partition
             * @param start start of region (inclusive)
             * @param end   end of region (exclusive)
             * @param x     pivot - "small" and "big" are <x, >=x.
             * @return      start index (inclusive) of big elements
             *              in region after partition.
             */
            private static int partition(
                int[] arr, int start, int end, int x)
            {

                int l = start ;
                int r = end-1;


                while (l<r) {

                    while(++l< r && arr[l] < x);

                        while(--r > l && arr[r] > x);

                        if(l >= r) // if pointers cross,
                            break; // partition done
                            else  {
                            int temp;
                        temp = arr[l];
                        arr[l] = arr[r];
                        arr[r] = temp;


                    }
                }
               return l;  
                }


            public static void main(String[] args) {
                int[] a = {15,8,4,8,9,6,};
                quickSort(a);
                for (int i = 0; i < a.length; i++){
                    System.out.print(" "+a[i]);
                }
            }
        }

公共类qs{
私有qs（）{}
/**
*按升序对数组排序
*@param arr数组到sor*/
公共静态void快速排序（int[]arr）{
qs（arr，0，arr.length）；
}
/**
*按升序对数组的区域进行排序。
*给定区域之外的元素不变。
*要求：0轴应该是中间点，而不是数组的起点

int x = arr[start];

将此行替换为此

int x = arr[(start+end)/2]

枢轴应该是中间点，而不是数组的起点

int x = arr[start];

将此行替换为此

int x = arr[(start+end)/2]

不，不能替换这一行。我不允许这样做。只有分区方法。我可以让它工作，但我不能满足循环不变量，可以从任何地方获取启动枢轴的状态，在无序数组中，每个选择都一样好。获取第一个元素稍微简化了算法，因为你总是用so交换枢轴方法。是的，但问题是如果我把int l=start-1；int r=end；放进去，这个方法很好，但不“兼容”使用循环不变量，我知道哪些状态是根据轴开始的，选择的代码必须更改。上面写的代码更多地表示中间轴…因此它必须相应地更改…让我重复一下，正如我前面所说的，如果我把l=start-1；int r=end；上面的代码工作正常，但我想更改l的初始化根据循环不变量r。这是我不理解的部分。不，不能替换这一行。我不允许这样做。只有分区方法。我可以让它工作，但我不能满足循环不变量，即可以从任何地方获取轴的起始状态，在无序数组中，每个选择都一样好。获取第一个元素si稍微简化了算法，因为你总是用一些东西交换枢轴。是的，但问题是如果我把int l=start-1；int r=end；放进去，这就行了，但不“兼容”使用循环不变量，我知道哪些状态是根据轴开始的，选择的代码必须更改。上面写的代码更多地表示中间轴…因此它必须相应地更改…让我重复一下，正如我前面所说的，如果我把l=start-1；int r=end；上面的代码工作正常，但我想更改l的初始化根据循环不变量r，这是我不理解的部分。