快速排序算法原理与实现
#include
using std::cout;
using std::endl;
int Partition( int *R, int low, int high){
// 对记录子序列 R[low..high] 进行一趟快速排序，并返回枢轴记录
// 所在位置，使得在它之前的记录的关键字均不大于它的关键字，
// 而在它之后的记录的关键字均不小于它的关键字
R[0] = R[low]; // 将枢轴记录移至数组的闲置分量
int pivotkey = R[low]; // 枢轴记录关键字
cout << endl << "pivotkey : " << pivotkey << endl;
while(low < high){ // 从表的两端交替地向中间扫描
while( low=pivotkey ){
--high;
}
if(low =high而退出的循环，不需要移动数据
R[low++] = R[high]; // 将比枢轴记录小的记录移到低端
//cout << "移动的hign数据：" << R[high] << endl;
}
while (low<high && R[low]<=pivotkey )
++low;
if(low < high){
R[high--] = R[low]; // 将比枢轴记录大的记录移到高端
//cout << "移动的low数据：" << R[low] << endl;
}
} // while
R[low] = R[0]; // 枢轴记录移到正确位置
//cout << "返回的pivotkey: " << low << endl;
for(int i = 1; i<=10; i++){
cout << R[i-1] << " ";
}
return low; // 返回枢轴位置
} // Partition
void QSort(int *R, int s, int t ){
// 对记录序列 R[s..t] 进行快速排序
if (s < t){ // 长度大于1
int pivotloc = Partition(R, s, t);// 对 R[s..t] 进行一趟快排，并返回枢轴位置
QSort(R, s, pivotloc-1);//对低子序列递归进行排序
QSort(R, pivotloc+1, t);//对高子序列递归进行排序
}//if
}//Qsort
int main(){
int li[10] = {0,38,65,97,76,13,27,48,55,4};
cout<<"注意:R[0]为数组的闲置分量"<<endl;
for(int i = 1; i<=10; i++){
cout << li[i-1] << " ";
}
cout << endl;
QSort(li,1,9);
cout << endl;
for(int i = 1; i<=10; i++){
cout << li[i-1] << " ";
}
cout << endl;
return 0;
}
快速排序的基本思想就是从一个数组中任意挑选一个元素（通常来说会选择最左边的元素）作为中轴元素，将剩下的元素以中轴元素作为比较的标准，将小于等于中轴元素的放到中轴元素的左边，将大于中轴元素的放到中轴元素的右边。
然后以当前中轴元素的位置为界，将左半部分子数组和右半部分子数组看成两个新的数组，重复上述操作，直到子数组的元素个数小于等于1（因为一个元素的数组必定是有序的）。
以下的代码中会常常使用交换数组中两个元素值的Swap方法，其代码如下
public static void Swap(int[] A, int i, int j){
int tmp;
tmp = A[i];
A[i] = A[j];
A[j] = tmp;
扩展资料：
快速排序算法 的基本思想是：将所要进行排序的数分为左右两个部分，其中一部分的所有数据都比另外一 部分的数据小，然后将所分得的两部分数据进行同样的划分，重复执行以上的划分操作，直 到所有要进行排序的数据变为有序为止。
定义两个变量low和high，将low、high分别设置为要进行排序的序列的起始元素和最后一个元素的下标。第一次，low和high的取值分别为0和n-1，接下来的每次取值由划分得到的序列起始元素和最后一个元素的下标来决定。
定义一个变量key，接下来以key的取值为基准将数组A划分为左右两个部分，通 常，key值为要进行排序序列的第一个元素值。第一次的取值为A[0]，以后毎次取值由要划 分序列的起始元素决定。
从high所指向的数组元素开始向左扫描，扫描的同时将下标为high的数组元素依次与划分基准值key进行比较操作，直到high不大于low或找到第一个小于基准值key的数组元素，然后将该值赋值给low所指向的数组元素，同时将low右移一个位置。
如果low依然小于high，那么由low所指向的数组元素开始向右扫描，扫描的同时将下标为low的数组元素值依次与划分的基准值key进行比较操作，直到low不小于high或找到第一个大于基准值key的数组元素，然后将该值赋给high所指向的数组元素，同时将high左移一个位置。
重复步骤(3) (4)，直到low的植不小于high为止，这时成功划分后得到的左右两部分分别为A[low……pos-1]和A[pos+1……high]，其中，pos下标所对应的数组元素的值就是进行划分的基准值key，所以在划分结束时还要将下标为pos的数组元素赋值 为 key。
快速排序的基本思想就是从一个数组中任意挑选一个元素（通常来说会选择最左边的元素）作为中轴元素，将剩下的元素以中轴元素作为比较的标准，将小于等于中轴元素的放到中轴元素的左边，将大于中轴元素的放到中轴元素的右边。
然后以当前中轴元素的位置为界，将左半部分子数组和右半部分子数组看成两个新的数组，重复上述操作，直到子数组的元素个数小于等于1（因为一个元素的数组必定是有序的）。
以下的代码中会常常使用交换数组中两个元素值的Swap方法，其代码如下
public static void Swap(int[] A, int i, int j){
int tmp;
tmp = A[i];
A[i] = A[j];
A[j] = tmp;
扩展资料：
快速排序算法 的基本思想是：将所要进行排序的数分为左右两个部分，其中一部分的所有数据都比另外一 部分的数据小，然后将所分得的两部分数据进行同样的划分，重复执行以上的划分操作，直 到所有要进行排序的数据变为有序为止。
定义两个变量low和high，将low、high分别设置为要进行排序的序列的起始元素和最后一个元素的下标。第一次，low和high的取值分别为0和n-1，接下来的每次取值由划分得到的序列起始元素和最后一个元素的下标来决定。
定义一个变量key，接下来以key的取值为基准将数组A划分为左右两个部分，通 常，key值为要进行排序序列的第一个元素值。第一次的取值为A[0]，以后毎次取值由要划 分序列的起始元素决定。
从high所指向的数组元素开始向左扫描，扫描的同时将下标为high的数组元素依次与划分基准值key进行比较操作，直到high不大于low或找到第一个小于基准值key的数组元素，然后将该值赋值给low所指向的数组元素，同时将low右移一个位置。
如果low依然小于high，那么由low所指向的数组元素开始向右扫描，扫描的同时将下标为low的数组元素值依次与划分的基准值key进行比较操作，直到low不小于high或找到第一个大于基准值key的数组元素，然后将该值赋给high所指向的数组元素，同时将high左移一个位置。
重复步骤(3) (4)，直到low的植不小于high为止，这时成功划分后得到的左右两部分分别为A[low……pos-1]和A[pos+1……high]，其中，pos下标所对应的数组元素的值就是进行划分的基准值key，所以在划分结束时还要将下标为pos的数组元素赋值 为 key。
参考资料:快速排序算法_百度百科
基本原理
从序列中任选一个数作为“基准”；所有小于“基准”的数，都挪到“基准”的左边；所有大于等于“基准”的数，都挪到“基准”的右边。
在这次移动结束之后，该“基准”就处于两个序列的中间位置，不再参与后续的排序；针对“基准”左边和右边的两个子序列，不断重复上述步骤，直到所有子序列只剩下一个数为止。
1、选择“基准”，并将其从原始数组分离
先获取基准的索引值，再使用splice数组方法取出基准值。
Tips：该实例中， 基准的索引值 = parseInt（序列长度 / 2）。
Tips：splice方法会改变原始数组。例如，arr = [1, 2, 3]; 基准索引值为1，基准值为2，原始数组变为arr = [1, 3]。
2、遍历序列，拆分序列
与“基准”比较大小，并拆分为两个子序列，小于“基准”的数存储于leftArr数组当中，大于等于“基准”的数存储于rightArr数组当中。
Tips：当然，也可以将 小于等于“基准”的数存于leftArr，大于“基准”的数存于rightArr。
由于要遍历序列，将每一个数与“基准”进行大小比较，所以，需要借助for语句来实现
3、递归调用，遍历子序列并组合子序列的结果
定义一个函数，形参用于接收数组
function quickSort(arr) { }；
实现递归调用遍历子序列，用concat数组方法组合子序列的结果。
4、判断子序列的长度
递归调用的过程中，子序列的长度等于1时，则停止递归调用，返回当前数组。
扩展资料
一趟快速排序的算法是：
1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；
2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；
4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换；
5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。
参考资料：百度百科 快速排序法
快速排序算法的原理与实现：
快速排序与归并排序已有,也使用分治思想。下面介绍下对一个典型的子数组A[p..r]进行快速排序的三步分治过程:
分解:数组A[p..r]被划分为两个(可能为空)子数组A[p..q-1]和A[q+1..r],使得A[p..q-1]中的每一个元素都小于等于A[q],而A[q]也小于等于A[p..q-1]中的每个元素,其中,计算下标q也是划分过程的一部分。
解决:通过递归调用快速排序,对子数组A[p..q-1]和A[q+1..r]进行排序。
合并:因为子数组都是原址排序的,所以不需要合并操作:数组A[p..r]已经有序。
通俗点讲就是把数组根据一个参照值划分为两部分,左边部分小于等于参照值,右边部分大于等于参照值,然后再不断递归调用该方法,直到数组只有一个元素,就认为其是有序的.注意:划分过程,左边部分和右边部分可以是不均衡的。
例如：
//将数组排序成满足数组左边比中间值小,右边比中间值大的方法
int partition(int arr[], int left, int right)
{
int i = left, j = right;
int tmp;
//定义参照值为数组的中间值
int pivot = arr[(left + right) / 2];
while (i <= j) {
//当arr[i]小于参照值时,符合左边小的原则,不需调换位置,直接跳过,直到找到不满足条件的A[i]时终止该循环
while (arr[i] < pivot)
i++;
//当arr[j]大于参照值时,符合右边大的原则,不需调换位置,直接跳过,直到找到不满足条件的A[j]时终止该循环
while (arr[j] > pivot)
j--;
//i小于j时,完成a[i]和a[j]的交换
if (i <= j) {
tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
i++;
j--;
} };
//返回的i就是满足i左边的值比i小.i右边的值比i大
return i;
}
void quickSort(int arr[], int left, int right) {
int index = partition(arr, left, right);
// System.out.println("index"+index);
if (left < index - 1){
quickSort(arr, left, index - 1);
// System.out.println(Arrays.toString(arr));
}
if (index < right){
quickSort(arr, index, right);
// System.out.println(Arrays.toString(arr));
}
}
@Test public void testQuickSort(){ int a[] = {222,5, 2, 4, 6, 1, 3, 11, 9, 10, 8, 7,0};
quickSort(a,0,a.length - 1);
System.out.println("最终排序结果"+Arrays.toString(a));
}
扩展资料：
快速排序（Quicksort）是对冒泡排序的一种改进。
快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
参考链接：百度百科-快速排序算法
1、快速排序算法的原理：
想必大家都学过和用过冒泡排序，这应该是大家成为程序员道路上学的第一个算法，那么我们的快速排序算法其实是在冒泡排序的基础上的一个改进，快速排序算法是利用一趟快速排序，一趟快排一般都是取第一个数作为准基数进行排序，将一串数据分成两个部分。
第一部分都比准基数小，第二部分都比准基数大。
如：（-------第一部分------准基数------第二部分------），也就这样以准基数分成了两个部分，接下来这两个部分继续使用一趟快排（可以用递归的方法），以此类推，最后数据显示是从小到大的排列顺序。
2、快速排序步骤：
我们先建立一组数据:
（1）根据一趟快排的规则，我们先定下一个准基数，通常准基数都是数据的第一位也就是这里的数字12。
（2）然后一趟快排是先从下标6向左进行和准基数12的比较，比较完一个后，然后再从下标0向右进行和准基数12的比较。
（3）我们进行比较的规则和操作是：从下标6向左进行和准基数12的比较，只要遇到的数据小于准基数12的时候我们就将这个数和准基数12进行替换，然后再执行从下标0向右进行和准基数12的比较.
如：我们从下标6向左进行和准基数12的比较，20>12，不满足一趟快排的规则，寻找下一位，1<12,所以我们将下标0的值和下标5的值进行替换替换后的结果为：
（4）执行完上一步之后，我们再从下标0向右进行和准基数12的比较，这里的规则是只要遇到的数据大于准基数12的时候我们就将这个数和准基数12进行替换，和上面一步恰恰相反。
如：我们再从下标0向右进行和准基数12的比较，30>12，所以我们将下标1的值和下标5的值进行替换。
（5）从左到右查找和从右到左的查找，都是通过下标来查找的，只要它们两者下标不相遇就可以一直进行排序，直到相遇后第一次一趟快排结束，不过，总有一次会相遇的。好了，执行完上一步之后，基本的套路也就生成了，接下来继续执行（3），（4）步骤，直到排序完成。
第一趟排序完成的结果为：
从上面第一次一趟快排结果我们可以看出从准基数那里将数据分成的两个部分，前面那一部分，1，5，5，都比准基数要小，后面的16，30，20，则比准基数要大。但是这还不算完，我们明显的看到排序并非从小到大。所以说我们需要把这整一条数据分成1，5，5和16，30，20这两个条数据再次进行一趟快排（递归），以此类推，直到排出一条规矩的数据为止。
最后的结果为：
3、快速排序代码实现：
public class QuickSort {
public static void main(String[] args) {
int arr[] = {49、38、65、97、76、13、27、49};
quickSort(arr, 0, 7);
System.out.println(Arrays.toString(arr));
}
public static void quickSort(int[] arr, int left, int right) {
if (left < right) {
int mid = partion(arr, left, right);
quickSort(arr, 0, mid - 1);
quickSort(arr, mid + 1, right);
}
}
public static void swap(int[] arr, int l, int r) {
int tmp = arr[l];
arr[l] = arr[r];
arr[r] = tmp;
}
public static int partion(int[] arr, int left, int right) {
while (left < right) {
while (left < right && arr[left] <= arr[right]) {
right--;
}
if (left<right){
swap(arr, left, right);
}
while (left < right && arr[left] <= arr[right]) {
left++;
}
if (left<right){
swap(arr, left, right);
}
}
return left;
}
}
扩展资料：
快速排序由冒泡排序演变而来，冒泡排序原理：
1、比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2、对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3、针对所有的元素重复以上的步骤，除了最后一个。
4、持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
参考资料：百度百科-快速排序
快速排序的原理：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
假设要排序的数组是A[1]……A[N]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一躺快速排序。一躺快速排序的算法是：
1）设置两个变量I、J，排序开始的时候I：=1，J：=N；
2）以第一个数组元素作为关键数据，赋值给X，即X：=A[1]；
3）从J开始向前搜索，即由后开始向前搜索（J：=J-1），找到第一个小于X的值，两者交换；
4）从I开始向后搜索，即由前开始向后搜索（I：=I+1），找到第一个大于X的值，两者交换；
5）重复第3、4步，直到I=J。
扩展资料
与普通快排不同的是，关键数据是一段buffer，首先将之前和之后的M/2个元素读入buffer并对该buffer中的这些元素进行排序，然后从被排序数组的开头（或者结尾）读入下一个元素，假如这个元素小于buffer中最小的元素，把它写到最开头的空位上；假如这个元素大于buffer中最大的元素，则写到最后的空位上。
否则把buffer中最大或者最小的元素写入数组，并把这个元素放在buffer里。保持最大值低于这些关键数据，最小值高于这些关键数据，从而避免对已经有序的中间的数据进行重排。完成后，数组的中间空位必然空出，把这个buffer写入数组中间空位。然后递归地对外部更小的部分，循环地对其他部分进行排序。
参考资料来源：百度百科—快速排序算法
冒泡、直插、选择、快速、希尔、归并排序算法进行比较
交换a[j]和a[center_index]，完成一趟快速排序。在中枢元素和a[j]交换的时候，很有可能把前面的元素的稳定性打乱，比如序列为 5 3 3 4 3 8 9 10 11，现在中枢元素5和3(第5个元素，下标从1开始计)交换就会把元素3的稳定性打乱，所以快速排序是一个不稳定的排序算法，不稳定发生在中枢元素和a...
快速排序,希尔排序和堆排序的平均时间复杂度都是O(nlog2n),为什么说...
快速排序是用递归的思想，用栈来存储数据，它第n趟最多要确定2^n个数的最终位置。它使用的空间是最多的，用空间换取了时间。例如：
冒泡排序法和快速排序比较的算法
当我为本科生讲授Quicksort算法时,许多学生即使在费了很大的努力之后,还是无法理解其中的证明过程,这令我非常沮丧。下面,我们将从Hoare的程序开11始讨论,并且最后将给出一个与他的证明很接近的分析。我们的任务是对示例2-1中的Quicksort代码进行修改,以分析在对元素值均不相同的数组进行排序时平均需要进行多少次...
数据结构的那些排序算法总是记不住,这个真的背的吗?
而非死记硬背，才是长期记忆的基石。通过实践和代码实现，你将逐渐掌握这些排序算法的精髓，让它们在处理数据时得心应手。在学习过程中，记得动手实践，比如参考GitHub上的代码示例（Sort Article - MisterBooo），在代码中体会排序算法的运作。这样，理论和实践相结合，记忆的效果将更为显著。
c++之数据排序
对左右子区间的排序与原问题一样,所以我们可以调用同样的子程序,只是区间大小不一样。各种排序算法的比较1.稳定性比较 插入排序、冒泡排序、二叉树排序、二路归并排序及其他线形排序是稳定的。 选择排序、希尔排序、快速排序、堆排序是不稳定的。2.时间复杂性比较 插入排序、冒泡排序、选择排序的时间复杂性为O(n2)...
紧急!!!有什么排序方法?各有什么特点?
4.7各种排序算法的比较1.稳定性比较 插入排序、冒泡排序、二叉树排序、二路归并排序及其他线形排序是稳定的 选择排序、希尔排序、快速排序、堆排序是不稳定的2.时间复杂性比较 插入排序、冒泡排序、选择排序的时间复杂性为O(n2) 其它非线形排序的时间复杂性为O(nlog2n) 线形排序的时间复杂性为O(n);3.辅助...
急求PASCAL优化过的快速排序
(1\/n!)。假设RANDOM(n)产生n个数的概率都相同(该假设几乎一定成立)，则随机化快速排序遇到最坏情况的可能性也为(1\/n!)。如果n足够大，我们就有多于99%的可能性会“交好运”。也就是说，随机化的快速排序算法有很高的稳定性。引自<论随机化算法的原理与设计>周咏基 ...
c++排序算法相关问题
选择法),但我们每次要进行与内层循环相同次数的‘=’操作。正常的一次交换我们需要三次‘=’ 而这里显然多了一些,所以我们浪费了时间。 最终,我个人认为,在简单排序算法中,选择法是最好的。 二、高级排序算法: 高级排序算法中我们将只介绍这一种,同时也是目前我所知道(我看过的资料中)的最快的。 它的工作看...
C语言排序
程序员可以使用5种：路插入排序（insertionsort.）路交换排序（exchangesOrt）路选择排序（selectionsort）路排序（归并）合并 路分配排序（distributionsort）为了生动地解释每个排序算法的工作原理，让我们来看看如何在桌子上，随机使用这些方法该卡支付排序。排序根据色卡只（顺序梅花，方块，红心和黑色心脏），...
为什么在平均情况下,快速排序比堆排序要优秀?
不是循序地把数据项插入到一个明确的树中，而是由快速排序组织这些数据项到一个由递归调用所隐含的树中。这两个算法完全地产生相同的比较次数，但是顺序不同。对于排序算法的稳定性指标，原地分区版本的快速排序算法是不稳定的。其他变种是可以通过牺牲性能和空间来维护稳定性的。快速排序的最直接竞争者是...
卷伏元坦： 快速排序的基本原理就是每一次把一个值放到它应该的位置上,然后序列被分为两部分,这个数前一部分后一部分,再对这两部分分别进行快速排序即可. 如此递归下去,但是对于基本有序的数列,你就不要快排了,那样效率会很低. 扩展...
江苏省14759231530： 快速排序的原理是什么 - ？
卷伏元坦： 先从数据序列中选一个元素,并将序列中所有比该元素小的元素都放到它的右边或左边,再对左右两边分别用同样的方法处之直到每一个待处理的序列的长度为1, 处理结束. 在当前无序区R[1..H]中任取一个数据元素作为比较的＂基准＂(不妨...
江苏省14759231530： 如何用java实现快速排序,简答讲解下原理 - ？
卷伏元坦： 快速排序思想: 通过对数据元素集合Rn 进行一趟排序划分出独立的两个部分.其中一个部分的关键字比另一部分的关键字小.然后再分别对两个部分的关键字进行一趟排序,直到独立的元素只有一个,此时整个元素集合有序. 快速排序的过程...
江苏省14759231530： 用C语言编程实现快速排序算法 - ？
卷伏元坦： 给个快速排序你参考参考 /********************** 快速排序 **************************** 基本思想:在待排序的n个记录中任取一个记录(通常取第一个记录), 以该记录为基准,将当前的无序区划分为左右两个较小的无 序子区,使左边的记录均小于基...
江苏省14759231530： java中快速排序的实现思路 - ？
卷伏元坦： 快速排序法:快速排序法号称是目前最优秀的算法之一,实现思路是,将一个数组的排序问题看成是两个小数组的排序问题,而每个小的数组又可以继续看成更小的两个数组,一直递归下去,直到数组长度大小最大为2
江苏省14759231530： 谁能介绍一下快速排序的算法思想. - ？
卷伏元坦： 快速排序是对起泡排序的一种改进,它的基本思想是:通过一趟排序将待排记录分割成独立的2部分,其中一部分记录的关键字均比另一部分记录的关键字小,则可分别对这两部分的记录继续进行排序,以达到整个序列有序.快速排序的平均时间是k*N*lnN,N为待排序列中记录的个数,k为某个常数.在所有同数量级(N*logN)的排序方法中,它被认为是平均性能最好的,但当序列按关键字基本有序时,将退化成冒泡排序,时间复杂度为 O(n^2)
江苏省14759231530： 快速排序方法的简单解释 - ？
卷伏元坦： 快速排序的原理和实现(纯白话文口述)看看这个博客,讲的很透彻,通俗易懂,望对你有用
江苏省14759231530： C语言的快速排序的算法是什么啊? - ？
卷伏元坦： 快速排序(Quicksort)是对冒泡排序的一种改进.由C. A. R. Hoare在1962年提出.它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数...
江苏省14759231530： C语言高效排序算法的原理及代码？
卷伏元坦： 快速排序是通过分治的思想来实现的.即找一个 中间数,让小于这个数字的放在他左边,大于这个数字的放在右边!然后逐渐放小! 以升序为例:int qsort(ArrayStule *aS,int low,int high){KeyStyle pri = aS[0];while(low <= high){while(pri < aS[high] ...
江苏省14759231530： 简单介绍一下快速排序的思想? - ？
卷伏元坦： 基本思想 快速排序(Quicksort)是对冒泡排序的一种改进.由C. A. R. Hoare在1962年提出.它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这...
