精华内容
下载资源
问答
  • C++ sort排序函数用法

    万次阅读 多人点赞 2017-07-27 21:35:06
    最近在刷ACM经常用到排序,以前老是写冒泡,可把冒泡带到OJ里后发现经常超时,所以本想用快排,可是很多学长推荐用sort函数,因为自己写的快排写不好真的没有sort快,所以毅然决然选择sort函数 用法 1、sort函数...

    最近在刷ACM经常用到排序,以前老是写冒泡,可把冒泡带到OJ里后发现经常超时,所以本想用快排,可是很多学长推荐用sort函数,因为自己写的快排写不好真的没有sort快,所以毅然决然选择sort函数

    用法

    1、sort函数可以三个参数也可以两个参数,必须的头文件#include < algorithm>和using namespace std;
    2、它使用的排序方法是类似于快排的方法,时间复杂度为n*log2(n)

    3、Sort函数有三个参数:(第三个参数可不写)

    (1)第一个是要排序的数组的起始地址。

    (2)第二个是结束的地址(最后一位要排序的地址)

    (3)第三个参数是排序的方法,可以是从大到小也可是从小到大,还可以不写第三个参数,此时默认的排序方法是从小到大排序。

    两个参数用法

    #include <iostream>
    #include <algorithm>
    int main()
    {
     int a[20]={2,4,1,23,5,76,0,43,24,65},i;
     for(i=0;i<20;i++)
      cout<<a[i]<<endl;
     sort(a,a+20);
     for(i=0;i<20;i++)
     cout<<a[i]<<endl;
     return 0;
    }
    

    输出结果是升序排列。(两个参数的sort默认升序排序)


    三个参数

    // sort algorithm example
    #include <iostream>     // std::cout
    #include <algorithm>    // std::sort
    #include <vector>       // std::vector
    
    bool myfunction (int i,int j) { return (i<j); }//升序排列
    bool myfunction2 (int i,int j) { return (i>j); }//降序排列
    
    struct myclass {
      bool operator() (int i,int j) { return (i<j);}
    } myobject;
    
    int main () {
        int myints[8] = {32,71,12,45,26,80,53,33};
      std::vector<int> myvector (myints, myints+8);               // 32 71 12 45 26 80 53 33
    
      // using default comparison (operator <):
      std::sort (myvector.begin(), myvector.begin()+4);           //(12 32 45 71)26 80 53 33
    
      // using function as comp
      std::sort (myvector.begin()+4, myvector.end(), myfunction); // 12 32 45 71(26 33 53 80)
        //std::sort (myints,myints+8,myfunction);不用vector的用法
        
      // using object as comp
      std::sort (myvector.begin(), myvector.end(), myobject);     //(12 26 32 33 45 53 71 80)
    
      // print out content:
      std::cout << "myvector contains:";
      for (std::vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)//输出
        std::cout << ' ' << *it;
      std::cout << '\n';
    
      return 0;
    }
    

    string 使用反向迭代器来完成逆序排列

    #include <iostream>
    using namespace std;
    int main()
    {
         string str("cvicses");
         string s(str.rbegin(),str.rend());
         cout << s <<endl;
         return 0;
    }
    //输出:sescivc
    
    展开全文
  • 排序函数

    千次阅读 2019-01-27 17:10:43
    sort()函数是对给定区间的元素进行排序,但是会改变值相同的元素的相对位置。stable_sort()是对给定区间的元素进行稳定排序,如果两个元素相等,那么排序完成后两个元素的相对位置保持不变,partial_sort()是对给定...

    sort函数有sort(),stable_sort()和partial_sort()。sort()函数是对给定区间的元素进行排序,但是会改变值相同的元素的相对位置。stable_sort()是对给定区间的元素进行稳定排序,如果两个元素相等,那么排序完成后两个元素的相对位置保持不变,partial_sort()是对给定区间的元素进行部分排序。默认的顺序是由小到大进行排序。

    三种函数的用法如下

    v为容器

    sort(v.begin(),v.begin()+4,comp);

    sort(v.begin(),v.end(),comp);

    stable_sort(v.begin(),v.end(),comp)

    stable_sort的用法与sort类似

    partial_sort(v.begin(),v.begin()+4,v.end());

    partial_sort(v.begin(),v.begin()+4,v.end(),comp);

    展开全文
  • 本篇文章讲解三个高级排序算法,分别为希尔排序、归并排序、快速排序。虽然它们的思想很复杂,但真的运用得非常得巧妙,我会用丰富的例子以及动图来让大家轻松地理解并掌握。

    本系列文章【数据结构与算法】所有完整代码已上传 github,想要完整代码的小伙伴可以直接去那获取,可以的话欢迎点个Star哦~下面放上跳转链接

    本篇文章来讲解一下更高级的排序算法,顾名思义,它们的排序思想一定更复杂,效率也一定比简单排序更高。为了更方便地理解高级排序算法,还是建议大家先把简单排序了解清楚,因为高级排序也多少借鉴了简单排序的思想,下面放上文章链接

    【数据结构与算法】简单排序(冒泡排序、选择排序、插入排序)完整思路,并用代码封装排序函数

    那么就让我们来了解一下三种高级排序算法吧

    一、希尔排序

    希尔排序是插入排序的改进版本,弥补了插入排序在某些情况下的缺点。

    例如,当长度为100的数组,前面有序区域的数组长度为80,此时我们用第81个数去跟前面有序区域的所有元素比较大小,但恰巧第81个数又是这100个数里最小的,它本应该在索引为1的位置,如图所示

    在这里插入图片描述
    本例中第81个数据的值为1,那么前面有序区域里的80个元素都要往后移动一个位置,这种情况就非常影响排序性能。

    因此,我们就要想办法尽可能早点让小的值靠前,让大的值靠后,这样就能避免上述情况了,这就是希尔排序要解决的问题。

    希尔排序也叫做缩小增量排序,它通过先设置一个增量n,大小为数组长度的一半,将间隔为n的元素视作一个组,然后对每个组内部的元素进行从小到大进行插入排序;然后再将增量n缩小一半,再次进行分组插入排序,直到增量n为1,因为增量为1的时候,所有的元素都为同一个组了


    为了方便大家理解,我用一个例子来展示一个完整的希尔排序过程,首先数据的初始状态如图所示,这里为了更好地体现希尔排序的优点,我特地把值较大的元素放到了靠左的位置,把值较小的元素放到了靠右的位置

    在这里插入图片描述
    该数组长度为8,因此我们设置初始的增量为 8 / 2 = 4,那么该数组的分组情况如下图所示:

    在这里插入图片描述
    图中颜色相同的元素为一组,每组内的各个元素间隔都为4,现在对每个组内进行从小到大排序,排序结果如下图所示:

    在这里插入图片描述
    此时我们将增量缩小一半,即 4 / 2 = 2,同样的,现在将所有元素重新组合,把所有间隔为2的元素视作一组,分组结果如下图所示:

    在这里插入图片描述

    图中颜色相同的元素为一组,每组内的各个元素间隔都为2,现在对每个组内进行从小到大排序,排序结果如下图所示:

    在这里插入图片描述
    我们继续将增量缩小一半,即 2 / 2 = 1,同样的,现在将所有元素重新组合,把所有间隔为1的元素视作一组,此时所有的元素都为同一组了,就相当于对所有的数据进行普通的插入排序,我们可以看到,对比最开始的数据,总得来说,小的值都比较靠左了,大的值也都比较靠右了,这样排序起来效率就很高了。结果如下图所示:

    在这里插入图片描述

    接下来用一个动图,演示一下完整的希尔排序全过程

    在这里插入图片描述
    了解完了希尔排序的实现过程,我们现在用代码来封装一下

    function shellSort(arr) {
        // 1. 获取数组长度
        let length = arr.length
    
        // 2.获取初始的间隔长度
        let interval = Math.floor(length / 2)
    
        // 3. 不断地缩小间隔的大小,进行分组插入排序
        while(interval >= 1) {
    
            // 4. 从 arr[interval] 开始往后遍历,将遍历到的数据与其小组进行插入排序
            for(let i = interval; i < length; i++) {
                let temp = arr[i]
                let j = i
                while(arr[j - interval] > temp && j - interval >= 0) {
                    arr[j] = arr[j - interval]
                    j -= interval 
                }
    
                arr[j] = temp           
            }
    
            // 5. 缩小间隔
            interval = Math.floor(interval / 2)
        }
    
        return arr
    }
    

    来用刚才举得例子来验证一下我们封装的希尔排序是否正确

    let arr = [63, 76, 13, 44, 91, 8, 82, 3]
    let res = shellSort(arr)
    console.log(res)
    /* 打印结果
    [3, 8, 13, 44, 63, 76, 82, 91]
    */
    

    上述情况中,希尔排序最坏情况下的时间复杂度为O(n²)。其实希尔排序的时间复杂度跟增量也有关系,我们上面是通过数组长度一直取一半获取的增量,其实还有一些别的增量规则,可以使得希尔排序的效率更高,例如Hibbard增量序列Sedgewick增量序列,本文就不对这两种增量做过多的讲解了,大家可以去网上搜索一下。

    二、归并排序

    归并排序的实现是使用了一种分而治之的思想,即将一个数组不断地通过两两分组的方式进行比较大小,最后直到所有元素都被分到一组里,那自然就是整体有序的了。

    我们来看一下归并排序的主要思路,首先有如下图所示排列的一组数据:

    在这里插入图片描述
    首先从左往右,每两个元素视为一组,组合前要分别判断一下这两个元素的大小,小的在左,大的右,如图所示

    在这里插入图片描述
    继续再取两个元素组成一组并比较大小,如图所示:

    在这里插入图片描述
    继续上一个步骤,如图所示:

    在这里插入图片描述
    此时,原数组的所有元素都被两两分组完毕了,现在整个数组的长度变成了3,如下图所示:

    在这里插入图片描述
    此时,我们要重新从左向右,每次取两个元素组成一组,同时分别比较两个元素内的所有子元素的大小,因为此时的两个元素内部是有序的,所以我们比较两者大小的话,只需要每次比较数组的第一个元素即可,过程如下图所示:

    在这里插入图片描述
    此时原数组中只剩下一个元素了,所以就不对其做任何组合处理了,此时的数组是这样的:

    在这里插入图片描述
    此时的数组内只有两个元素了,所以我们只需要不断比较两个元素内部的子元素大小,即可获得完整的有序数组了,过程如下图所示:

    在这里插入图片描述
    这就是一个完整的归并排序的过程,接下来我们用代码来实现一下吧

    function mergeSort(arr) {
        
        // 将所有元素不断地两两组合,直到所有元素都被组合成一个组
        while(arr.length > 1){
            // 获取一下遍历前的数组长度,方便下面判断需要组合几次
            let length = arr.length
            
            // 创建空的新数组,用于存放所有组合后的元素
            let next_arr = []
            
            // 取两个元素进行组合,一共取 length / 2 次
            for(let i = 0; i < Math.floor(length / 2); i++){
                // 取出第一个元素
                let left = [].concat(arr.shift())
                // 取出第二个元素
                let right = [].concat(arr.shift())
                // 创建另一个新的空数组,用于存放组合后的所有元素
                let new_arr = []
    
                // 取两个数组中头部最小的值放到新数组中,直到一个数组为空
                while(left.length > 0 && right.length > 0){
                    let min = left[0] > right[0]? right.shift() : left.shift()
                    new_arr.push(min)
                }
                // 将合并好的数组添加到新的数组中
                next_arr.push(new_arr.concat(left.length == 0? right : left))
            }
            // 判断是否有一个未成组的数组
            if(arr.length == 1) next_arr.push(arr[0]);
            
            // 将所有组合后的元素构成的新数组作为下一次遍历的对象
            arr = next_arr
        }
    
        // 返回完整有序数组
        return arr[0]
    }
    

    我们来使用一下该方法,看看是否正确,为了方便大家理解,我在归并排序的函数里加了一条打印的代码,可以看到每次遍历后的数组情况,结果如下

    let arr = [19, 97, 9, 17, 1, 8]
    mergeSort(arr)
    
    /* 打印结果:
    第一次组合后:[ [ 19, 97 ], [ 9, 17 ], [ 1, 8 ] ]
    第二次组合后:[ [ 9, 17, 19, 97 ], [ 1, 8 ] ]
    第三次组合后:[ [ 1, 8, 9, 17, 19, 97 ] ]
    */
    

    查看代码我们不难发现,归并排序运行起来非常得占内存,因为在组合的过程中,我们不断得在创建新的数组,然后又进行合并。但其比较次数却非常得少,只在每次合并元素时进行比较,因此归并排序的效率还是非常得高的。

    三、快速排序

    快速排序相信大家一定不陌生,就算没用过也一定听过,拥有这么大的名声,那么它的排序效率一定很高。而且快速排序也是面试中经常会被问到的,可能会让你当场手写哦~所以大家一定要掌握它的核心思想

    快速排序也用到了分而治之的思想,它的实现思路非常得有意思:

    1. 先选一个元素作为基点pivot
    2. 将其余元素中所有比pivot小的值放到pivot的左边;将所有比pivot大的值放到pivot的右边
    3. 然后分别对pivot左边的所有元素、pivot右边的所有元素从步骤1开始排序依次,直到所有元素完整有序

    思路看着很简单,那么我们来用一个例子具体看一下快速排序的全过程吧

    首先有这样一组数据,如下图所示:

    在这里插入图片描述
    首先我们要选取一个元素作为基点pivot,最后排序完后,pivot左边的所有元素都是小于pivot的,右边的所有元素都是大于pivot的,因此我们希望的是尽量是两边平均一下,所以这里将采用一种方式寻找到一个大概的中点,即取数组两头的索引,分别为left 、right,再取一个中点 center,结果如下图:

    在这里插入图片描述

    然后在这三个元素中找到一个中等大小的值,并将其放到数组的开头位置,如下图所示:

    在这里插入图片描述

    到此,我们就可以将该数组的第一个元素作为此次遍历的基点pivot了,同时,我们将引入两个指针,即 ij,分别指向 left 和 right,如图所示

    在这里插入图片描述

    接下来就可以进行遍历了,这里我们把遍历过程称为填坑法,因为现在我们取到了数组的第一个值为pivot,所以可以假设这个位置上没有元素了,留了一个坑,需要我们将别的元素填进来。所以我们要从指针 j 开始往右寻找到一个比pivot小的值,若找到了,则将找到的值填到坑里,但要注意的是,指针 j 不能找到 指针 i 的左边去,即当指针 j 与 指针 i 重合时就停止移动。

    过程如下图所示:

    在这里插入图片描述

    此时我们可以看到,指针 j 找到了一个小于pivot的值 8,并将找到的值填到了坑里,那么此时指针 j 所指向的位置就留下了一个坑,又需要别的元素来填坑,所以此时我们就要让指针 i 向右找一个大于pivot的值,并将值填到坑里,同样的,指针 i 也不能找到指针 j 的右边,即当指针 i 与 指针 j 重合时就停止移动。

    过程如下图所示:

    在这里插入图片描述

    指针 i 找到了一个大于pivot的值 97 并将其填到了坑里,此时指针 i 所在的位置就留下了一个坑,因此我们又要让指针 j 往左找小于pivot的值并填到坑里,过程如图所示:

    在这里插入图片描述

    紧接着,指针 i 又要向右找大于pivot的值,但是移动了两个位置都没有找到,并且此时指针 i 指针 j 重合了,此时我们只需要将pivot填入到坑里就实现了pivot左边的所有元素小于它,右边所有的元素都大于它了,如图所示:

    在这里插入图片描述

    接下来的操作,就是我们要单独对此时pivot的左边所有元素和右边的所有元素进行上述的一系列操作,就可以实现快速排序了。本例中的左右两边区域的元素个数都是小于等于3个的,因此直接将这几个值互相进行比较大小比较方便,过程如下图:

    在这里插入图片描述

    了解了快速排序的实现思路,我们来用代码来实现一下

    function quickSort(arr) {
        // 两个数据进行交换
        function exchange(v1, v2) {
            let temp = arr[v1]
            arr[v1] = arr[v2]
            arr[v2] = temp
        }
        
        // 找到相对合适的元素放到数组索引为0的位置作为基点pivot
        function init(left, right) {
            let center = Math.floor((left + right) / 2)
    
            // 比较索引为left、center、right三个值的大小,从小到大排列
            if(arr[left] > arr[right]) exchange(left, right)
            if(arr[center] > arr[right]) exchange(center, right)
            if(arr[left] > arr[center]) exchange(left, center)
    
            // 判断数组长度是否大于3,若小于3,则数组已经排序好了,不需要做任何处理
            if(right - left > 2) exchange(left, center)
        }
    
        function quick(left, right) {
            init(left, right)
            // 若数组长度小于等于2,则不需要做任何操作了,因为init函数已经排序好了
            if(right - left <= 2) return;
            
            // 创建指针i和j,分别指向left和right
            let i = left
            let j = right
            // 将该数组区域的第一个元素作为基点pivot
            let pivot = arr[i]
    
            // 不断让指针i和j寻找合适的值填坑,直到两个指针重合
            while(i < j) {
                // 指针j不断向左找小于pivot的值,但指针j不能找到指针i的左边
                while(arr[j] > pivot && j > i) {
                    j --
                }
                // 将找到的小于pivot的值填到指针i所指向的坑中
                arr[i] = arr[j]
    
                // 指针i不断向右找大于pivot的值,但指针i不能找到指针j的右边
                while(arr[i] < pivot && i < j) {
                    i ++
                }
                // 将找到的大于pivot的值填到指针j所指向的坑中
                arr[j] = arr[i]
            }
    
            // 将pivot填到指针i和指针j共同指向的坑中
            arr[i] = pivot
    
            // 对此时pivot的左边所有元素进行快排
            quick(left, i - 1)
            // 对此时pivot的右边所有元素进行快排
            quick(i + 1, right)
        }
    
        quick(0, arr.length - 1)
    
        return arr  
    }
    

    我们可以简单来验证一下快速排序的正确性

    let arr = [19, 97, 9, 17, 8, 1]
    console.log(quickSort(arr))
    /* 打印结果为:
    	[1, 8, 9, 17, 19, 97]
    */
    

    四、结束语

    排序算法中的高级排序(希尔排序、归并排序、快速排序)就已经讲完啦,下一篇文章为动态规划

    大家可以关注我,之后我还会一直更新别的数据结构与算法的文章来供大家学习,并且我会把这些文章放到【数据结构与算法】这个专栏里,供大家学习使用。

    然后大家可以关注一下我的微信公众号:前端印象,等这个专栏的文章完结以后,我会把每种数据结构和算法的笔记放到公众号上,大家可以去那获取。

    或者也可以去我的github上获取完整代码,欢迎大家点个Star

    我是Lpyexplore,一个因Python爬虫而进入前端的探索者。创作不易,喜欢的加个关注,点个收藏,给个赞~

    展开全文
  • Python3 list 排序函数详解

    万次阅读 多人点赞 2018-05-28 18:55:03
    Python3 list 排序函数详解 一、列表的sort排序函数 函数原型: list.sort(key=None,reverse=False) 函数功能: 对原列表进行排序,完成排序后,原列表变为有序列表。默认情况(不传入任何参数时)按字典顺序...

    Python3 list 排序函数详解

    一、           列表的sort排序函数

    函数原型:

             list.sort(key=None,reverse=False)

    函数功能:

    对原列表进行排序,完成排序后,原列表变为有序列表。默认情况(不传入任何参数时)按字典顺序排序。

    函数参数:

    (1)     key: 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中。指定可迭代对象中的一个元素来进行排序指定排序时使用的单个元素或多个元素、lambda表达式;

    (2)     reverse:指字排序规则是升序还是降序,默认为升序排序;

    二、           排序示例

    1.      字符串排序

    def list_sort_string():
        list=["delphi","Delphi","python","Python","c++","C++","c","C","golang","Golang"]
        list.sort() #按字典顺序升序排列
        print("升序:",list)
    
        list.sort(reverse=True) #按降序排列
        print("降序:",list)

     

    排序结果:

     

    升序: ['C', 'C++', 'Delphi', 'Golang', 'Python', 'c', 'c++', 'delphi', 'golang', 'python']
    降序: ['python', 'golang', 'delphi', 'c++', 'c', 'Python', 'Golang', 'Delphi', 'C++', 'C']

    2.      数值型排序

    def list_sort_number():
        list=[30,40,10,50,50.1,80,60,100,90]
        list.sort()
        print("升序:",list)
    
        list.sort(reverse=True)
        print("降序:",list)

    排序结果:

    升序: [10, 30, 40, 50, 50.1, 60, 80, 90, 100]
    降序: [100, 90, 80, 60, 50.1, 50, 40, 30, 10]

     

    3.      根据列表中类对象的属性排序

     

    class element(object):
        def __init__(self,id="",name=""):
            self.id=id
            self.name=name
        def __lt__(self, other): # override <操作符
            if self.id<other.id:
                return True
            return False
    
        def __str__(self): # override __str__
            return "id={0},name={1}".format(self.id,self.name)
    
    def sort_by_attribute():
        list=[element(id="130",name="json"),
              element(id="01",name="jack"),element(id="120",name="tom")]
        list.sort()
        for item in list:
            print(item)

     

    由于list.sort()函数在排序时,使用的是小于号对比,所以自定义的数据类型需要override __lt__(小于)函数才能实现排序。

     

    根据element的id属性排序

    排序列的结果:

    id=01,name=jack
    id=120,name=tom
    id=130,name=json

    4.      根据列表中元素的长度排序

    def list_sort_by_length():
        list=["delphi","Delphi","python","Python","c++","C++","c","C","golang","Golang"]
        list.sort(key=lambda ele:len(ele)) #按元素长度顺序升序排列
        print("升序:",list)
    
        list.sort(key=lambda ele:len(ele),reverse=True) #按降序排列
        print("降序:",list)

     

    借助于lambda表达式,计算list列表中的元素的长度,根据元素的长度进行排序

     

    排序的结果:

    升序: ['c', 'C', 'c++', 'C++', 'delphi', 'Delphi', 'python', 'Python', 'golang', 'Golang']
    降序: ['delphi', 'Delphi', 'python', 'Python', 'golang', 'Golang', 'c++', 'C++', 'c', 'C']

     

    5.      根据列表中元素的多个属性进行排序:

     

    def two_d_list_sort():
        list=[ ["1","c++","demo"],
               ["1","c","test"],
               ["2","java",""],
               ["8","golang","google"],
               ["4","python","gil"],
               ["5","swift","apple"]
        ]
        list.sort(key=lambda ele:ele[0])# 根据第1个元素排序
        print(list)
        list.sort(key=lambda ele:ele[1]) #先根据第2个元素排序
        print(list)
        list.sort(key=lambda ele:(ele[1],ele[0])) #先根据第2个元素排序,再根据第1个元素排序
        print(list)

     

    同样借助于lambda表达式完成,当然也可以定义一个与labmda具有相同意义的函数实现排序。

     

    排序结果:

    [['1', 'c++', 'demo'], ['1', 'c', 'test'], ['2', 'java', ''], ['4', 'python', 'gil'], ['5', 'swift', 'apple'], ['8', 'golang', 'google']]
    [['1', 'c', 'test'], ['1', 'c++', 'demo'], ['8', 'golang', 'google'], ['2', 'java', ''], ['4', 'python', 'gil'], ['5', 'swift', 'apple']]
    [['1', 'c++', 'demo'], ['1', 'c', 'test'], ['8', 'golang', 'google'], ['2', 'java', ''], ['4', 'python', 'gil'], ['5', 'swift', 'apple']]

     

    6.      动态的根据用户指定的索引进行排序

     

    有时候,在写代码之前,并不知道根据二维表的哪几列排序,而是在程序运行的时候根据输入或配置决定的,为了解决这个动态根据多个列或属性排序的问题,借助了eval()函数,eval函数能够把字符串编译成python代码并运行,从而达到动态根据多个列或属性排序的目的。

    排序结果:

    排序索引: 0 [['1', 'c++', 'demo'], ['1', 'c', 'test'], ['2', 'java', ''], ['4', 'python', 'gil'], ['5', 'swift', 'apple'], ['8', 'golang', 'google']]
    排序索引: 1 [['1', 'c', 'test'], ['1', 'c++', 'demo'], ['8', 'golang', 'google'], ['2', 'java', ''], ['4', 'python', 'gil'], ['5', 'swift', 'apple']]
    排序索引: 2 [['2', 'java', ''], ['5', 'swift', 'apple'], ['1', 'c++', 'demo'], ['4', 'python', 'gil'], ['8', 'golang', 'google'], ['1', 'c', 'test']]
    排序索引: 1,0 [['1', 'c++', 'demo'], ['1', 'c', 'test'], ['8', 'golang', 'google'], ['2', 'java', ''], ['4', 'python', 'gil'], ['5', 'swift', 'apple']]

     

    综上,基本总结了list.sort的使用的大部分场景,如下:

     

    1、默认排序

    2、根据类对象的单个属性进行排序,当然也可以扩展为根据类对象的多个属性进行排序

    3、根据元素的固有属性进行排序,如:长度、第N个元素等。为了简单,所以借助了lambda表达式,当然也可以使用普通函数代替lambda表达式

    4、动态的根据多个列进行排序,同时借助lambda和eval()函数实现

    5、另外相比Python2,Python3取消了sort函数中的 cmp方式,只能用key方式。
          所以python2用cmp方式写的函数迁移到python3中需要转换。
         from functools import cmp_to_key

        sort(iterable, key=cmp_to_key(cmp_fun))

       <感谢CSDN:xpresslink的指正>

    可能还有一些场景没有涉及到,不过我相信,上面的几种情况可以满足90%以上的场景了;如果在使用中有问题欢迎留言交流。

    展开全文
  • 排序函数:C++自带 sort排序函数用法

    千次阅读 2018-08-23 16:11:57
    c++有自带的sort排序函数,比自己写的冒泡算法快很多,可以拿来直接用 1、加上头文件#include &lt;algorithm&gt; ,using namespace std 2、函数使用方法:sort(首元素地址,尾元素地址的下一个地址,比较...
  • Numpy排序函数

    2019-08-06 15:30:26
    Numpy排序函数
  • Pandas-排序函数sort_values()

    万次阅读 多人点赞 2018-10-18 22:21:33
    pandas中的sort_values()函数类似于SQL中order by的原理,可以将数据集依照某个字段中的数据进行排序。 二、sort_values()函数的具体参数 用法: DataFrame.sort_values(by=‘##’,axis=0,ascending=True, in...
  • python3.7排序函数

    千次阅读 2020-10-10 23:56:27
    python3.7排序函数
  • SQL窗口函数-排序函数

    2020-04-22 23:37:38
    1.排序函数用途 对某一列内容的数值大小,新建一列按1,2,3...排序。 2.排序函数的完整表达式 row_number() over (partition by 分组字段 order by 需排序字段 desc/asc) partition by 分组字段:进行分组排序,...
  • Python排序函数

    千次阅读 2019-07-26 11:48:05
    Python中自带了两个排序函数sort和sorted,用法分别为: sort函数用法 list.sort(cmp=None, key=None, reverse=False) 特点:对list原地排序(直接改变数组),无返回值。 参数: cmp——可选参数, 可用于...
  • python排序函数

    千次阅读 2019-03-09 11:33:34
    python 基础的排序函数 sort 、sorted 、argsort 一、sort 、sorted 1.简单升序排序直接调用sorted函数即可 sort()方法仅定义在list中 ls = list([5, 2, 3, 1, 4]) ls.sort() print ls &gt;&gt;&gt;[1, ...
  • 排序函数重载

    千次阅读 2018-03-30 18:06:22
    编写一组重载的排序函数,可以对两个整数、三个整数、四个整数、整数数组从大到小排序,函数名为sort,其中数组排序应使用递归的方法,另补充print函数,在一行显示排序后的数组元素。 主函数如下: int main() { ...
  • MATLAB中排序函数sort()的用法

    万次阅读 2019-03-31 15:47:02
    MATLAB中排序函数sort()可以对参数的元素进行升序排序或降序排序。 具体的用法如下: Y=sort(X) sort()的参数可以是向量,矩阵,数组等等。当X是向量时,sort(X)对X的元素进行升序排序;当X是矩阵时,sort(X)对...
  • python中排序函数

    千次阅读 2018-10-23 20:23:43
    python中排序函数(sort)
  • 窗口函数之排序函数通俗理解

    千次阅读 2019-09-04 09:28:54
    * 窗口函数之排序函数 * rank():跳跃式排序——比如分数为99,99,90,89,那么通过这个函数得到的排名为1,1,3,4 dense_rank():并列连续型排序——比如分数为99,99,90,89,那么通过这个函数得到的排名为1,1...
  • R语言排序函数

    千次阅读 2020-03-22 09:33:41
    R语言常用排序函数有内置函数sort,rank,order,还有dplyr包内函数arrange。 #生成虚拟数据 data <- data.frame( score = c(1800,1500,2000,2500,2500,NA), row.names = c('杭州','成都','南京','上海','北京...
  • 这篇文章主要介绍了Python匿名函数/排序函数/过滤函数/映射函数/递归/二分法 ,本文通过实例代码给大家介绍的非常详细,具有一定的参考借鉴价值,需要的朋友可以参考下 一. lamda匿名函数  为了解决一些简单的需求而...
  • C语言 快速排序函数

    千次阅读 2017-09-12 18:34:11
    C语言 快速排序函数用法 #include #include #include struct student { int id; char name[12]; char sex; }; int compare(const void* a,const void* b)//基本数据类型排序 { return *(char*)a-*(char*)b;/...
  • c++中快速排序函数

    千次阅读 2019-03-12 23:24:19
    一)为什么要用c++标准库里的排序函数 Sort()函数是c++一种排序方法之一,学会了这种方法也打消我学习c++以来使用的冒泡排序和选择排序所带来的执行效率不高的问题!因为它使用的排序方法是类似于快排的方法,...
  • 要想比较两个函数的效率,最直观的方法莫过于比较两个排序函数排序同一个数组的时间,哪个函数花的时间更少,则该函数的运行效率相对较高,因此,我们需要在头文件中引入一个测试函数,能够较为直观的返回排序函数...
  • 之前的文章,我已经把前端需要了解的...现在我们要开始对排序算法部分进行讲解,排序算法顾名思义,就是对一堆杂乱无章的数据按照一定的规则将它们有序地排列在一起。 在讲解排序算法时,大致分成两大类,如下图 本文
  • 排序函数模板

    千次阅读 2016-05-31 13:06:27
    问题及描述; /* ... *All rights reserved. *文件名称;test.cpp *作者;邱凯 *完成日期;... 排序函数模板 *输入描述; 输入数据 *输出描述; 输出答案 */ #include using namespace std; templ
  • Oracle 分组排序函数

    千次阅读 2018-06-20 11:32:53
    2、亦或更加要求取出1中已经分组排序好的前多少行的数据这里通过一张表的示例和SQL语句阐述下oracle数据库中用于分组排序函数的用法。1.row_number() over()row_number()over(partition by col1 order by col2)表...
  • Python实现指定排序函数进行排序

    千次阅读 2017-11-09 21:59:25
    利用冒泡排序、直接选择排序分别实现指定数组的升序、降序排列,并可以选择指定排序函数。 Python代码如下: #冒泡排序法实现升序排列 def bubble_sort(lists, sort = None): if not sort: count = len(lists) ...
  • 【C语言】快速排序函数qsort()

    万次阅读 多人点赞 2018-05-12 16:28:22
    快速排序函数 函数原型 #include&amp;amp;amp;amp;amp;amp;lt;stdlib.h&amp;amp;amp;amp;amp;amp;gt; void qsort(void*, size_t, size_t, int ( * )(const void * , const void * )) 1...
  • python自定义排序函数

    万次阅读 2016-01-02 16:47:08
    python自定义排序函数,有两种方式 第一种自定义函数: # 自定义排序函数 def func(x,y): if x return -1 if x==y: return 0 else: return 1 a = [3,6,2,8,4] print u'正序排列:',sorted(a,func) print u'
  • sort 在 STL 库中是排序函数,有时冒泡、选择等O(n2)O(n2)算法会超时时,我们可以使用 STL 中的快速排序函数O(nlogn)O(nlogn)完成排序 sort 在 algorithm 库里面,原型如下: template <class ...
  • 【题目】python中的排序函数sorted以及列表排序方法sort()   概述 Python list内置sort()方法用来排序,也可以用python内置的全局sorted()方法来对可迭代的序列排序生成新的序列。如果要读取文件夹下面的文件,...
  • Matlab排序函数

    千次阅读 2014-01-06 01:18:55
    Matlab自带排序函数sort用法 [Y,I] = sort(X,DIM,MODE) sort函数默认Mode为'ascend'为升序,sort(X,'descend')为降序排列。 sort(X)若X是矩阵,默认对X的各列进行升序排列 sort(X,dim) dim=1时等效sort(X) dim...
  • lua自定义排序函数

    千次阅读 2016-08-05 10:34:30
    说一下lua的table库中比较常用的排序函数——table.sort(),第一个参数代表要进行排序的table,第二个参数是可选的,如果没有第二个参数,那么这个函数就会将table元素从小到大进行排序,我主要来说一下第二个参数。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 64,212
精华内容 25,684
关键字:

排序函数