精华内容
下载资源
问答
  • 主要介绍了java 实现Comparable接口排序,升序降序、倒叙,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 主要介绍了JAVA基于Arrays.sort()实现数组升序和降序,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 堆排序的思路主要就是建堆排序两部分组成。 2.建堆算法 Williams算法建堆法【Wil64】 时间复杂度为O(nlogn),空间为O(1) Floyd算法建堆法【Floo64】 一种更为高效的建堆方法,可以在O(时间)O(1)空间内完成建...

    一、概述

    1.堆排序的思路主要就是建堆和排序两部分组成。堆排序是基于二叉树的,那么我们首先得知道二叉树得基本特性。我们在堆排序中定义这样一种完整二叉树,其中每个结点的值都大于等于它的孩子,那么我们就称之为最大堆,同理还有最小堆。接下来重要的是我们在建立完最大堆之后,我们需要再次进行上浮或者下沉操作,使得二叉树仍然满足最大对的定义。

    2.二叉树概述

    二叉树得结点一般用于存储我们要处理的数据,而结点位置可以通过编号给出简单且唯一的描述:

    • 结点编号一般取整数,我们称树中编号为k的结点为结点k
    • 一棵非空二叉树根结点的编号为1,这是最小的编号
    • 结点k的左孩子和右孩子编号分别为2k和2k+1,而节点k称为这两个孩子的父亲

       按照上述规则,可知结点k的父亲结点编号为k/2。另外二叉树的层次也很重要,一般定义根节点 处于第0层,以此为基础不断递增,也即所有位于第L层的结点其孩子所在层次为L+1。二叉树的高度定义为该树中结点的最大层数,若二叉树是一颗结点总数为2^(h+1)-1的完整二叉树(h为二叉树的高度),那么称该二叉树为完美二叉树。
       二叉树中结点的的孩子数称为该节点的度,显然度为0的结点称为叶子结点,否则称为非叶子结点。若二叉树中非叶子结点的度均为2,那么就称该二叉树为满二叉树

    3.总结

    • 非空二叉树的第i层最多有2^i个结点
    • 高为h的非空二叉树最多包含的结点数为2^(h+1)-1个
    • 设i = 0,1,2 ,若非空二叉树中度为i的结点数为Ni,则N0 = N2 + 1

    二、建堆算法

    这里我在课本上学习的建堆方法有两种,分别是Williams建堆法Floyd建堆法,接下来将讲述这两种建堆方法的区别,在一般的堆排序中我们建议使用Floyd建堆法,因为它的时间复杂度更低并且代码更加容易实现。但是还是要将每种的实现步骤画一遍。

    1.Williams算法建堆法【Wil64】

    时间复杂度为O(nlogn),空间为O(1)
    例如我们对数组[4,7,5,8,6,0,2,3,9,1]进行从小到大排列,因为我们是要从小到达进行排列所以我们应该建立最大堆。
    我们知道在建立完最大堆之后,就要开始进行弹出操作,我们最先弹出的数字永远放在最后面因此从小到大的排列就需要建立最大堆。

    这是我们要排序的数组。
    在这里插入图片描述
    开始建堆
    第一步
    在这里插入图片描述
    第二步(因为7比4大所以交换顺序)
    在这里插入图片描述
    第三步(5比父节点小,所以当作6的右孩子就可以)
    在这里插入图片描述
    第四步
    在这里插入图片描述
    第五步
    在这里插入图片描述
    第六步
    在这里插入图片描述
    第七步
    在这里插入图片描述
    第八步
    在这里插入图片描述
    第九步
    在这里插入图片描述
    第十步
    在这里插入图片描述
    到这里我们就建完了我们的最大堆,
    接下来我们就开始进行弹出操作:
    首先走到这里我们一斤建好了我们的最大堆,我们现在就开始进行弹出操作,也就是我们的排序。
    第一步(弹出9)
    在这里插入图片描述
    第二步(弹出8)
    在这里插入图片描述
    第三步(弹出7)
    在这里插入图片描述
    第四步(弹出6)
    在这里插入图片描述
    第五步(弹出5)
    在这里插入图片描述
    第六步(弹出4)
    在这里插入图片描述
    第七步(弹出3)
    在这里插入图片描述
    第八步(弹出2)
    在这里插入图片描述
    第九步(弹出1)
    在这里插入图片描述
    第十步(弹出0)
    这里我们就已经排序完成,我们首先弹出来的在后面
    在这里插入图片描述

    2.Floyd算法建堆法【Floo64】

    一种更为高效的建堆方法,可以在O(时间)和O(1)空间内完成建堆任务。
    他的要点就是从最后一个非叶子结点从后向前对那些有孩子的结点执行下沉操作 ,从而来建立我们的最大堆。在开始之前还是要强调要会计算某个结点的左右孩子结点,和孩子节点的父结点。

    最开始的数组
    在这里插入图片描述
    建堆
    第一步(最开始的堆)
    在这里插入图片描述第二步(元素8无需调整,因为以它为根的子树已经是子堆)
    在这里插入图片描述
    第三步(元素0下沉后原位置对应一个以9为对顶的子堆)
    在这里插入图片描述第四步(元素6无需调整,因为以它为根的子树已经是子堆)
    在这里插入图片描述
    第五步(元素4下沉后原位置对应一个以9为对顶的子堆)
    在这里插入图片描述第六步(元素7下沉后原位置(已经是根节点)对应一个以9为对顶的子堆)
    在这里插入图片描述到这里我们就已经完成建堆任务,这里有一个定义Floyd算法可以在O(n)时间内完成对n个元素建堆的任务。
    后面的就和上一个弹出操作类似,这里就不展示每一次步骤了。

    三、基于Floyd建堆算法进行堆排序

    1.最小堆
    在开始之前我们前面已经知道了怎样表示一个结点的左孩子和右孩子,以及知道某个结点可以求出其父亲结点。先下面我们对数组进行从大到小排序,因此我么应该建立最小堆

    package org.westos.demo;
    
    
    
    import java.util.Arrays;
    import java.util.Scanner;
    
    public class HeapSort3 {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入你要排序的数字的个数");
            int n = sc.nextInt();
            int[] tree = new int[n];
            for (int i = 0; i < tree.length; i++) {
                tree[i] = sc.nextInt();
            }
            heap_sort(tree,tree.length);
            System.out.println(Arrays.toString(tree));
        }
        //我们在建好堆的基础之上,进行排序,每次排完序之后要记得重新进行下沉操作,从而使得堆满足最大(小)堆的特性
        public static void heap_sort(int[]tree,int n){
            build_heap(tree,n);
            for (int i = n-1; i >= 0; i--) {
                swap(tree,i,0);
                heapify(tree,i,0);
            }
        }
    
        /**
         *
         * @param tree 要排序的数组
         * @param n    数组的长度
         * 从最后一个非叶子结点从后向前进行建堆,这里我们使用的是Floyd建堆算法
         */
        public static void build_heap(int[]tree,int n){
            int last_node = n - 1;
            int parent = (last_node - 1)/2;
            for (int i = parent;i >= 0;i--){
                heapify(tree,n,i);
            }
        }
    
        /**
         *
         * @param tree 要排序的数组
         * @param n    数组的长度
         * @param i    表示第i个节点
         * 这里我们对元素进行下沉操作
         */
        public static void heapify(int[]tree,int n,int i){
            if(i >= n){
                return;
            }
            int c1 = 2 * i +1;//左孩子结点
            int c2 = 2 * i +2;//右孩子结点
            int max = i;//父亲结点
            //下面就是判断父亲结点和孩子结点的大小,从而进行下沉操作
            if (c1 < n && tree[max] > tree[c1]){//这里得加上c1 < n 防止越界
                max = c1;
            }
            if (c2 < n && tree[max] > tree[c2]){//这里得加上c2 < n 防止越界
                max = c2;
            }
            if (max != i){
                swap(tree,max, i);
                heapify(tree,n,max);
            }
        }
        public static void swap(int[]tree,int i,int j){
            int temp = tree[i];
            tree[i] = tree[j];
            tree[j] = temp;
        }
    }
    
    

    验证

    请输入你要排序的数字的个数
    10
    7
    4
    6
    0
    8
    1
    5
    9
    2
    3
    [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
    
    Process finished with exit code 0
    

    2.最大堆
    这里我们只需要在上面代码出改变一处位置就OK,就是我们在进行下沉操作的时候,判断父亲结点与孩子结点的值的大小就可以。

    package org.westos.demo;
    
    
    
    import java.util.Arrays;
    import java.util.Scanner;
    
    public class HeapSort3 {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入你要排序的数字的个数");
            int n = sc.nextInt();
            int[] tree = new int[n];
            for (int i = 0; i < tree.length; i++) {
                tree[i] = sc.nextInt();
            }
            heap_sort(tree,tree.length);
            System.out.println(Arrays.toString(tree));
        }
        //我们在建好堆的基础之上,进行排序,每次排完序之后要记得重新进行下沉操作,从而使得堆满足最大(小)堆的特性
        public static void heap_sort(int[]tree,int n){
            build_heap(tree,n);
            for (int i = n-1; i >= 0; i--) {
                swap(tree,i,0);
                heapify(tree,i,0);
            }
        }
    
        /**
         *
         * @param tree 要排序的数组
         * @param n    数组的长度
         * 从最后一个非叶子结点从后向前进行建堆,这里我们使用的是Floyd建堆算法
         */
        public static void build_heap(int[]tree,int n){
            int last_node = n - 1;
            int parent = (last_node - 1)/2;
            for (int i = parent;i >= 0;i--){
                heapify(tree,n,i);
            }
        }
    
        /**
         *
         * @param tree 要排序的数组
         * @param n    数组的长度
         * @param i    表示第i个节点
         * 这里我们对元素进行下沉操作
         */
        public static void heapify(int[]tree,int n,int i){
            if(i >= n){
                return;
            }
            int c1 = 2 * i +1;//左孩子结点
            int c2 = 2 * i +2;//右孩子结点
            int max = i;//父亲结点
            //下面就是判断父亲结点和孩子结点的大小,从而进行下沉操作
            if (c1 < n && tree[max] < tree[c1]){//这里得加上c1 < n 防止越界
                max = c1;
            }
            if (c2 < n && tree[max] < tree[c2]){//这里得加上c2 < n 防止越界
                max = c2;
            }
            if (max != i){
                swap(tree,max, i);
                heapify(tree,n,max);
            }
        }
        public static void swap(int[]tree,int i,int j){
            int temp = tree[i];
            tree[i] = tree[j];
            tree[j] = temp;
        }
    }
    
    

    测试:

    请输入你要排序的数字的个数
    10
    7
    4
    6
    0
    8
    1
    5
    9
    2
    3
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    
    Process finished with exit code 0
    

    四、总结

    在刚开始学完堆排序之后,我只是简单的懂了其中的原理,但是当我真正用代码进行实现的时候,才发现自己遇见了很大的问题,虽然每一步的流程图都可以画出来,但是代码还是不知道怎么实现。首先堆排序利用了二叉树,那么首先就要对二叉树了解,另外还有里面的相关结点的计算,接下来就是按照每一步的流程用代码实现,这里面还有好几处边界问题也应该注意,另外,如果不知道思路大概画一遍就可以更加深入的了解其中的原理。

    展开全文
  • 优先队列-java可以选择属性和升序降序
  • python升序和降序排序If you want to learn how to work with the sort() method in your Python projects, then this article is for you. This method is very powerful and you can customize it to fit your ...

    python升序和降序排序

    If you want to learn how to work with the sort() method in your Python projects, then this article is for you. This method is very powerful and you can customize it to fit your needs, so let's see how it works in detail.

    如果您想学习如何在Python项目中使用sort()方法,那么本文适合您。 此方法功能非常强大,您可以根据需要对其进行自定义,因此让我们详细了解它的工作原理。

    You will learn:

    您将学习:

    • How to use this method and customize its functionality.

      如何使用此方法并自定义其功能。
    • When to use it and when not to use it.

      何时使用和何时不使用它。
    • How to call it passing different combinations of arguments.

      如何通过不同的参数组合调用它。
    • How to sort a list in ascending and descending order.

      如何按升序和降序对列表进行排序。
    • How to compare the elements of a list based on intermediate values.

      如何基于中间值比较列表的元素。
    • How you can pass lambda functions to this method.

      如何将lambda函数传递给此方法。
    • How this method compares to the sorted() function.

      此方法与sorted()函数的比较。

    • Why the sort() method performs a stable sort.

      为什么sort()方法执行稳定的排序。

    • How the process of mutation works behind the scenes.

      突变过程如何在后台工作。

    Are you ready? Let's begin! ⭐

    你准备好了吗? 让我们开始! ⭐

    目的和用例 (Purpose and Use Cases)

    With the sort() method, you can sort a list in either:

    使用sort()方法,可以对以下任一列表进行排序:

    • Ascending Order

      升序
    • Descending Order

      降序

    This method is used to sort a list in place, which means that it mutates it or modifies it directly without creating additional copies, so remember:

    此方法用于对列表进行排序,这意味着它会对其进行突变或直接对其进行修改,而无需创建其他副本,因此请记住:

    You will learn more about mutation in this article (I promise!), but for now it's very important that you know that the sort() method modifies the list, so its original version is lost.

    您将在本文中了解有关突变的更多信息(我保证!),但是现在很重要的一点是,您知道sort()方法会修改列表,因此它的原始版本会丢失。

    Because of this, you should only use this method if:

    因此,仅在以下情况下才应使用此方法:

    • You want to modify (sort) the list permanently.

      您要永久修改(排序)列表。
    • You don't need to keep the original version of the list.

      您无需保留列表的原始版本。

    If this fits your needs, then the .sort() method is exactly what you are looking for.

    如果这符合您的需求,那么.sort()方法正是您想要的。

    🔸语法和参数 (🔸 Syntax and Arguments)

    Let's see how you can call .sort() to take advantage of its full power.

    让我们看看如何调用.sort()来利用其全部功能。

    This is the most basic call (with no arguments):

    这是最基本的调用(无参数):

    If you don't pass any arguments, by default:

    如果您不传递任何参数,则默认情况下:

    • The list will be sorted in ascending order.

      该列表将按升序排序。
    • The elements of the list will be compared directly using their values with the < operator.

      列表中的元素将使用其值与<运算符直接进行比较。

    For example:

    例如:

    >>> b = [6, 3, 8, 2, 7, 3, 9]
    >>> b.sort()
    >>> b
    [2, 3, 3, 6, 7, 8, 9] # Sorted!

    自定义参数 (Custom Arguments  )

    To customize how the sort() method works, you can pass two optional arguments:

    要自定义sort()方法的工作方式,可以传递两个可选参数:

    • Key

    • Reverse

      逆转

    Let's see how they change the behavior of this method. Here we have a method call with these two arguments:

    让我们看看它们如何更改此方法的行为。 这里有两个参数的方法调用:

    Before explaining how they work, I would like to explain something that you probably noticed in the diagram above – in the method call, the names of the parameters have to be included before their corresponding values, like this:

    在解释它们如何工作之前,我想解释一下您可能在上图中注意到的一些内容–在方法调用中,必须在参数的相应值之前包括参数名称,如下所示:

    • key=<f>

      key=<f>

    • reverse=<value>

      reverse=<value>

    This is because they are keyword-only arguments. If you are passing a custom value for them, their names have to be specified in the method call, followed by an equal sign = and their corresponding values, like this:

    这是因为它们是仅关键字的参数 。 如果要为它们传递自定义值,则必须在方法调用中指定它们的名称 ,后跟等号=及其对应的值,如下所示:

    Otherwise, if you try to pass the arguments directly as we normally do for positional parameters, you will see this error because the function will not know which argument corresponds to which parameter:

    否则,如果您尝试像通常对位置参数一样直接传递参数,则会看到此错误,因为函数将不知道哪个参数对应于哪个参数:

    TypeError: sort() takes no positional arguments

    逆转 (Reverse)

    Now that you know what keyword-only arguments are, let's start with reverse.

    现在您知道什么是仅关键字参数,让我们从reverse开始。

    The value of reverse can be either True or False:

    reverse的值可以为TrueFalse

    • False means that the list will be sorted in ascending order.

      False表示列表将按升序排序。

    • True means that the list will be sorted in descending (reverse) order.

      True表示列表将以降序(反向)排序。

    💡 Tip: By default, its value is False – if you don't pass any arguments for this parameter, the list is sorted in ascending order.

    💡 提示:默认情况下,其值为False –如果您不为此参数传递任何参数,则列表将按升序排序。

    Here we have a few examples:

    这里有一些例子:

    # List of Integers
    >>> b = [6, 3, 8, 2, 7, 3, 9]
    >>> b.sort()
    >>> b
    [2, 3, 3, 6, 7, 8, 9]
    
    # List of Strings
    >>> c = ["A", "Z", "D", "T", "U"]
    >>> c.sort()
    >>> c
    ['A', 'D', 'T', 'U', 'Z']

    💡 Tip: If the elements of the list are strings, they are sorted alphabetically.

    💡 提示:如果列表中的元素是字符串,则它们将按字母顺序排序。

    # List of Integers
    >>> b = [6, 3, 8, 2, 7, 3, 9]
    >>> b.sort(reverse=True)
    >>> b
    [9, 8, 7, 6, 3, 3, 2]
    
    # List of Strings
    >>> c = ["A", "Z", "D", "T", "U"]
    >>> c.sort(reverse=True)
    >>> c
    ['Z', 'U', 'T', 'D', 'A']

    💡 Tip: Notice how the list is sorted in descending order if reverse is True.

    💡 提示:请注意,如果reverseTrue则列表将按降序排序。

    (Key)

    Now that you know how to work with the reverse parameter, let's see the key parameter.

    现在您知道如何使用reverse参数,让我们来看一下key参数。

    This parameter is a little bit more detailed because it determines how the elements of the list are be compared during the sorting process.

    此参数稍微详细一点,因为它确定在排序过程中如何比较列表中的元素。

    The value of key is either:

    key的值是:

    • None, which means that the elements of the list will be compared directly. For example, in a list of integers, the integers themselves can be used for the comparison.

      None ,这意味着将直接比较列表中的元素。 例如,在整数列表中,整数本身可用于比较。

    • A function of one argument that generates an intermediate value for each element. This intermediate value is calculated only once and it's used to make the comparisons during the entire sorting process. We use this when we don't want to compare the elements directly, for example, when we want to compare strings based on their length (the intermediate value).

      一个参数 函数 ,为每个元素生成一个中间值。 该中间值仅计算一次,并在整个排序过程中用于进行比较。 当我们不想直接比较元素时,例如当我们要根据字符串的长度(中间值)比较字符串时,可以使用它。

    💡 Tip: By default, the value of key is None, so the elements are compared directly.

    💡 提示:默认情况下, key值为None ,因此可以直接比较元素。

    For example:

    例如:

    Let's say that we want to sort a list of strings based on their length, from the shortest string to the longest string. We can pass the function len as the value of key, like this:

    假设我们要根据字符串的长度(从最短的字符串到最长的字符串)对字符串列表进行排序。 我们可以将函数len作为key的值传递,如下所示:

    >>> d = ["aaa", "bb", "c"]
    >>> d.sort(key=len)
    >>> d
    ['c', 'bb', 'aaa']

    💡 Tip: Notice that we are only passing the name of the function (len) without parenthesis because we are not calling the function. This is very important.

    提示:请注意,由于我们没有调用函数,因此仅传递函数名称( len )而没有括号。 这个非常重要。

    Notice the difference between comparing the elements directly and comparing their length (see below). Using the default value of key (None) would have sorted the strings alphabetically (left), but now we are sorting them based on their length (right):

    注意直接比较元素和比较元素长度之间的区别(请参见下文)。 使用key的默认值( None )可以按字母顺序对字符串进行排序(左),但是现在我们根据字符串的长度(右)对其进行排序:

    What happens behind the scenes? Each element is passed as an argument to the len() function, and the value returned by this function call is used to perform the comparisons during the sorting process:

    幕后发生了什么? 每个元素都作为参数传递给len()函数,此函数调用返回的值用于在排序过程中执行比较:

    This results in a list with a different sorting criteria: length.

    这将导致列表具有不同的排序标准:长度。

    Here we have another example:

    这里有另一个例子:

    Another interesting example is sorting a list of strings as if they were all written in lowercase letters (for example, making "Aa" equivalent to "aa").

    另一个有趣的示例是对字符串列表进行排序,就好像它们都是用小写字母书写一样(例如,使“ Aa”等效于“ aa”)。

    According to lexicographical order, capital letters come before lowercase letters:

    根据字典顺序,大写字母先于小写字母:

    >>> "E" < "e"
    True

    So the string "Emma" would come before "emily" in a sorted list, even if their lowercase versions would be in the opposite order:

    因此,即使它们的小写版本的排列顺序相反,字符串"Emma"也将在排序列表中的"emily"之前出现:

    >>> "Emma" < "emily"
    True
    >>> "emma" < "emily"
    False

    To avoid distinguishing between capital and lowercase letters, we can pass the function str.lower as key. This will generate a lowercase version of the strings that will be used for the comparisons:

    为了避免区分大小写字母,我们可以将函数str.lower作为key传递。 这将生成将用于比较的字符串的小写版本:

    >>> e = ["Emma", "emily", "Amy", "Jason"]
    >>> e.sort(key=str.lower)
    >>> e
    ['Amy', 'emily', 'Emma', 'Jason']

    Notice that now, "emily" comes before "Emma" in the sorted list, which is exactly what we wanted.

    请注意,现在,已排序列表中的"Emma"之前是"emily" ,这正是我们想要的。

    💡 Tip: if we had used the default sorting process, all the strings that started with an uppercase letter would have come before all the strings that started with a lowercase letter:

    💡 提示:如果我们使用了默认的排序过程,则所有以大写字母开头的字符串都将排在所有以小写字母开头的字符串之前:

    >>> e = ["Emma", "emily", "Amy", "Jason"]
    >>> e.sort()
    >>> e
    ['Amy', 'Emma', 'Jason', 'emily']

    Here is an example using Object-Oriented Programming (OOP):

    这是使用面向对象编程(OOP)的示例:

    If we have this very simple Python class:

    如果我们有这个非常简单的Python类:

    >>> class Client:
    	def __init__(self, age):
    		self.age = age

    And we create four instances:

    我们创建了四个实例:

    >>> client1 = Client(67)
    >>> client2 = Client(23)
    >>> client3 = Client(13)
    >>> client4 = Client(35)

    We can make a list that references them:

    我们可以列出引用它们的列表:

    >>> clients = [client1, client2, client3, client4]

    Then, if we define a function to get the age of these instances:

    然后,如果我们定义一个函数来获取age这些实例:

    >>> def get_age(client):
    	return client.age

    We can sort the list based on their age by passing the get_age function an an argument:

    我们可以通过将参数get_age传递给参数来根据年龄对列表进行排序:

    >>> clients.sort(key=get_age)

    This is the final, sorted version of the list. We use a for loop to print the age of the instances in the order that they appear in the list:

    这是列表的最终排序版本。 我们使用一个for循环按照实例在列表中出现的顺序来打印实例的寿命:

    >>> for client in clients:
    	print(client.age)
    
    	
    13
    23
    35
    67

    Exactly what we wanted – now the list is sorted in ascending order based on the age of the instances.

    正是我们想要的-现在,列表根据实例的使用期限以升序排序。

    💡 Tip: Instead of defining a get_age function, we could have used a lambda function to get the age of each instance, like this:

    提示:我们可以使用lambda函数来获取每个实例的年龄,而不是定义get_age函数,如下所示:

    >>> clients.sort(key=lambda x: x.age)

    Lambda functions are small and simple anonymous functions, which means that they don't have a name. They are very helpful for these scenarios when we only want to use them in particular places for a very short period of time.

    Lambda函数是小型且简单的匿名函数,这意味着它们没有名称。 当我们只想在特定位置短时间使用它们时,它们对于这些情况非常有用。

    This is the basic structure of the lambda function that we are using to sort the list:

    这是我们用来对列表进行排序的lambda函数的基本结构:

    传递两个参数 (Passing Both Arguments)

    Awesome! Now you know to customize the functionality of the sort() method. But you can take your skills to a whole new level by combining the effect of key and reverse in the same method call:

    太棒了! 现在您知道了自定义sort()方法的功能。 但是您可以通过在同一方法调用中组合keyreverse key的效果,将您的技能提升到一个全新的水平:

    These are the different combinations of the arguments and their effect:

    这些是参数及其效果的不同组合:

    仅关键字参数的顺序不重要 (The Order of Keyword-Only Arguments Doesn't Matter)

    Since we are specifying the names of the arguments, we already know which value corresponds to which parameter, so we can include either key or reverse first in the list and the effect will be exactly the same.

    由于我们正在指定参数的名称,因此我们已经知道哪个值对应于哪个参数,因此我们可以在列表中首先包含keyreverse ,并且效果将完全相同。

    So this method call:

    所以这个方法调用:

    Is equivalent to:

    等效于:

    This is an example:

    这是一个例子:

    >>> a = ["Zz", "c", "y", "o", "F"]
    >>> a.sort(key=str.lower, reverse=True)
    >>> a
    ['Zz', 'y', 'o', 'F', 'c']

    If we change the order of the arguments, we get the exact same result:

    如果更改参数的顺序,则会得到完全相同的结果:

    >>> a = ["Zz", "c", "y", "o", "F"]
    >>> a.sort(reverse=True, key=str.lower)
    >>> a
    ['Zz', 'y', 'o', 'F', 'c']

    🔹返回值 (🔹 Return Value)

    Now let's talk a little bit about the return value of this method. The sort() method returns None – it does not return a sorted version of the list, like we might intuitively expect.

    现在让我们谈谈该方法的返回值。 该sort()方法返回None - 返回列表的排序版本,就像我们可以直观地期待。

    According to the Python Documentation:

    根据Python文档

    To remind users that it operates by side effect, it does not return the sorted sequence.
    为了提醒用户它是有副作用的,它不会返回已排序的序列。

    Basically, this is used to remind us that we are modifying the original list in memory, not generating a new copy of the list.

    基本上,这是用来提醒我们,我们正在修改内存中的原始列表,而不是生成列表的新副本。

    This is an example of the return value of sort():

    这是sort()返回值的示例:

    >>> nums = [6.5, 2.4, 7.3, 3.5, 2.6, 7.4]
    
    # Assign the return value to this variable:
    >>> val = nums.sort()
    
    # Check the return value:
    >>> print(val)
    None

    See? None was returned by the method call.

    看到? 方法调用None返回None

    💡 Tip: It is very important not to confuse the sort() method with the sorted() function, which is a function that works very similarly, but doesn't modify the original list. Instead sorted() generates and returns a new copy of the list, already sorted.

    提示:不要将sort()方法与sorted()函数混淆,这是一个非常相似的函数,但不会修改原始列表,这一点非常重要。 而是sorted()生成并返回已排序的列表的新副本。

    This is an example that we can use to compare them:

    这是一个我们可以用来比较它们的示例:

    This is very important because their effect is very different. Using the sort() method when you intended to use sorted() can introduce serious bugs into your program because you might not realize that the list is being mutated.

    这非常重要,因为它们的效果有很大不同。 当您打算使用sorted()时使用sort()方法可能会在程序中引入严重的错误,因为您可能没有意识到列表已被更改。

    (sort()方法执行稳定的排序 (🔸 The sort() Method Performs a Stable Sort)

    Now let's talk a little bit about the characteristics of the sorting algorithm used by sort().

    现在,让我们来谈谈sort()使用的排序算法的特征。

    This method performs a stable sort because it works with an implementation of TimSort, a very efficient and stable sorting algorithm.

    此方法执行稳定的排序,因为它与TimSort的实现(一种非常有效且稳定的排序算法)一起使用。

    According to the Python Documentation:

    根据Python文档

    A sort is stable if it guarantees not to change the relative order of elements that compare equal — this is helpful for sorting in multiple passes (for example, sort by department, then by salary grade).

    如果可以保证不改变比较相等的元素的相对顺序,则排序是稳定的-这有助于多次通过排序(例如,按部门排序,然后按薪级排序)。

    This means that if two elements have the same value or intermediate value (key), they are guaranteed to stay in the same order relative to each other.

    这意味着,如果两个元素具有相同的值或中间值(键),则保证它们彼此之间保持相同的顺序。

    Let's see what I mean with this. Please take a look at this example for a few moments:

    让我们看看我的意思。 请花一点时间看一下此示例:

    >>> d = ["BB", "AA", "CC", "A", "B", "AAA", "BBB"]
    >>> d.sort(key=len)
    >>> d
    ['A', 'B', 'BB', 'AA', 'CC', 'AAA', 'BBB']

    We are comparing the elements based on their length because we passed the len function as the argument for key.

    我们根据元素的长度进行比较,因为我们将len函数作为key的参数进行了传递。

    We can see that there are three elements with length 2: "BB", "AA", and "CC" in that order.

    我们可以看到有三个长度分别为2的元素: "BB""AA""CC"

    Now, notice that these three elements are in the same relative order in the final sorted list:

    现在,请注意,这三个元素在最终排序的列表中的相对顺序相同:

    This is because the algorithm is guaranteed to be stable and the three of them had the same intermediate value (key) during the sorting process (their length was 2, so their key was 2).

    这是因为保证算法稳定,并且在排序过程中它们三个具有相同的中间值(键)(它们的长度为2,所以它们的键为2)。

    💡 Tip: The same happened with "A" and "B" (length 1) and "AAA" and "BBB" (length 3), their original order relative to each other was preserved.

    💡 提示: "A""B" (长度为1)以及"AAA""BBB" (长度为3)也是如此,它们相对的原始顺序得以保留。

    Now you know how the sort() method works, so let's dive into mutation and how it can affect your program.

    现在您知道sort()方法是如何工作的,让我们深入了解突变及其如何影响程序。

    🔹变异与风险 (🔹 Mutation and Risks)

    As promised, let's see how the process of mutation works behind the scenes:

    如所承诺的,让我们看看突变的过程在幕后如何工作:

    When you define a list in Python, like this:

    在Python中定义列表时,如下所示:

    a = [1, 2, 3, 4]

    You create an object at a specific memory location. This location is called the "memory address" of the object, represented by a unique integer called an id.

    您在特定的内存位置创建一个对象。 此位置称为对象的“内存地址”,由称为id的唯一整数表示。

    You can think of an id as a "tag" used to identify a specific place in memory:

    您可以将id视为用于标识内存中特定位置的“标签”:

    You can access a list's id using the id() function, passing the list as argument:

    您可以使用id()函数访问列表的ID,并将列表作为参数传递:

    >>> a = [1, 2, 3, 4]
    >>> id(a)
    60501512

    When you mutate the list, you change it directly in memory. You may ask, why is this so risky?

    当你发生变异的名单,你直接在内存中修改它。 您可能会问,为什么这样有风险?

    It's risky because it affects every single line of code that uses the list after the mutation, so you may be writing code to work with a list that is completely different from the actual list that exists in memory after the mutation.

    这是有风险的,因为它会影响突变后使用列表的每一行代码,因此您可能正在编写代码以使用与突变后内存中存在的实际列表完全不同的列表。

    This is why you need to be very careful with methods that cause mutation.

    这就是为什么您需要非常小心导致变异的方法的原因。

    In particular, the sort() method mutates the list. This is an example of its effect:

    特别地, sort()方法使列表变异 。 这是其效果的一个示例:

    Here is an example:

    这是一个例子:

    # Define a list
    >>> a = [7, 3, 5, 1]
    
    # Check its id
    >>> id(a)
    67091624
    
    # Sort the list using .sort()
    >>> a.sort()
    
    # Check its id (it's the same, so the list is the same object in memory)
    >>> id(a)
    67091624
    
    # Now the list is sorted. It has been mutated!
    >>> a
    [1, 3, 5, 7]

    The list was mutated after calling .sort().

    调用.sort()之后,该列表发生了变化。

    Every single line of code that works with list a after the mutation has occurred will use the new, sorted version of the list. If this was not what you intended, you may not realize that other parts of your program are working with the new version of the list.

    发生突变后,与list a配合使用的每一行代码都将使用列表的新排序版本。 如果这不是您想要的,您可能不会意识到程序的其他部分正在使用列表的新版本。

    Here is another example of the risks of mutation within a function:

    这是一个函数内发生突变的风险的另一个示例:

    # List 
    >>> a = [7, 3, 5, 1]
    
    # Function that prints the elements of the list in ascending order.
    >>> def print_sorted(x):
    	x.sort()
    	for elem in x:
    		print(elem)
    
    # Call the function passing 'a' as argument	
    >>> print_sorted(a)
    1
    3
    5
    7
    
    # Oops! The original list was mutated.
    >>> a
    [1, 3, 5, 7]

    The list a that was passed as argument was mutated, even if that wasn't what you intended when you initially wrote the function.

    即使作为初始编写函数的初衷,作为参数传递的列表a也会发生突变。

    💡 Tip: If a function mutates an argument, it should be clearly stated to avoid introducing bugs into other parts of your program.

    💡 提示:如果函数改变了参数,则应明确声明该参数,以避免将错误引入程序的其他部分。

    🔸sort()方法摘要 (🔸 Summary of the sort() Method)

    • The sort() method lets you sort a list in ascending or descending order.

      sort()方法使您可以按升序或降序对列表进行排序。

    • It takes two keyword-only arguments: key and reverse.

      它使用两个仅关键字的参数: keyreverse

    • reverse determines if the list is sorted in ascending or descending order.

      reverse确定列表是按升序还是降序排序。

    • key is a function that generates an intermediate value for each element, and this value is used to do the comparisons during the sorting process.

      key是一个为每个元素生成中间值的函数,该值用于在排序过程中进行比较。

    • The sort() method mutates the list, causing permanent changes. You need to be very careful and only use it if you do not need the original version of the list.

      sort()方法会使列表发生变化,从而导致永久更改。 您需要非常小心,仅在不需要列表的原始版本时才使用它。

    I really hope that you liked my article and found it helpful. Now you can work with the sort() method in your Python projects. Check out my online courses. Follow me on Twitter. 👍

    我真的希望您喜欢我的文章并认为对您有所帮助。 现在,您可以在Python项目中使用sort()方法。 查看我的在线课程 。 在Twitter上关注我。 👍

    翻译自: https://www.freecodecamp.org/news/the-python-sort-list-array-method-ascending-and-descending-explained-with-examples/

    python升序和降序排序

    展开全文
  • 总结下java对象升序和降序

    千次阅读 2018-10-18 14:02:49
    //如果想降序,即从大到小排序,那么比较时,如果o1>o2,那么要对比默认的规则 ,反过来 ,让大的一方去左边(意思是你大反而是小,返回-1,往前站,就形成了左--->右,大---小) } else if (dt1.getTime() ()) { ...
    List<Date>list=new ArrayList<Date>();
    Date date1=new Date(2018,10,18,10,10,10);
    Date date2=new Date(2018,10,18,16,10,10);
    Date date3=new Date(2018,10,18,15,10,10);
    Date date4=new Date(2018,10,18,12,10,10);
    list.add(date1);
    list.add(date2);
    list.add(date3);
    list.add(date4);
     Collections.sort(list, new Comparator<Date>() {
         @Override
         public int compare(Date dt1, Date dt2) {
             if (dt1.getTime() > dt2.getTime()) {
                 return -1;
    //关键在这里    其实规则还是 返回1就是大 ,大在右边,返回-1就是小,小在左边
    //如果想升序 ,即从小到大排序,那么比较时 如果o1>o2,则o1返回1  返回1代表在2的右边 。这是默认的正序(意思是你大就是大,大返回1,往后站,就形成了左--->右,小---大)
    
    //============================
    //如果想降序,即从大到小排序,那么比较时,如果o1>o2,那么要对比默认的规则 ,反过来 ,让大的一方去左边(意思是你大反而是小,返回-1,
    展开全文
  • JAVA冒泡排序(升序和降序排序)

    千次阅读 2020-08-15 22:45:32
    import java.util.Arrays; //冒泡排序 public class Test01 { public static void sort(int[] a){//创建排序的方法 int temp=0;//临时变量 for (int i = 0; i < a.length-1; i++) {//外层循环,相当于排序的...
    import java.util.Arrays;
    
    //冒泡排序
    public class Test01 {
        public static void sort(int[] a){//创建排序的方法
            int temp=0;//临时变量
            for (int i = 0; i < a.length-1; i++) {//外层循环,相当于排序的次数
                for (int j = 0; j < a.length-1-i; j++) {//里面循环,每一次排序减去已经拍好i个数。
                    if(a[j]>a[j+1]){//升序排序
                        temp=a[j];
                        a[j]=a[j+1];
                        a[j+1]=temp;
                    }
                }
            }
            return ;
        }
        public static void sort1(int[] a){//创建排序的方法
            int temp=0;//临时变量
            for (int i = 0; i < a.length-1; i++) {//外层循环,相当于排序的次数
                for (int j = 0; j < a.length-1-i; j++) {//里面循环,每一次排序减去已经拍好i个数。
                    if(a[j]<a[j+1]){//降序排序
                        temp=a[j];
                        a[j]=a[j+1];
                        a[j+1]=temp;
                    }
                }
            }
            return ;
        }
        public static void main(String[] args) {
            int[] a={3,2,5,45,3,23,87,345};
            sort(a);//调用升序排序
            System.out.println(Arrays.toString(a));//打印
            //Arrays.sort(a);//Arrays类直接调用排序方法
            //System.out.print(Arrays.toString(a));//打印数组元素
            System.out.println("=====================");
            int[] b={55,4,1,34,53,3,767,8};
            sort1(b);//调用降序排序
            System.out.println(Arrays.toString(b));//打印
        }
    }
    运行结果:
    
    ```java
    D:\tool\jdk-12.0.2_windows-x64_bin\jdk-12.0.2\bin\java.exe "-javaagent:D:\IDEA1\IntelliJ IDEA 2020.2\lib\idea_rt.jar=51169:D:\IDEA1\IntelliJ IDEA 2020.2\bin" -Dfile.encoding=UTF-8 -classpath D:\IDEA1\javaSE\out\production\基础语法 practice.Test01
    [2, 3, 3, 5, 23, 45, 87, 345]
    =====================
    [767, 55, 53, 34, 8, 4, 3, 1]
    
    Process finished with exit code 0
    
    
    
    
    展开全文
  • Java 用 sort 实现对数组的升序和降序排序一、升序二、降序 一、升序 使用 java.util.Arrays 类中的 sort() 方法对数组进行升序分为以下两步: 导入 java.util.Arrays 包。 使用 Arrays.sort(数组名) 语法对数组...
  • java升序和降序排序方法及原理

    千次阅读 2019-08-28 17:23:50
    //排序升序 sort(sortArr); print(sortArr); //排序转置 reverse(sortArr); print(sortArr); } public static void sortArr(int arr[]) { System.out.println("原始数组:"); for (int i = 0; i ; i++) {...
  • Java comparator(升序降序) 官方默认升序,基于: < return -1 = return 0 > return 1 降序,基于 < return 1 = return 0 > return -1 根据其它博客,可看作 comparator反映两个参数的权重,1表示...
  • //降序排序 public int compare(int o1, int o2) { return o2 - o1;; } Comparable中的compareTo方法 //自己实现的比较器,重写compareTo方法,自定义比较规则 //升序排序 @Override public int compareTo(Test o)...
  • 思想就是交换排序,通过比较交换相邻的数据来达到排序的目的。 设数组的长度为N: 1、比较前后相邻的二个数据,如果前面数据大于后面的数据,就将这二个数据交换。 2、这样对数组的第0个数据到N-1个数据进行一次...
  • Pyhon列表排序(升序和降序

    万次阅读 多人点赞 2020-05-14 21:48:32
    一、sort()方法: list.sort(cmp=None, key=None, reverse=False) cmp -- 可选参数, 如果...reverse -- 排序规则,reverse = True 降序, reverse = False 升序(默认)。 #列表升序 list1=['python','java','c++
  • 自然排序:类实现了java.lang.Comparable接口,重写compareTo()的规则 //这里固定指:o1表示位于前面的对象,o2表示后面的对象,并且表示o1比o2小 o1.compareTo(o2) //升序 Collections.sort(persons, new ...
  • 二分法查找升序和降序集合

    千次阅读 2017-07-09 17:21:18
    系统提供的方法是对升序list或数组进行查找 返回的值>0则代表找到,小于0表示没有找到 如果小于0 那么取反则是数据需要插入的位置 list和数组的查找系统提供的方法为 : Collections.binarySearch() ...
  • Java学习中会遇到对数组进行升序或者降序排序的问题 Java语言提供给我们Array.sort(int [] arr)对数组进行升序排列 import java.util.Arrays; public class Test1 { public static void main(String[] args) { ...
  • java中对数组进行排序 使用Array.sort() 这个默认是升序 @Test public void index4(){ int scores[] = new int[]{1,2,3,89,4}; Arrays.sort(scores); for (int i:scores ) { System.out.println(i); } }...
  • 输入整型数组排序标识,对其元素按照升序降序进行排序(一组测试用例可能会有多组数据) 本题有多组输入,请使用while(cin>>)处理 输入描述 第一行输入数组元素个数 第二行输入待排序的数组,每个数用...
  • 1.几种情况说明: ...* 排序结果为降序 */ public int compare(int i1,int i2){ retrun i2 - i1; } /** * 排序结果为升序 * 定义Role类中有id属性 */ public int compareTo(Role role){ retrun thi.
  • Java TreeMap 升序|降序排列

    千次阅读 2017-12-06 13:52:38
    import java.util.Comparator;  import java.util.TreeMap;  public class Main {   public static void main(String[] args) {   TreeMap&lt;Integer,Integer&gt; map1 = new ...
  • 第三种,第二种一样,不过使用匿名类 public class CollectionsClass {    /**  * @param args  */  public static void main(String[] args) {  List<BeanClass> list = new ArrayList();  Bean...
  • Java中对数组进行升序或者降序排序 升序排列: Java提供了Array.sort(int [] arr)函数对数组进行升序排列 package pack; import java.util.Arrays; public class testsort { public static void main(String[] ...
  • Arrays的sort方法可以直接对数据进行升序和降序排列。本人小白,前段时间刚学到sort方法时,看到Arrays操作数组只能升序,使用了很多奇怪的办法来进行降序。例如: import java.util.Arrays; public class ...
  • java8 使用stream进行排序(多字段排序、升序降序)
  • Java排序之升序降序

    2019-03-22 09:44:00
    以前在学校学排序的时候,总是自己写排序的代码,真正到工作中,直接使用java提供的排序方法,但最近发现行业默认的学习时有些不一样。  以前总是在进行排序时如果前边的数字后边数字的差为负则交换两个数字的...
  • 在数组的排序中使用java中提供的Arrays.sort方法相当的方便;这个方法可以快速对数组进行 排序,但是这个方法的弊端就是它只能进行升序操作。 语法:Arrays.sort(要排序的数组) int arr[]= { 25,45,32,64...
  • Java Collections.sort()升序降序问题

    千次阅读 2019-02-01 10:35:35
    实体类实现Comparable&lt;?&gt;接口,重写   上图为降序     上图为升序
  • //升序 默认升序 //list.sort((o1,o2) -> 1 * o1.getNo().compareTo(o2.getNo())); list.sort((o1,o2) -> o1.getNo().compareTo(o2.getNo())); System.out.println(list.toString()); System.out.println("-------...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 47,291
精华内容 18,916
关键字:

升序和降序java

java 订阅