C++ 用quicksort-O（n^2）观察二次型行为

该算法的平均时间复杂度为O（n*log（n）），最坏情况复杂度为O（n^2）

假设Hoare的快速排序算法的某些变体，什么样的输入会导致快速排序算法表现出最坏情况的复杂性

请说明与特定快速排序算法（如枢轴选择等）的实现细节相关的任何假设，或者它是否来源于常用的库（如libc）

一些阅读：

当选择的轴的所有值都是所取集合中的最大值或最小值时，执行最差的ie，为O（n^2）。考虑这个例子。

123445

选择的轴是1，轴的右侧有4个元素，左侧没有元素。递归地应用同样的逻辑，选择的支点分别是2、3、4、5，我们得到了这样一种情况，即这种排序在最坏的时间执行

有人建议并证明，如果输入洗牌良好，快速排序的性能会很好

---

此外，排序的选择通常取决于对输入域的清晰了解。例如，如果输入是巨大的，那么有一种称为外部排序的东西可能会使用外部内存。如果输入的大小非常小，我们可以选择合并排序，但不能选择中等和较大的输入集，因为它使用额外的内存。快速排序的主要优点是它的“就地”含义，没有额外的内存用于输入数据。它在纸上的最坏情况时间是O（n^2），但仍然被广泛使用。我的观点是，排序算法可以根据输入集的知识和偏好进行更改。

要扩展Bragboy所说的内容，而不仅仅是运行：

quicksort(array);

运行：

其中

shuffle（）

的定义可以是：

shuffle(array){
    for(int i = array.length; i > 0; i--){
        r= random number % i;
        swap(array[i], array[r]);
    }
}

---

这样做很可能会处理这样的情况：获取输入会使

quicksort（）

变慢。

霍尔的快速排序算法选择一个随机轴。对于可重复的结果，我建议Scowen的修改，其中包括从输入中选择中间项。对于这种变体，轴最小的锯齿形图案似乎是最坏的输入：

starting with           {  j   i   h   g   f   a   e   d   c   b  }
compare 1 to 6          { (j)  i   h   g   f  (a)  e   d   c   b  }
compare 6 to 10         {  j   i   h   g   f  (a)  e   d   c  (b) }
compare 6 to 9          {  j   i   h   g   f  (a)  e   d  (c)  b  }
compare 6 to 8          {  j   i   h   g   f  (a)  e  (d)  c   b  }
compare 6 to 7          {  j   i   h   g   f  (a) (e)  d   c   b  }
swap 1<=>6              { (a)  i   h   g   f  (j)  e   d   c   b  }
compare 1 to 5          { (a)  i   h   g  (f)  j   e   d   c   b  }
compare 1 to 4          { (a)  i   h  (g)  f   j   e   d   c   b  }
compare 1 to 3          { (a)  i  (h)  g   f   j   e   d   c   b  }
compare 1 to 2          { (a) (i)  h   g   f   j   e   d   c   b  }
compare 2 to 6          {  a  (i)  h   g   f  (j)  e   d   c   b  }
compare 3 to 6          {  a   i  (h)  g   f  (j)  e   d   c   b  }
compare 4 to 6          {  a   i   h  (g)  f  (j)  e   d   c   b  }
compare 5 to 6          {  a   i   h   g  (f) (j)  e   d   c   b  }
compare and swap 6<=>10 {  a   i   h   g   f  (b)  e   d   c  (j) }
compare 7 to 10         {  a   i   h   g   f   b  (e)  d   c  (j) }
compare 8 to 10         {  a   i   h   g   f   b   e  (d)  c  (j) }
compare 9 to 10         {  a   i   h   g   f   b   e   d  (c) (j) }
compare 2 to 6          {  a  (i)  h   g   f  (b)  e   d   c   j  }
compare 6 to 9          {  a   i   h   g   f  (b)  e   d  (c)  j  }
compare 6 to 8          {  a   i   h   g   f  (b)  e  (d)  c   j  }
compare 6 to 7          {  a   i   h   g   f  (b) (e)  d   c   j  }
swap 2<=>6              {  a  (b)  h   g   f  (i)  e   d   c   j  }
compare 2 to 5          {  a  (b)  h   g  (f)  i   e   d   c   j  }
compare 2 to 4          {  a  (b)  h  (g)  f   i   e   d   c   j  }
compare 2 to 3          {  a  (b) (h)  g   f   i   e   d   c   j  }
compare 3 to 6          {  a   b  (h)  g   f  (i)  e   d   c   j  }
compare 4 to 6          {  a   b   h  (g)  f  (i)  e   d   c   j  }
compare 5 to 6          {  a   b   h   g  (f) (i)  e   d   c   j  }
compare and swap 6<=>9  {  a   b   h   g   f  (c)  e   d  (i)  j  }
compare 7 to 9          {  a   b   h   g   f   c  (e)  d  (i)  j  }
compare 8 to 9          {  a   b   h   g   f   c   e  (d) (i)  j  }
compare 3 to 6          {  a   b  (h)  g   f  (c)  e   d   i   j  }
compare 6 to 8          {  a   b   h   g   f  (c)  e  (d)  i   j  }
compare 6 to 7          {  a   b   h   g   f  (c) (e)  d   i   j  }
swap 3<=>6              {  a   b  (c)  g   f  (h)  e   d   i   j  }
compare 3 to 5          {  a   b  (c)  g  (f)  h   e   d   i   j  }
compare 3 to 4          {  a   b  (c) (g)  f   h   e   d   i   j  }
compare 4 to 6          {  a   b   c  (g)  f  (h)  e   d   i   j  }
compare 5 to 6          {  a   b   c   g  (f) (h)  e   d   i   j  }
compare and swap 6<=>8  {  a   b   c   g   f  (d)  e  (h)  i   j  }
compare 7 to 8          {  a   b   c   g   f   d  (e) (h)  i   j  }
compare 4 to 6          {  a   b   c  (g)  f  (d)  e   h   i   j  }
compare 6 to 7          {  a   b   c   g   f  (d) (e)  h   i   j  }
swap 4<=>6              {  a   b   c  (d)  f  (g)  e   h   i   j  }
compare 4 to 5          {  a   b   c  (d) (f)  g   e   h   i   j  }
compare 5 to 6          {  a   b   c   d  (f) (g)  e   h   i   j  }
compare and swap 6<=>7  {  a   b   c   d   f  (e) (g)  h   i   j  }
compare and swap 5<=>6  {  a   b   c   d  (e) (f)  g   h   i   j  }

以{j i h g f a e d c b}开始
比较1到6{（j）i h g f（a）e d c b}
比较6到10{j i h g f（a）e d c（b）}
比较6到9{ji h g f（a）ed（c）b}
比较6到8{jihgf（a）e（d）cb}
比较6和7{ji h g f（a）（e）d c b}
交换16{（a）i h g f（j）e d c b}
比较1到5{（a）i h g（f）j e d c b}
比较1到4{（a）i h（g）f j e d c b}
比较1到3{（a）i（h）gfj e d c b}
比较1到2{（a）（i）hgfjedcb}
比较2到6{a（i）hgf（j）edcb}
比较3到6{ai（h）gf（j）edcb}
比较4到6{aih（g）f（j）edcb}
比较5到6{a i h g（f）（j）e d c b}
比较和交换610{a i h g f（b）e d c（j）}
比较7到10{a i h g f b（e）d c（j）}
比较8到10{a i h g f b e（d）c（j）}
比较9到10{a i h g f b e d（c）（j）}
比较2到6{a（i）hgf（b）edcj}
比较6到9{a i h g f（b）e d（c）j}
比较6到8{aihgf（b）e（d）cj}
比较6到7{a i h g f（b）（e）d c j}
交换26{a（b）hgf（i）edcj}
比较2到5{a（b）hg（f）iedcj}
比较2到4{a（b）h（g）f i e d c j}
比较2到3{a（b）（h）gfi e d c j}
比较3到6{ab（h）gf（i）edcj}
比较4到6{abh（g）f（i）edcj}
比较5到6{abhg（f）（i）edcj}
比较和交换69{abhgf（c）edj（i）j}
比较7到9{abh g f c（e）d（i）j}
比较8和9{abh g f c e（d）（i）j}
比较3到6{ab（h）gf（c）edij}
比较6到8{abhgf（c）e（d）ij}
比较6到7{abhgf（c）（e）dij}
交换36{ab（c）gf（h）edi j}
比较3到5{ab（c）g（f）hedij}
比较3到4{ab（c）（g）f h e d i j}
比较4到6{abc（g）f（h）edij}
比较5到6{abcg（f）（h）edij}
比较和交换68{abccgf（d）e（h）ij}
比较7到8{abccgfd（e）（h）ij}
比较4到6{abc（g）f（d）ehhij}
比较6到7{abccgf（d）（e）hij}
交换46{abc（d）f（g）ehhij}
比较4到5{abc（d）（f）gehij}
比较5到6{abcdf（g）ehhij}
比较和交换67{abcdf（e）（g）hij}
比较和交换56{abcde（e）（f）ghij}

本文中概述的攻击的一个先决条件是能够运行任意可执行代码，他们能想到的最好办法是让快速排序变成二次排序？我建议-如果听起来像是家庭作业，应该在测试后1-2周内回答

starting with           {  j   i   h   g   f   a   e   d   c   b  }
compare 1 to 6          { (j)  i   h   g   f  (a)  e   d   c   b  }
compare 6 to 10         {  j   i   h   g   f  (a)  e   d   c  (b) }
compare 6 to 9          {  j   i   h   g   f  (a)  e   d  (c)  b  }
compare 6 to 8          {  j   i   h   g   f  (a)  e  (d)  c   b  }
compare 6 to 7          {  j   i   h   g   f  (a) (e)  d   c   b  }
swap 1<=>6              { (a)  i   h   g   f  (j)  e   d   c   b  }
compare 1 to 5          { (a)  i   h   g  (f)  j   e   d   c   b  }
compare 1 to 4          { (a)  i   h  (g)  f   j   e   d   c   b  }
compare 1 to 3          { (a)  i  (h)  g   f   j   e   d   c   b  }
compare 1 to 2          { (a) (i)  h   g   f   j   e   d   c   b  }
compare 2 to 6          {  a  (i)  h   g   f  (j)  e   d   c   b  }
compare 3 to 6          {  a   i  (h)  g   f  (j)  e   d   c   b  }
compare 4 to 6          {  a   i   h  (g)  f  (j)  e   d   c   b  }
compare 5 to 6          {  a   i   h   g  (f) (j)  e   d   c   b  }
compare and swap 6<=>10 {  a   i   h   g   f  (b)  e   d   c  (j) }
compare 7 to 10         {  a   i   h   g   f   b  (e)  d   c  (j) }
compare 8 to 10         {  a   i   h   g   f   b   e  (d)  c  (j) }
compare 9 to 10         {  a   i   h   g   f   b   e   d  (c) (j) }
compare 2 to 6          {  a  (i)  h   g   f  (b)  e   d   c   j  }
compare 6 to 9          {  a   i   h   g   f  (b)  e   d  (c)  j  }
compare 6 to 8          {  a   i   h   g   f  (b)  e  (d)  c   j  }
compare 6 to 7          {  a   i   h   g   f  (b) (e)  d   c   j  }
swap 2<=>6              {  a  (b)  h   g   f  (i)  e   d   c   j  }
compare 2 to 5          {  a  (b)  h   g  (f)  i   e   d   c   j  }
compare 2 to 4          {  a  (b)  h  (g)  f   i   e   d   c   j  }
compare 2 to 3          {  a  (b) (h)  g   f   i   e   d   c   j  }
compare 3 to 6          {  a   b  (h)  g   f  (i)  e   d   c   j  }
compare 4 to 6          {  a   b   h  (g)  f  (i)  e   d   c   j  }
compare 5 to 6          {  a   b   h   g  (f) (i)  e   d   c   j  }
compare and swap 6<=>9  {  a   b   h   g   f  (c)  e   d  (i)  j  }
compare 7 to 9          {  a   b   h   g   f   c  (e)  d  (i)  j  }
compare 8 to 9          {  a   b   h   g   f   c   e  (d) (i)  j  }
compare 3 to 6          {  a   b  (h)  g   f  (c)  e   d   i   j  }
compare 6 to 8          {  a   b   h   g   f  (c)  e  (d)  i   j  }
compare 6 to 7          {  a   b   h   g   f  (c) (e)  d   i   j  }
swap 3<=>6              {  a   b  (c)  g   f  (h)  e   d   i   j  }
compare 3 to 5          {  a   b  (c)  g  (f)  h   e   d   i   j  }
compare 3 to 4          {  a   b  (c) (g)  f   h   e   d   i   j  }
compare 4 to 6          {  a   b   c  (g)  f  (h)  e   d   i   j  }
compare 5 to 6          {  a   b   c   g  (f) (h)  e   d   i   j  }
compare and swap 6<=>8  {  a   b   c   g   f  (d)  e  (h)  i   j  }
compare 7 to 8          {  a   b   c   g   f   d  (e) (h)  i   j  }
compare 4 to 6          {  a   b   c  (g)  f  (d)  e   h   i   j  }
compare 6 to 7          {  a   b   c   g   f  (d) (e)  h   i   j  }
swap 4<=>6              {  a   b   c  (d)  f  (g)  e   h   i   j  }
compare 4 to 5          {  a   b   c  (d) (f)  g   e   h   i   j  }
compare 5 to 6          {  a   b   c   d  (f) (g)  e   h   i   j  }
compare and swap 6<=>7  {  a   b   c   d   f  (e) (g)  h   i   j  }
compare and swap 5<=>6  {  a   b   c   d  (e) (f)  g   h   i   j  }