精华内容
下载资源
问答
  • 数组排序
    万次阅读 多人点赞
    2021-09-27 10:51:26

    这三个排序方法应对日常工作基本够用

    先说一下三者的区别
    sort, sorted 是用在 list 数据类型中的排序方法
    argsort 是用在 numpy 数据类型中的排序方法( numpy 里也有一个 sort 方法,下面会讲)

    sort 和 sorted 的区别如下👇
    先看两个简单的升序排序,分别使用 sorted 和 sort 方法

    # sorted 
    num_list = [1, 8, 2, 3, 10, 4, 5]
    ordered_list = sorted(num_list)
    print(ordered_list)    # [1, 2, 3, 4, 5, 8, 10]
    
    # sort
    num_list = [1, 8, 2, 3, 10, 4, 5]
    num_list.sort()
    print(num_list)    # [1, 2, 3, 4, 5, 8, 10]
    

    可以看出 sorted 并没有修改原来的数组,而是将排序的结果作为参数传递给一个新的数组,而 sort 则在原数组上直接进行了排序
    区别就是 sorted 需要一个变量接收排序结果,sort不用
    建议使用 sorted,因为 sort 虽然代码更简洁,但是会修改原数组,这样不灵活,如果你有多个地方同时使用了这个数组,那么经过 sort 操作之后的数组就已经不是原来那个数组了,debug的时候很麻烦


    说完了区别,来具体讲讲使用方法

    1.升序排序

    # sorted 升序排序
    num_list = [1, 8, 2, 3, 10, 4, 5]
    ordered_list = sorted(num_list)
    print(ordered_list)    # [1, 2, 3, 4, 5, 8, 10]
    
    # sort 升序排序
    num_list = [1, 8, 2, 3, 10, 4, 5]
    num_list.sort()
    print(num_list)    # [1, 2, 3, 4, 5, 8, 10]
    

    2.降序排序

    # sorted 降序排序
    num_list = [1, 8, 2, 3, 10, 4, 5]
    ordered_list = sorted(num_list, reverse=True)
    print(ordered_list)    # [1, 2, 3, 4, 5, 8, 10]
    
    # sort 降序排序
    num_list = [1, 8, 2, 3, 10, 4, 5]
    num_list.sort(reverse=True)
    print(num_list)    # [1, 2, 3, 4, 5, 8, 10]
    

    3.如果不想要排序后的值,想要排序后的索引,可以这样做

    num_list = [1, 8, 2, 3, 10, 4, 5]
    ordered_list = sorted(range(len(num_list)), key=lambda k: num_list[k])
    print(ordered_list)    # [0, 2, 3, 5, 6, 1, 4]
    

    4.字符串类型排序

    # 字符串类型排序
    str_list = ['1', '8', '2', '3', '10', '4', '5']
    ordered_list = sorted(str_list)
    print(ordered_list)  # ['1', '10', '2', '3', '4', '5', '8']
    
    str_list = ['A', 'D', 'B', 'N', 'C', 'R', 'V']
    ordered_list = sorted(str_list)
    print(ordered_list)  # ['A', 'B', 'C', 'D', 'N', 'R', 'V']
    

    5.二维数组排序

    book_list = [
        ['北大马克思主义研究', '9787509728529', 2011],
        ['人的解放', '9787215064003', 2014],
        ['西方经典悦读 资本论', '9787200092882', 2012],
        ['列宁的一生', '9787501319343', 2013],
    ]
    
    # sorted 按出版年升序排序
    ordered_list = sorted(book_list, key=lambda book: book[2])
    print(ordered_list)    # [['北大马克思主义研究', '9787509728529', 2011], ['西方经典悦读 资本论', '9787200092882', 2012], ['列宁的一生', '9787501319343', 2013], ['人的解放', '9787215064003', 2014]]
    
    # sort 按出版年降序排序
    book_list.sort(key=lambda book: book[2], reverse=True)
    print(book_list)    # [['人的解放', '9787215064003', 2014], ['列宁的一生', '9787501319343', 2013], ['西方经典悦读 资本论', '9787200092882', 2012], ['北大马克思主义研究', '9787509728529', 2011]]
    

    6.二维数组获取排序后的索引

    # sorted 获取排序后的索引
    book_list = [
        ['北大马克思主义研究', '9787509728529', 2011],
        ['人的解放', '9787215064003', 2014],
        ['西方经典悦读 资本论', '9787200092882', 2012],
        ['列宁的一生', '9787501319343', 2013],
    ]
    ordered_list = sorted(range(len(book_list)), key=lambda k: book_list[k][2])
    print(ordered_list)  # [0, 2, 3, 1]
    

    7.字典数组排序

    book_list = [
        {'name': '北大马克思主义研究', 'isbn': '9787509728529', 'publish_year': 2011},
        {'name': '人的解放', 'isbn': '9787215064003', 'publish_year': 2014},
        {'name': '西方经典悦读 资本论', 'isbn': '9787200092882', 'publish_year': 2012},
        {'name': '列宁的一生', 'isbn': '9787501319343', 'publish_year': 2013},
    ]
    # sorted 按出版年降序排序
    ordered_list = sorted(book_list, key=lambda book: book['publish_year'], reverse=True)
    print(ordered_list)    # [{'name': '人的解放', 'isbn': '9787215064003', 'publish_year': 2014}, {'name': '列宁的一生', 'isbn': '9787501319343', 'publish_year': 2013}, {'name': '西方经典悦读 资本论', 'isbn': '9787200092882', 'publish_year': 2012}, {'name': '北大马克思主义研究', 'isbn': '9787509728529', 'publish_year': 2011}]
    # sort 按出版年升序排序
    book_list.sort(key=lambda book: book['publish_year'])
    print(book_list)    # [{'name': '北大马克思主义研究', 'isbn': '9787509728529', 'publish_year': 2011}, {'name': '西方经典悦读 资本论', 'isbn': '9787200092882', 'publish_year': 2012}, {'name': '列宁的一生', 'isbn': '9787501319343', 'publish_year': 2013}, {'name': '人的解放', 'isbn': '9787215064003', 'publish_year': 2014}]
    

    8.字典数组获取排序后的索引

    book_list = [
        {'name': '北大马克思主义研究', 'isbn': '9787509728529', 'publish_year': 2011},
        {'name': '人的解放', 'isbn': '9787215064003', 'publish_year': 2014},
        {'name': '西方经典悦读 资本论', 'isbn': '9787200092882', 'publish_year': 2012},
        {'name': '列宁的一生', 'isbn': '9787501319343', 'publish_year': 2013},
    ]
    ordered_list = sorted(range(len(book_list)), key=lambda k: book_list[k]['publish_year'])
    print(ordered_list)  # [0, 2, 3, 1]
    

    9.对象排序

    class Book(object):
        def __init__(self, name, isbn, publish_year):
            self.name = name
            self.isbn = isbn
            self.publish_year = publish_year
        def __repr__(self):
            return repr((self.name, self.isbn, self.publish_year))
    book_list = [
        Book('北大马克思主义研究', '9787509728529', 2011),
        Book('人的解放', '9787215064003', 2014),
        Book('西方经典悦读 资本论', '9787200092882', 2012),
        Book('列宁的一生', '9787501319343', 2013),
    ]
    # sorted 按出版年降序排序
    ordered_list = sorted(book_list, key=lambda book: book.publish_year, reverse=True)
    print(ordered_list)  # [('人的解放', '9787215064003', 2014), ('列宁的一生', '9787501319343', 2013), ('西方经典悦读 资本论', '9787200092882', 2012), ('北大马克思主义研究', '9787509728529', 2011)]
    # sort 按出版年升序排序
    book_list.sort(key=lambda book: book.publish_year)
    print(book_list)  # [('北大马克思主义研究', '9787509728529', 2011), ('西方经典悦读 资本论', '9787200092882', 2012), ('列宁的一生', '9787501319343', 2013), ('人的解放', '9787215064003', 2014)]
    

    10.对象排序获取排序后的索引

    book_list = [
        Book('北大马克思主义研究', '9787509728529', 2011),
        Book('人的解放', '9787215064003', 2014),
        Book('西方经典悦读 资本论', '9787200092882', 2012),
        Book('列宁的一生', '9787501319343', 2013),
    ]
    ordered_list = sorted(range(len(book_list)), key=lambda k: book_list[k].publish_year)
    print(ordered_list)  # [0, 2, 3, 1]
    

    11.一维数组排序【numpy】

    numpy 只有 sort 没有 sorted,且 numpy 的 sort 方法 和 list 的 sorted 方法使用起来类似

    import numpy as np
    
    # 一维数组
    num_list = np.array([1, 8, 2, 3, 10, 4, 5])
    index_list = np.sort(num_list)
    print(index_list)    # [ 1  2  3  4  5  8 10]
    

    12.一维数组获取排序后的索引【numpy】

    num_list = np.array([1, 8, 2, 3, 10, 4, 5])
    index_list = np.argsort(num_list)
    print(index_list)    # [0 2 3 5 6 1 4]
    

    13.一维数组降序排序【numpy】

    # # 降序排序
    num_list = np.array([1, 8, 2, 3, 10, 4, 5])
    index_list = np.argsort(-num_list)    # 加负号按降序排序
    print(index_list)  # [4 1 6 5 3 2 0]
    

    14.二维数组排序【numpy】

    num_list = np.array([
        [1, 8, 2, 9],
        [8, 2, 4, 5],
        [2, 3, 7, 4],
        [1, 2, 3, 5]
    ])
    ordered_list = np.sort(num_list, axis=0)    # axis=0 是按列排序
    print(ordered_list)
    # [[1 2 2 4]
    #  [1 2 3 5]
    #  [2 3 4 5]
    #  [8 8 7 9]]
    
    ordered_list = np.sort(num_list, axis=1)     # axis=1 是按行排序
    print(ordered_list)
    # [[1 2 8 9]
    #  [2 4 5 8]
    #  [2 3 4 7]
    #  [1 2 3 5]]
    

    15.二维数组获取排序后的索引【numpy】

    num_list = np.array([
        [1, 8, 2, 9],
        [8, 2, 4, 5],
        [2, 3, 7, 4],
        [1, 2, 3, 5]
    ])
    ordered_list = np.argsort(num_list, axis=0)   # axis=0 是按列排序
    print(ordered_list)
    # [[0 1 0 2]
    #  [3 3 3 1]
    #  [2 2 1 3]
    #  [1 0 2 0]]
    ordered_list = np.argsort(num_list, axis=1)  # axis=1 是按行排序
    print(ordered_list)
    # [[0 2 1 3]
    #  [1 2 3 0]
    #  [0 1 3 2]
    #  [0 1 2 3]]
    
    更多相关内容
  • 我们知道在js中默认提供了sort函数,但是这个函数默认是按照数组内容的ascii码升序进行排列的,如果我们要对二维数组排序要如何做呢?在php中是有multi_sort函数可供调用的,但是在js中似乎没有这种函数,但是没关系...
  • 易语言文本数组排序

    2020-08-16 06:37:33
    文本数组排序 系统结构:文本数组排序, ======程序集1 | | | |------ _启动子程序 | | | |------ _临时子程序 | | | |------ 文本数组排序
  • /**作用: 二维数组排序函数,支持多键名排序 * 返回: 排序好的数组 * 使用: array_msort(数组,需要排序的键名,排序方式); * 例子: array_msort($cflist,"chapter_orderid","SORT_ASC"); * array_msort($arr,"name...
  • 数字索引数组: bool usort( array &$array, callback $cmp_function ) usort函数对指定数组(参数1)按指定方式(参数2)进行排序。 当我们想对多维数组进行排序时,多维数组的每个元素又是一数组类型,而两个数组如何...
  • 易语言自定义数据类型数组排序源码,自定义数据类型数组排序,更新超级列表框,取随机品名,根据产地排序,根据类别排序,根据售价排序
  • 介绍了关于使用SCL编写的数组排序程序的详细说明,提供实用程序算法的技术资料的下载。
  • 问题:将两个已排序数组合并成一个排序数组 这里先不考虑大数据量的情况(在数据量很大时不知大家有什么好的思路或方法?),只做简单数组的处理。 简单代码如下: 说明:之所以把merge函数定义成返回数组长度,是因为...
  • 为普通数组和对象数组排序,对象数组排序时,可指定排序所依据的对象属性,汉字将以汉语拼音为序。
  • 此函数对元胞数组进行排序,即使它包含字符串和数值(即混合)。 唯一的限制是它假定每列包含数字值或字符串,而不是两者都包含。 它按升序对行进行排序。 请注意,它允许根据用户输入的优先级对多列进行排序
  • java数组排序

    2017-09-04 11:39:37
    java数组排序的思想,过程和代码实现。多种数组排序的方法,主要有冒泡排序,堆排序,插入排序, 归并操作(merge), 归并操作(merge),选择排序,希尔排序。
  • 易语言自定义数据类型数组排序
  • 主要介绍了Perl基本数组排序方法介绍,本文讲解基于ASCII码排序、比较函数、按字母顺序排列、Perl对数值排序等内容,需要的朋友可以参考下
  • 易语言文本数组排序模块源码 系统结构:文本数组排序, ======窗口程序集1 | | | |------ __启动窗口_创建完毕 | | | |------ _按钮1_被单击 ======程序集1 | | | |------ _启动子程序 | | | |------ _临时子
  • 我查阅网上资料未见到关于数组中有重复元素时如何得到排序后的数组索引(所有元素的索引),所有自己写了一个简单的版本,与大家一起分享.
  • 易语言数组排序源码

    2020-12-08 02:19:54
    为您提供易语言数组排序源码下载,易语言数组排序源码系统结构:易语言数组排序源码,数组排序 ======窗口程序集1 | | | |------ __启动窗口_创建完毕 | | | |------ _按钮1_被单击 | | | |------ _按钮2_被单击
  • PHP 数组排序

    2021-01-03 05:26:08
    PHP 数组排序 数组中的元素可以按字母或数字顺序进行降序或升序排列。 PHP – 数组排序函数 在本章中,我们将一一介绍下列 PHP 数组排序函数: sort() – 对数组进行升序排列 rsort() – 对数组进行降序排列 a...
  • 易语言文本数组随机打乱排序源码,文本数组随机打乱排序,交换数据_ASM变量交变量,交换数据_ASM变量数组交变量数组,加,减,依文本类型排序,文本冒泡排序,按文本长度排序,每字分割_到数组,取文本第一个字,反转数组,打乱...
  • 易语言数组排序算法集合源码,数组排序算法集合,排序程序,冒泡排序,改冒泡法,双向泡排序,双响泡排序,直接插入排序,地精排序,地精排序2,地精排序3,二分排序,选择排序,梳子排序,希尔排序,快速排序
  • 在本篇内容里小编给大家分享的关于易语言如何自编数组排序的方法和技巧,需要的朋友们可以学习下。
  • 易语言数组排序源码
  • 今天小编就为大家分享一篇关于易语言数组排序命令使用讲解,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • 易语言文本数组排序模块源码
  • 文本数组 里面带小数的 排序 改的精易模快 数组排名
  • 任意数组排序

    2014-08-30 14:24:24
    任意数组排序 很经典经典 学习交流
  • 二维数组排序.vi
  • Js中的数组排序

    千次阅读 2022-04-01 15:46:09
    本文介绍了数组自带的sort方法以及冒泡排序、选择排序、快排以及插入排序 1.数组的sort() 默认情况下,sort() 方法将按字母和升序将值作为字符串进行排序。 注意: sort() 方法会改变原始数组。 如果想按照别的顺序...

    本文介绍了数组自带的sort方法以及冒泡排序、选择排序、快排以及插入排序
    1.数组的sort()
    默认情况下,sort() 方法将按字母和升序将值作为字符串进行排序。
    注意: sort() 方法会改变原始数组。
    如果想按照别的顺序进行排序,就必须提供比较函数,该函数要比较两个值,然后返回一个用于说明这两个值的相对顺序的数字。比较函数应该具有两个参数a和b,如果数组中的元素是数值类型,如果需要升序排序,那么就返回a - b;如果需要降序排序,那么就返回b-a;

        var oldArr = [19, 55, 6, 52, 4 , 6, 15, 28, 23, 2, 1, 9]
        oldArr.sort((a, b) => {
          return a-b // 升序
        })
        console.log(oldArr);
      //  [1, 2, 4, 6, 6, 9, 15, 19, 23, 28, 52, 55]
    

    以下代码实现的都是升序
    2.冒泡排序
    思路:通过两层循环把数组中两两相邻的元素进行比较,比较两个元素的大小,大的元素放后面,从而一步步交换元素的位置,这样最后一个元素是最大值,下一次循环比较就不需要比较这个最大值,持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
    代码如下:

      var oldArr = [19, 55, 6, 52, 4 , 6, 15, 28, 23, 2, 1, 9]
      function bubbleSort(arr) {
        for(let i = 0; i < arr.length; i++) {
          for (let j = 0; j < arr.length - i; j++) {
            // 如果前一个比后一个大,则交换位置
            if (arr[j] > arr[j+1]) {
              let temp = arr[j]
              arr[j] = arr[j + 1]
              arr[j + 1] = temp
            }
          }
        }
        return arr
      }
      console.log(bubbleSort(oldArr));
      //  [1, 2, 4, 6, 6, 9, 15, 19, 23, 28, 52, 55]
    

    3.选择排序
    思路:第一次从待排序的数据元素中选出最小的一个元素,存放在序列的起始位置,然后再从剩余的未排序元素中寻找到最小元素,然后放到已排序的序列的末尾。以此类推,直到全部待排序的数据元素的个数为零。
    代码如下:

      var oldArr = [19, 55, 6, 52, 4 , 6, 15, 28, 23, 2, 1, 9]
      function selectArr(arr) {
        for(let i = 0; i < arr.length - 1; i++) {
          for(let j = i + 1; j < arr.length; j++) {
            if (arr[i] > arr[j]) {
              let temp = arr[i]
              arr[i] = arr[j]
              arr[j] = temp
            }
          }
        }
        return arr
      }
      console.log(selectArr(oldArr));
      //  [1, 2, 4, 6, 6, 9, 15, 19, 23, 28, 52, 55]
    

    4.快排
    快速排序算法通过多次比较和交换来实现排序,其排序流程如下:
    (1)首先设定一个分界值,通过该分界值将数组分成左右两部分。
    (2)将大于或等于分界值的数据集中到数组右边,小于分界值的数据集中到数组的左边。此时,左边部分中各元素都小于分界值,而右边部分中各元素都大于或等于分界值。
    (3)然后,左边和右边的数据可以独立排序。对于左侧的数组数据,又可以取一个分界值,将该部分数据分成左右两部分,同样在左边放置较小值,右边放置较大值。右侧的数组数据也可以做类似处理。
    (4)重复上述过程,可以看出,这是一个递归定义。通过递归将左侧部分排好序后,再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后,整个数组的排序也就完成了。
    代码如下:

      var oldArr = [19, 55, 6, 52, 4 , 6, 15, 28, 23, 2, 1, 9]
      function quickArr(arr) {
        if (arr.length < 1) return arr
        var temp = Math.floor(arr.length/2)
        var leftArr = [], rightArr = []
        var tempNum = arr.splice(temp,1)[0]
        for(var i = 0; i < arr.length; i++) {
          if (tempNum > arr[i]) {
            leftArr.push(arr[i])
          }else {
            rightArr.push(arr[i])
          }
        }
        return quickArr(leftArr).concat(tempNum, quickArr(rightArr))
      }
      console.log(quickArr(oldArr));
      //  [1, 2, 4, 6, 6, 9, 15, 19, 23, 28, 52, 55]
    

    5.插入排序
    思路:插入排序是指在待排序的元素中,假设前面n-1(其中n>=2)个数已经是排好顺序的,现将第n个数插到前面已经排好的序列中,然后找到合适自己的位置,使得插入第n个数的这个序列也是排好顺序的。按照此法对所有元素进行插入,直到整个序列排为有序的过程,称为插入排序
    在这里插入图片描述

    代码如下:

      var oldArr = [19, 55, 6, 52, 4 , 6, 15, 28, 23, 2, 1, 9]
      function inserArr(arr) {
        let newArr = []
        for(let i = 0; i < arr.length; i++) {
          if (i === 0) {
            newArr.push(arr[i])
            continue
          }
          for(j = newArr.length -1; j >= 0; j--) {
            if (arr[i] >= newArr[j]) {
              newArr.splice(j + 1, 0, arr[i])
              break
            } else if (j === 0) {
              newArr.splice(0, 0, arr[i])
            }
          }
        }
        return newArr
      }
      console.log(inserArr(oldArr));
      //  [1, 2, 4, 6, 6, 9, 15, 19, 23, 28, 52, 55]
    
    展开全文
  • 易语言源码易语言自定义数据类型数组排序.rar 易语言源码易语言自定义数据类型数组排序.rar 易语言源码易语言自定义数据类型数组排序.rar 易语言源码易语言自定义数据类型数组排序.rar 易语言源码易语言自定义...
  • 分类标签:选择数组排序,冒泡排序,插入排序,冒泡排序分类标签:选择数组排序,冒泡排序,插入排序,冒泡排序分类标签:选择数组排序,冒泡排序,插入排序,冒泡排序分类标签:选择数组排序,冒泡排序,插入排序,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,112,088
精华内容 444,835
关键字:

数组排序

友情链接: FunctionGraph.zip