快速排序算法

快速排序的基本思想是:通过一趟排序将待排记录分割成独立的两部分,其中一部分记录的关键字均比另一部分关键字小,则可分别对这两部分记录继续进行排序,以达到整个序列有序的目的。

稳定性:快速排序是不稳定的排序

时间复杂度: 最好:O(nlogn)   最差:O(n^2)  辅助空间:O(logn) ~ O(n)

/* 快速排序算法 */
#include <cstdio>

/* 对给定的闭区间进行快速排序 */
void QSort(int* L, int low, int high){
    if (low < high){
        int fst = low, lst = high;
        int key = L[fst]; //这样fst位置就空出来了
        while (fst < lst){
            //从后半部分找小于key的值放到前面
            while (fst < lst && L[lst] >= key)
                --lst;
            //循环结束后lst位置即为小于key的地方
            L[fst] = L[lst]; //这样lst位置就空出来了
            //从前面找大于key的数放到后面
            while (fst < lst && L[fst] <= key)
                ++fst;
            L[lst] = L[fst]; //这样fst又空出来了
        }
        L[fst] = key; //枢轴记录到位
        QSort(L, low, fst - 1);
        QSort(L, fst + 1, high);
    }
}

/* 对给定的左闭右开区间进行排序 --- 指针法 */
void QSort(int* low, int* high){
    //high - low = 1表示只有一个元素无须排序
    if (high - low > 1){
        int* fst = low; //首元素
        int* lst = high - 1; //尾元素
        int key = *fst; //fst空出来了
        while (fst < lst){
            //从后面找比key小地元素放到前面
            while (fst < lst && *lst >= key)
                --lst;
            *fst = *lst;
            //从前面找比key大的元素放到后面
            while (fst < lst && *fst <= key)
                ++fst;
            *lst = *fst;
        }
        *fst = key; //枢轴记录到位
        QSort(low, fst); //递归排序左闭右开区间
        QSort(fst + 1, high); //递归排序左闭右开区间
    }
}

/* 快速排序 --- 指针法降序版 左闭右开区间 */
void QSort2(int* low, int* high){
    if (high - low > 1){
        int* fst = low;
        int* lst = high - 1;
        int key = *fst; //fst位置空出来
        //由于是降序,则比key大的放前面,比key小的放后面
        while (fst < lst){
            //从后面找比key大的放前面
            while (fst < lst && *lst <= key)
                --lst;
            *fst = *lst; //这样lst空出来了
            //从前面找比key小地放后面
            while (fst < lst && *fst >= key)
                ++fst;
            *lst = *fst; //fst空出来
        }
        *fst = key; //枢轴记录到位
        QSort2(low, fst); //递归排序左闭右开区间
        QSort2(fst + 1, high); //递归排序左闭右开区间
    }
}

int main()
{
    //int a[10] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
    int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    QSort2(a, a+5);
    for (int i = 0; i < 10; ++i){
        printf("%d ", a[i]);
    }//for(i)

    return 0;
}

时间: 2024-11-23 21:40:17

快速排序算法的相关文章

快速排序算法小结

         快速排序是对冒泡排序的一种改进.它的基本思想是:通过一躺排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一不部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列.          假设要排序的数组是a[6],长度为7,首先任意选取一个数据(通常选用第一个数据)作为关键数据,然后将所有比它的数都放到它前面,所有比它大的数都放到它后面,这个过程称为一躺快速排序.一躺快速排序的算法是: 1).设

排序算法之 Java简单快速排序算法

package net.qh.test.sort; import java.util.ArrayList; import java.util.Calendar; import java.util.List; /** * Created by Administrator on 2016/03/01. */ public class SimpleQuick { public int[] sort(int[] arr,int left,int right){ if ( arr == null || a

关于快速排序算法(一个90%的人都不懂其原理、99.9%的人都不能正常写出来的算法.)

一.奇怪的现象 研究快速排序很久了,发现一个古怪的实情:这算法描述起来很简单,写一个正确的出来实在不容易.写一个优秀的快速排序算法更是难上加难. 也难怪该算法提出来过了很久才有人写出一个正确的算法,过了很久才优秀的版本出来. 二.原理描述 从数列中挑出一个元素,称为 "基准"(pivot), 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边).在这个分区退出之后,该基准就处于数列的中间位置.这个称为分区(partition)操作

排序算法--快速排序算法解析

一.快速排序算法思路 ①.取待排序列表的第一个元素p,通过归位算法,挪移他到列表中正确的位置. ②.列表被元素p分成两部分,左边都比元素p小,右边都比元素p大. ③.通过递归,在两部分,重复1.2步骤,直至列表有序. 归位算法动画演示: 二.快速排序算法代码示例 1 def partition(l,left,right):#归位算法 2 temp = l[left] #保存归位元素 3 while left <right: 4 while l[right]>=temp and left<

三路快速排序算法

1.三路快速排序算法的基本思想 之前的快速排序算法都是将序列分成<=v和>v或者是<v和>=v的两个部分,而三路快速排序是将序列分成三个部分: <v.=v.>v,如下图所示: 首先v元素还是作为"基准"元素,e表示当前遍历索引值指向的元素,也就是待考虑的元素,从图中可以看出来,整个序列被分成 3个部分,也就是说当我们遍历完成之后整个序列就已经被分成了<v.=v.>v三个部分了,而我们只需要对<v和>v的两个部分 再次递归调用三

C# 集合扩展快速排序算法

/// <summary> /// 对集合进行排序,如 /// List<Person> users=new List<Person>(){.......} /// ListSorter.SortList<list<Person>,Person>( users,"Age",SortDirection.Ascending); /// </summary> public static class ListUtil {

归并与快速排序算法对处理同等规模的数据的对比

用长分别为100.200.300.400.500.600.700.800.900.1000的10个数组的排列来统计这两种算法的时间复杂性: 快速排序程序: #include<iostream> using namespace std; int circle; static int num[11]={0,0,0,0,0,0,0,0,0,0,0}; void vector_initial(int *array,int n); void vector_print(int *array,int n);

用函数指针实现的快速排序算法

K&R第五章介绍了用函数指针实现的快速排序算法,对其中的代码比较困惑,所以看了下<算法导论>上对快排的介绍.归纳算法如下: 设每次遍历的最左边为low, 最右边为high,数组名为a: 1.每次以最左边的数a[low]为基准数(pivot),从左边第二个数(a[low+1])开始遍历,维护一个i -->j的数列,这些数都比pivot大,直到j到达最右边(high). 2.此时,i -->high之间的数都比pivot大,low+1 --> i-1之间的数都比pivot

快速排序算法的两个写法

快速排序作为应用比较广泛,而且时间复杂度比较优越的排序算法备受大家的喜爱.最近有点悠闲,就又把这个快速算法研究了一遍,目前掌握了两种排序算法的思路,为了以免忘记,故详细的记录下来,也供大家学习借鉴,不足之处望请指教. 快速排序的基本原理: 假设一个待排序的数组如上图所示,排序的目的就是将其从小到大排序.快速排序的主要步骤就是设定一个待排序的元素(称作主元,记作temp),经过一轮划分排序后在这个主元左边的元素值都小于它,在主元右边的元素值都大于它,一轮划分后的效果应该是这样的,如下图: 这样以t