精华内容
下载资源
问答
  • 用C语言实现快速排序算法

    万次阅读 多人点赞 2016-11-04 22:33:13
    一、快速排序算法(Quicksort) 1. 定义 快速排序由C. A. R. Hoare在1962年提出。快速排序是对冒泡排序的一种改进,采用了一种分治的策略。 2. 基本思想 通过一趟排序将要排序的数据分割成独立的两部分,其中...

    一、快速排序算法(Quicksort)

    1. 定义

    快速排序由C. A. R. Hoare在1962年提出。快速排序是对冒泡排序的一种改进,采用了一种分治的策略。

    2. 基本思想

    通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。

    3. 步骤

    a. 先从数列中取出一个数作为基准数。

    b. 分区过程,将比这个数大的数全放到它的右边,小于或等于它的数全放到它的左边。

    c. 再对左右区间重复第二步,直到各区间只有一个数。

    二、C语言实现代码(仅供参考)

     

    /*****************************************************
    File name:Quicksort
    Author:Zhengqijun    Version:1.0    Date: 2016/11/04
    Description: 对数组进行快速排序
    Funcion List: 实现快速排序算法
    *****************************************************/
    
    #include <stdio.h>
    #include <stdlib.h>
    
    #define BUF_SIZE 10
    
    /**************************************************
     *函数名:display
     *作用:打印数组元素
     *参数:array - 打印的数组,maxlen - 数组元素个数
     *返回值:无
     **************************************************/
    void display(int array[], int maxlen)
    {
        int i;
    
        for(i = 0; i < maxlen; i++)
        {
            printf("%-3d", array[i]);
        }
        printf("\n");
    
        return ;
    }
    
    /************************************
     *函数名:QuickSort
     *作用:快速排序算法
     *参数:
     *返回值:无
     ************************************/
    void QuickSort(int *arr, int low, int high)
    {
        if (low < high)
        {
            int i = low;
            int j = high;
            int k = arr[low];
            while (i < j)
            {
                while(i < j && arr[j] >= k)     // 从右向左找第一个小于k的数
                {
                    j--;
                }
    
                if(i < j)
                {
                    arr[i++] = arr[j];
                }
    
                while(i < j && arr[i] < k)      // 从左向右找第一个大于等于k的数
                {
                    i++;
                }
    
                if(i < j)
                {
                    arr[j--] = arr[i];
                }
            }
    
            arr[i] = k;
    
            // 递归调用
            QuickSort(arr, low, i - 1);     // 排序k左边
            QuickSort(arr, i + 1, high);    // 排序k右边
        }
    }
    
    // 主函数
    int main()
    {
        int array[BUF_SIZE] = {12,85,25,16,34,23,49,95,17,61};
        int maxlen = BUF_SIZE;
        
        printf("排序前的数组\n");
        display(array, maxlen);
        
        QuickSort(array, 0, maxlen-1);  // 快速排序
        
        printf("排序后的数组\n");
        display(array, maxlen);
        
        return 0;
    }

     

    执行程序后的结果如下所示:

    上诉代码结合了我自己对快速排序的看法和理解,仅供参考。

     

    展开全文
  • 实现快速排序算法

    千次阅读 2019-02-14 16:39:14
    快速排序是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。 其基本思想是: 通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的...* 实现快速排序算法 * 实验目的: * ...

    快速排序是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。

    其基本思想是:

    通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。

    /**
    *    实验题目:
    *        实现快速排序算法
    *    实验目的:
    *        领会快速排序过程和算法设计
    *    实验内容:
    *        设计程序,实现快速排序算法。用相关数据进行测试,并
    *    输出各次划分后的结果。
    */

    #include <stdio.h>

    #define MAX_LEN     (100)                       //  最大长度

    typedef int key_type;                           //  定义关键字类型为int
    typedef char info_type;
    typedef struct
    {
        key_type key;                               //  关键字项
        info_type data;                             //  其他数据项,类型为info_type
    }rec_type;                                      //  查找元素的类型

    /*-----------------x和y交换------------------*/
    void swap_rec(rec_type &x, rec_type &y)         //  引用类型
    {
        rec_type tmp = x;
        x = y;
        y = tmp;
    }

    /*-----------------创建顺序表------------------*/
    void create_list(rec_type recs[], key_type keys[], int n)
    {
        int i;

        for(i = 0; i < n; i++)                      // recs[0...n-1]存放排序记录
            recs[i].key = keys[i];
    }

    /*-----------------输出顺序表------------------*/
    void disp_list(rec_type recs[], int n)
    {
        int i;

        for(i = 0; i < n; i++)
            printf("%d ", recs[i].key);

        printf("\n");
    }

    /*-----------------以下运算针对堆排序的程序------------------*/
    /*-----------------创建顺序表------------------*/
    void create_list1(rec_type recs[], key_type keys[], int n)
    {
        int i;

        for(i = 1; i <= n; i++)                     // recs[1...n]存放排序记录
        {
            recs[i].key = keys[i - 1];
        }
    }

    /*-----------------输出顺序表------------------*/
    void disp_list1(rec_type recs[], int n)
    {
        int i;

        for(i = 1; i <= n; i++)
        {
            printf("%d ", recs[i].key);
        }
        printf("\n");
    }

    /*---------------显示一趟划分后的结果--------------*/
    static void disp_partition(rec_type recs[], int s, int t)
    {
        static int i = 1;                               // 局部静态变量仅被初始化一次
        int j;

        printf("第%d次划分:", i);
        for(j = 0; j < s; j++)
            printf("   ");
        for(j = s; j <= t; j++)
            printf("%3d", recs[j].key);
        printf("\n");
        i++;
    }

    /*---------------一趟划分--------------*/
    static int partition_recs(rec_type recs[], int s, int t)
    {
        int i = s, j = t;
        rec_type tmp = recs[i];                         //  以recs[i]为基准 [6, 8, 7, 9, 0, 1, 3, 2, 4, 5]

        while(i < j)                                    //  从两端交替向中间扫描,直至i=j为止
        {
            while(i < j && recs[j].key >= tmp.key)
                j--;                                    //  从右向左扫描,找一个小于tmp.key的recs[j]
            recs[i] = recs[j];                          //  找到这样的recs[j],放入recs[i]处
            while(i < j && recs[i].key <= tmp.key)
                i++;                                    //  从左向右扫描,找一个大于tmp.key的recs[i]
            recs[j] = recs[i];                          //  找到这样的recs[i],放入recs[j]处
        }
        recs[i] = tmp;
        disp_partition(recs, s, t);

        return i;
    }

    /*---------------对recs[s...t]的元素进行递增快速排序--------------*/
    /**
    *   快速排序基本思想:
    *       通过一趟排序将要排序的数据分割成独立的两部分,
    *   其中一部分的所有数据都比另外一部分的所有数据都要小,
    *   然后再按此方法对这两部分数据分别进行快速排序,整个
    *   排序过程可以递归进行,以此达到整个数据变成有序序列。
    */
    static void quick_sort(rec_type recs[], int s, int t)
    {
        int i;

        if(s < t)                                       //  区间内至少存在两个元素的情况
        {
            i = partition_recs(recs, s, t);
            quick_sort(recs, s, i - 1);                 //  对左区间递归排序
            quick_sort(recs, i + 1, t);                 //  对右区间递归排序
        }
    }

    int main(int argc, char *argv[])
    {
        int n = 10;
        rec_type recs[MAX_LEN];
        key_type a[] = {6, 8, 7, 9, 0, 1, 3, 2, 4, 5};

        create_list(recs, a, n);
        printf("排序前: ");
        disp_list(recs, n);
        quick_sort(recs, 0, n - 1);// 0 9
        printf("排序后: ");
        disp_list(recs, n);

        return 0;
    }

    测试结果:

    排序前: 6 8 7 9 0 1 3 2 4 5
    第1次划分:  5  4  2  3  0  1  6  9  7  8
    第2次划分:  1  4  2  3  0  5
    第3次划分:  0  1  2  3  4
    第4次划分:        2  3  4
    第5次划分:           3  4
    第6次划分:                       8  7  9
    第7次划分:                       7  8
    排序后: 0 1 2 3 4 5 6 7 8 9

    展开全文
  • Python 实现快速排序算法

    千次阅读 2019-04-08 00:04:14
    快速排序算法如下: 从数列中挑出一个元素,称为"基准"(pivot), 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区结束之后,该...

    快速排序(Quick sort)

    快速排序(Quick sort),又称划分交换排序

    • 快速排序算法如下:
      • 从数列中挑出一个元素,称为"基准"(pivot),
      • 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区结束之后,该基准就处于数列的中间位置。这个称为分区(partition)操作。
      • 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序
    • 时间复杂度:
      • 最优时间复杂度:O(nlogn)
        • 最坏时间复杂度:O(n2)
        • 稳定性:不稳定
      • 代码实现如下:
    #!/usr/bin/python
    # coding=utf-8
    def quick_sort(a_list, start, end):
        """快速排序"""
        if start >= end:
            return
        # 定义一个基准
        mid = a_list[start]
        left = start
        right = end
    
        # 如果left与right未重合, left就向中间(右)移动
        while left < right:
            while left < right and a_list[right] >= mid:
                right -= 1
            a_list[left] = a_list[right]
            while left < right and a_list[left] < mid:
                left += 1
            a_list[right] = a_list[left]
        # 从循环退出后, left与right相遇, 即 left==right
        a_list[left] = mid
    
        # 用递归对左边部分执行快速排序
        quick_sort(a_list, start, left-1)
    
        # 用递归对右边部分执行快速排序
        quick_sort(a_list, left+1, end)
    
    
    if __name__ == '__main__':
        li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
        print(li)
        quick_sort(li, 0, len(li)-1)
        print(li)
    
    
    # 输出结果:
    排序前: [54, 26, 93, 17, 77, 31, 44, 55, 20]
    排序后: [17, 20, 26, 31, 44, 54, 55, 77, 93]
    展开全文
  • Java实现快速排序算法

    千次阅读 2018-07-15 21:35:44
    快速排序算法的思想是:在数组中选取一个数(一般都是选第一个数),分别与其它的每一个数比较,把比这个数小的数放到它的前面,比他大的数放到它的后面,此时数组分成两部分,该数前面的都比它小,后面的都比它大,...

    快速排序算法的思想是:在数组中选取一个数(一般都是选第一个数),分别与其它的每一个数比较,把比这个数小的数放到它的前面,比他大的数放到它的后面,此时数组分成两部分,该数前面的都比它小,后面的都比它大,然后分别对这两部分递归排序算法,就可以实现整个数组的排序。

    public static void main(String[] args) {
    	
    	    int [] arr = {65,58,95,10,57,62,13,106,78,23,85};
    	    System.out.println("排序前:"+Arrays.toString(arr));
    	    quickSort(arr,0,arr.length-1);
    	    System.out.println("排序后:"+Arrays.toString(arr));
    		
    	}
    	
    	public static void quickSort(int [] arr,int left,int right) {
    	      int pivot = 0;
    	      if(left < right) {
    	         pivot = partition(arr,left,right);
    	         quickSort(arr,left,pivot-1);
    	         quickSort(arr,pivot+1,right);
    	      }
    	   }
    	
    	private static int partition(int[] arr,int left,int right) {
    
    	      int key = arr[left];
    	      while(left < right) {
    	         while(left < right && arr[right] >= key) {
    	            right--;
    	         }
    	         arr[left] = arr[right];
    	         while(left < right && arr[left] <= key) {
    	            left++;
    	         }
    	         arr[right] = arr[left];
    	      }
    	      	 arr[left] = key;
    	         return left;
    
    	   }
    	

    解析如下:

                                        

    此上过程是完成了一次排序partition()方法返回int类型的leftarr[left]将整个数组分成了两部分,左边的部分都比它小,右边的部分都比它大。然后运用递归的方法,分别对左边的数组部分和右边的部分重复上面的操作,最终可以实现数组的排序。




    参考:http://blog.51cto.com/13733462/2113397

    展开全文
  • PHP实现快速排序算法

    千次阅读 2018-08-18 18:06:14
    //快速排序算法 //创建数组并打乱数组 $arr = range(1,20); shuffle($arr); function QuickSort($arr = array()) { $size = sizeof($arr); if ($size&lt;=1) { //如果数组大小小于等于1返回该数组 re...
  • 快速排序算法

    万次阅读 多人点赞 2019-01-11 21:09:08
    但是这种算法时间复杂度高,当需要排序的元素较多时,程序运行时间很长,因此产生了快速排序算法。该算法的实现可分为以下几步: 1. 在数组中选一个基准数(通常为数组第一个); 2. 将数组中小于基准数的数据移到...
  • 快速排序算法——C/C++

    万次阅读 多人点赞 2019-06-12 22:55:14
    快速排序 1、算法思想 快速排序的基本思想:通过一趟排序将待排记录分隔成独立的两部分,其中一部分记录的关键字均比另一部分的关键字小,则可分别对这两部分记录继续进行排序,以达到整个序列有序。 2、实现原理 ...
  • Python实现快速排序算法

    千次阅读 2018-09-18 19:17:27
    快速排序也是使用了分治思想的排序方法,但与归并排序不一样的是“分”的时候的依据。归并排序“分”的依据是对半分,不管大小,而快速排序则是选定数组中的一个值,以这个值为依据,将数组分为三个部分:小于这个值...
  • 用python实现快速排序算法

    万次阅读 2017-04-18 00:05:04
    本文主要介绍用python实现基本的快速排序算法,体会一下python的快排代码可以写得多么简洁。
  • 快速排序算法的Python实现

    千次阅读 2018-01-17 14:41:07
    快算排序算法,快速排序算法的python实现,Python实现款速排序算法
  • 图解java实现快速排序算法

    千次阅读 2018-02-07 16:53:39
    冒泡排序算法,解决了桶排序浪费空间的问题,但在算法的执行效率上却牺牲了很多,它的时间复杂度达到了O(N2)。假如我们的计算机每秒钟可以运行10亿次,那么对1亿个数进行排序,桶排序则只需要0.1秒,而冒泡排序则...
  • 排序算法系列:快速排序算法

    万次阅读 多人点赞 2016-03-01 15:40:07
    概述  在前面说到了两个关于交换排序的算法:冒泡排序与奇偶排序。... 本文就其原理、过程及实现几个方面讲解一下快速排序算法。 版权声明 著作权归作者所有。 商业转载请联系作者获得授权,...
  • 分治法实现快速排序算法

    千次阅读 2014-11-24 17:13:10
    * 随机产生20个数,并对其进行快速排序 * * @author 刘永浪 * */ public class Quick { /** * 交换函数,实现数组中两个数的交换操作 * * @param array * 待操作数组 * @param i * 交
  • c++实现快速排序算法

    千次阅读 2019-01-16 15:09:32
    #include &lt;unistd.h&gt; #include &lt;stdio.h&gt; using namespace std; void quickSort(int arr[], int left, int right) { if (left &gt; right) { return;... int bas...
  • c语言实现快速排序算法

    千次阅读 2011-12-15 14:50:38
    值得注意的是,快速排序不是一种稳定的排序算法,也就是说,多个相同的值的相对位置也许会在算法结束时产生变动。  一趟快速排序的算法是:  1)设置两个变量I、J,排序开始的时候:I=0,J=N-1;
  • (1)针对插入排序、归并排序和快速排序算法,编写完整程序实现三种排序算法。 (2)采用随机生成测试用例的方法生成三组算法测试数据集。三组测试数据集的规模分别是:20000个数据、50000个数据、200000个数据。 ...
  • C语言实现数组快速排序算法

    万次阅读 2015-02-26 10:53:01
    C语言实现数组快速排序算法 快速排序算法,顾名思义,是迄今为止发现的速度最快的排序算法。快速排序算法采用分治的思想,首先在要排序的序列{5,8,7,6,4,3,9}中选取一个基准数(一般选取序列的第一个,其实选取哪个...
  • 快速排序算法的C++实现

    千次阅读 2018-08-22 17:24:03
    关于快速排序算法的介绍可以参看此篇博客:...下面就介绍一下毛毛利用栈来实现快速排序算法,代码只为验证算法功能,并不保证没有bug。闲话少说,先上代码。 #include &lt;st...
  • 用java实现快速排序算法

    万次阅读 2019-01-20 10:26:30
    问题在于当我们先从在边开始时,那么 i 所停留的那个位置肯定是大于基数6的,而在上述例子中,为了满足 i于是 j也停留在7的位置 但最后交换回去的时候,7就到了左边,不行,因为我们原本 交换后数字6在边应该是全部...
  • 经典算法(4)图解快速排序算法及代码实现

    万次阅读 多人点赞 2019-11-03 11:26:31
    很多软件公司的笔试和面试,像腾讯,微软等知名IT公司都喜欢考这个,还有大大小的程序方面的考试如软考,考研中也常常出现快速排序的身影。这篇博客用图解的形式对快速排序过程做了说明,并且有完整的代码实现
  • 快速排序算法javascript实现

    万次阅读 多人点赞 2018-06-22 19:00:22
    相比较传统做法用嵌套循环排序,时间复杂度由O(n^2)变为O(logn),当问题规模n变大的时候,就能体现快速排序算法的效率了。2、快速排序的数学计算步骤假设我们对T = [6,1,2,7,9,3,4,5,10,8]数组进行快速排序。(1)、...
  • 快速排序算法java版实现

    千次阅读 2017-06-02 16:19:11
    本文使用java实现快速排序
  • 快速排序算法python实现

    千次阅读 2020-02-01 15:02:50
    快速排序 快速排序是一种递归调用的方法,思想是根据一个基准值,将数组比基准值小的放在左边,比基准值大的放在右边。运用了分而治之的思想,最后将三部份合并即可得到最终的有序数组 代码实现: def quickSort(arr...
  • 快速排序算法C语言实现

    千次阅读 2017-10-01 21:34:56
    背景:在了解快速排序算法之前,先了解一下它的背景。快速排序算法是冒泡排序的改进,它大大优化了算法的时间复杂度,当然,它并不是总具备优势。 基本思想:快速排序算法的基本思想可以总结为分治和递归。冒泡排序...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 204,864
精华内容 81,945
关键字:

为了实现快速排序算法