初涉 QuickSorting

所属排序类型：交换排序

算法名：快速排序法

是否稳定：否

时间复杂度：O(nlog2n)

 

核心思想：

设置一个排序比较的标准值，将小于这个值的元素移到左边，大于这个值的元素移到右边

 

算法步骤：

1：获取需排序序列的起始下标与结束下标

2：将起始下标元素的某个值作为排序参考的标准值(这里我们用这个序列的起始元素的某个值作为标准值)

3：定义一个临时对象标准参考值对象，依然在交换过程中覆盖掉参考值对象

4：首先我们编写一个完成一轮交换排序的函数 QuicjPartition(序列, 起始, 终止) 然后开始开始移动 high 下标从右向左寻找小于标准值的元素，当找到符合条件的元素后进行当  

      前 low 下标与 high 下标元素的位置交换，如下图

                             临时变量 = 序列[low];

                               low                                                                                   high

                                |                                                                                        |

                               36                  47                28                    95                   12                     84

                             序列[low] = 序列[high]

 

                              low                                                                                   high

                                |                                                                                        |

                               12                  47                28                    95                   12                     84

 

 

5：开始移动 low 下标从左向右寻找大于或等于标准值的元素，当找到符合条件的元素进行当前 high 下标与 low 下标元素的位置交换，如下图

                                                    low                                                              high

                                                      |                                                                   |

                               12                  47                28                    95                   12                     84

                               序列[high] = 序列[low]

                                                    low                                                              high

                                                      |                                                                   |

                               12                  47                28                    95                   47                    84

 

 

6：当 low < high 时重复 4 5 两个步骤最后得到

 

                                                    low              high

                                                      |                   |

                               12                  28                28                    95                   47                    84

 

                                                                        low

                                                                        high

                                                                          |

                               12                  28                28                    95                   47                    84

 

7：将 临时变量所保存的数据赋值给 low high 重叠的元素

      序列[low] = 临时变量

      并且返回 low 的下标

                                                                        low

                                                                        high

                                                                          |

                               12                  28                36                    95                   47                    84

 

8：至此一轮交换排序已经做完

 

9：接下来在编写一个 QuickSorting 函数递归完成一整个排序过程。递归时将整个序列分成两个部分，分别递归调用。在调用过程中需注意实参小标的控制。

 

10：首先我们通过 QuickPartition 函数的返回值得到当前标准值的下标位置，然后以这个下标位置作为“作为分水岭”将整个序列分成前后两个部分，然后“前后”部分分别递归调用 QuickSorting 函数完成交换排序， 如下伪代码

        快速排序(序列，起始，终止）

        {

              // 判断起始位置是否小于终止位置

              // 如果小于则调用 int tmp = QuickPartition 函数得到排序一轮后的标准元素的下标

              // 递归调用 快速排序(序列, low, tmp - 1);   完成前半部分排序

              // 递归调用 快速排序(序列, tmp + 1, high); 完成后半部分排序

         }

 

11：至此整个快速排序完毕