Java 如何理解快速排序算法

根据我掌握的资料，我正在学习java中的快速排序。最好的情况是轴心是中位数，最坏的情况是轴心的一侧总是空的

对于下面的代码，是否将“indexPartition”作为轴心？您在下面的函数中输入了什么样的参数，以便它在最坏的情况下运行？

    private void quickSortSegment(E[] list, int start, int end)
{
  if (end-start>1) 
  { 
     int indexPartition = partition(list, start, end);
     quickSortSegment(list, start, indexPartition);
     quickSortSegment(list, indexPartition+1, end);
  }
}

private int partition(E[] list, int start, int end)
{
  E temp; 
  E partitionElement = list[start];
  int leftIndex = start; 
  int rightIndex = end-1;
  while (leftIndex<rightIndex)
  {  
    while (list[leftIndex].compareTo(partitionElement) <= 0 && leftIndex<rightIndex)
    {
        leftIndex++; 
    }
    while (list[rightIndex].compareTo(partitionElement) > 0)
    {
        rightIndex--; 
    }
     if (leftIndex<rightIndex)
     {  
        temp = list[leftIndex];
        list[leftIndex] = list[rightIndex];
        list[rightIndex] = temp;
     }
  }
  list[start] = list[rightIndex];
  list[rightIndex] = partitionElement;
  return rightIndex;
}

private void quickSortSegment（E[]列表，int开始，int结束）
{
如果（结束-开始>1）
{ 
int indexPartition=分区（列表、开始、结束）；
quickSortSegment（列表、开始、取消显示）；
QuickPortSegment（列表，索引+1，结束）；
}
}
私有int分区（E[]列表，int开始，int结束）
{
E温度；
E partitionElement=list[start]；
int leftIndex=start；
int rightIndex=end-1；
while（leftIndexNo）pivot是
partitionElement
。这段代码似乎总是选择序列中的第一个元素作为pivot。该函数在所有情况下都会运行，包括最坏的情况，但性能很差（具有平方复杂性）

不同的人提出了不同的选择轴心的解决方案，但我个人喜欢这样一个：从考虑的时间间隔中选择3个随机元素，计算它们的平均值，并将其用作轴心。
否轴心是
partitionElement
。而且该代码似乎总是选择序列中的第一个元素作为轴心。该函数将在所有情况下运行，包括最坏的情况，但性能较差（具有平方复杂性）

不同的人提出了不同的选择轴心点的解决方案，但我个人喜欢这个：从考虑的时间间隔中选择3个随机元素，计算它们的平均值，并将其用作轴心点。

这段视频和这篇文章应该会澄清一些问题。维基百科在解释排序算法方面非常棒。关于你的问题，
indexPartition
是
rightIndex
，它是
partitionElement
，pivot的索引。

这段视频和这篇文章应该会澄清一些问题。Wikipedia在解释排序算法方面非常棒。关于你的问题，
indexPartition
是
rightIndex
，它是
partitionElement
，pivot的索引。
这个方法partition（）有问题，例如{3,1,2}我们将得到{1,3,2}：

public class CompareApp {
public static void main(String... args) {
    Integer[] arr = {3, 1, 2};
    quickSortSegment(arr, 0, 2);
    for (Integer i : arr) System.out.println(i);
}

private static <E extends Comparable> void quickSortSegment(E[] list, int start, int end) {
    if (end - start > 1) {
        int indexPartition = partition(list, start, end);
        quickSortSegment(list, start, indexPartition);
        quickSortSegment(list, indexPartition + 1, end);
    }
}


private static <E extends Comparable> int partition(E[] list, int start, int end) {
    E temp;
    E partitionElement = list[start];
    int leftIndex = start;
    int rightIndex = end - 1;
    while (leftIndex < rightIndex) {
        while (list[leftIndex].compareTo(partitionElement) <= 0 && leftIndex < rightIndex) {
            leftIndex++;
        }
        while (list[rightIndex].compareTo(partitionElement) > 0) {
            rightIndex--;
        }
        if (leftIndex < rightIndex) {
            temp = list[leftIndex];
            list[leftIndex] = list[rightIndex];
            list[rightIndex] = temp;
        }
    }
    list[start] = list[rightIndex];
    list[rightIndex] = partitionElement;
    return rightIndex;
}}

公共类比较程序{
公共静态void main（字符串…参数）{
整数[]arr={3,1,2}；
快速排序段（arr，0，2）；
对于（整数i:arr）System.out.println（i）；
}
私有静态void quickSortSegment（E[]列表，int开始，int结束）{
如果（结束-开始>1）{
int indexPartition=分区（列表、开始、结束）；
quickSortSegment（列表、开始、取消显示）；
QuickPortSegment（列表，索引+1，结束）；
}
}
私有静态int分区（E[]列表，int开始，int结束）{
E温度；
E partitionElement=list[start]；
int leftIndex=start；
int rightIndex=end-1；
while（左索引<右索引）{
while（列表[leftIndex].compareTo（partitionElement）0）{
右索引--；
}
if（左索引<右索引）{
temp=列表[leftIndex]；
列表[左索引]=列表[右索引]；
列表[右索引]=临时；
}
}
列表[开始]=列表[右索引]；
list[rightIndex]=partitionElement；
返回右索引；
}}

java system.compare.CompareApp

一,
3.
2
此方法partition（）有问题，例如，对于{3,1,2}，我们将得到{1,3,2}：

public class CompareApp {
public static void main(String... args) {
    Integer[] arr = {3, 1, 2};
    quickSortSegment(arr, 0, 2);
    for (Integer i : arr) System.out.println(i);
}

private static <E extends Comparable> void quickSortSegment(E[] list, int start, int end) {
    if (end - start > 1) {
        int indexPartition = partition(list, start, end);
        quickSortSegment(list, start, indexPartition);
        quickSortSegment(list, indexPartition + 1, end);
    }
}


private static <E extends Comparable> int partition(E[] list, int start, int end) {
    E temp;
    E partitionElement = list[start];
    int leftIndex = start;
    int rightIndex = end - 1;
    while (leftIndex < rightIndex) {
        while (list[leftIndex].compareTo(partitionElement) <= 0 && leftIndex < rightIndex) {
            leftIndex++;
        }
        while (list[rightIndex].compareTo(partitionElement) > 0) {
            rightIndex--;
        }
        if (leftIndex < rightIndex) {
            temp = list[leftIndex];
            list[leftIndex] = list[rightIndex];
            list[rightIndex] = temp;
        }
    }
    list[start] = list[rightIndex];
    list[rightIndex] = partitionElement;
    return rightIndex;
}}

公共类比较程序{
公共静态void main（字符串…参数）{
整数[]arr={3,1,2}；
快速排序段（arr，0，2）；
对于（整数i:arr）System.out.println（i）；
}
私有静态void quickSortSegment（E[]列表，int开始，int结束）{
如果（结束-开始>1）{
int indexPartition=分区（列表、开始、结束）；
quickSortSegment（列表、开始、取消显示）；
QuickPortSegment（列表，索引+1，结束）；
}
}
私有静态int分区（E[]列表，int开始，int结束）{
E温度；
E partitionElement=list[start]；
int leftIndex=start；
int rightIndex=end-1；
while（左索引<右索引）{
while（列表[leftIndex].compareTo（partitionElement）0）{
右索引--；
}
if（左索引<右索引）{
temp=列表[leftIndex]；
列表[左索引]=列表[右索引]；
列表[右索引]=临时；
}
}
列表[开始]=列表[右索引]；
list[rightIndex]=partitionElement；
返回右索引；
}}

java system.compare.CompareApp

一,
3.
2
我强烈建议观看一些视频，你可以找到非常好的youtube视频查看我的答案。演示会非常有帮助。我强烈建议观看一些视频，你可以找到非常好的youtube视频查看我的答案。演示会非常有帮助。而且它不会排序大小=2个数组（子数组）：{3,1}->{3,1}它也不会对size=2数组（子数组）进行排序：{3,1}->{3,1}