精华内容
下载资源
问答
  • 2022-05-02 21:45:30

    排序

    Golang中sort包下提供了一些基本切片的排序

    sort.Ints(arr)
    sort.Float64s()
    sort.Strings()
    

    但是这些排序逻辑都是固定的,例如 sort.Intes()默认就是按升序进行排序的,Golang也提供了一个接口进行自定义逻辑排序

    sort.Sort()方法,这个方法需要传入Interface类型的对象

    func Sort(data Interface) {
       n := data.Len()
       quickSort(data, 0, n, maxDepth(n))
    }
    

    Interface接口定义

    type Interface interface {
       Len() int
       Less(i, j int) bool
       Swap(i, j int)
    }
    

    我们只需要实现这个Interface接口即可

    下面以[]int降序排序以及自定义User结构体按年龄排序两种场景进行解释

    1. []int降序排序
    type intByDesc []int
    
    func (arr intByDesc) Len() int {
       return len(arr)
    }
    func (arr intByDesc) Less(i, j int) bool {
       return arr[i] > arr[j]
    }
    func (arr intByDesc) Swap(i, j int) {
       temp := arr[i]
       arr[i] = arr[j]
       arr[j] = temp
    }
    func main() {
    
       arr := []int{10, 20, 30, 15}
       var byDesc intByDesc = arr
       sort.Sort(byDesc)
       fmt.Println(byDesc)
    }
    
    1. 自定义数据类型排序
    package main
    
    type User struct {
       age  int
       name string
    }
    
    type UsersByAge []User
    
    func (u UsersByAge) Len() int {
       return len(u)
    }
    
    func (u UsersByAge) Less(i, j int) bool {
       return u[i].age < u[j].age
    }
    
    func (u UsersByAge) Swap(i, j int) {
       temp := u[i]
       u[i] = u[j]
       u[j] = temp
    }  
    
    更多相关内容
  • 主要介绍了Java针对ArrayList自定义排序的2种实现方法,结合实例形式总结分析了Java操作ArrayList自定义排序的原理与相关实现技巧,需要的朋友可以参考下
  • 主要介绍了python3 sorted 如何实现自定义排序标准,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 主要介绍了JAVA使用Comparator接口实现自定义排序,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • java数组自定义排序

    2017-10-31 15:35:59
    java中数组的自定义排序,种类繁多,简单实现,可自由操控。
  • 学习一门编程语言,要掌握原子数据类型,还需要掌握自定义数据类型。下面这篇文章主要给大家介绍了关于golang如何对自定义类型进行排序的相关资料,文中通过示例代码介绍的非常详细,需要的朋友可以参考下。
  • * 二维数组自定义排序函数 * uasort($arr,function_name) * **/ $arr = array( array('a'=>1,'b'=>'c'), array('a'=>4,'b'=>'a'), array('a'=>5,'b'=>'g'), array('a'=>7,'b'=>'f'), array('a'=>6,'b'=>'e') );...
  • [javascript] 代码如下:var studs = [{name: ‘clap’, age: 15}, {name: ‘martin’, age: 13}, {name: ‘merry’, age: 10}]; function sortbyage(a, b) { //按... } //按年龄排序 studs.sort(sortbyage); for(v
  • 主要介绍了list泛型自定义排序示例,实现List泛型类将制定元素至前排序,大家参考使用吧
  • 主要介绍了Java自定义比较器实现中文排序,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 下面小编就为大家带来一篇MySQL 按指定字段自定义列表排序的实现。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 排序规则是默认的,数字、时间、字符串等都有自己默认的排序规则。有时候需要按自己的想法来排序,而不是按字段默认排序规则。 比如字段值为英文字段:Monday、Tuesday、Wednesday等,如果按字段默认排序规则就为...
  • 主要介绍了php自定义排序uasort函数,结合实例形式分析了php实现二维数组按指定键值排序的相关操作技巧,需要的朋友可以参考下
  • Lucene中的自定义排序功能和Java集合中的自定义排序的实现方法差不多,都要实现一下比较接口. 在Java中只要实现Comparable接口就可以了.但是在Lucene中要实现SortComparatorSource接口和ScoreDocComparator接口.在...
  • table table自定义排序;目前支持数值排序,文本(支持中文)排序; 示例: var option = { tableid: '#tableid', sortindex: 7, sorttype: "down", sortby: "text" }; $("#tableid").sortTable(option);
  • 本文主要讲解ASP.NET 2.0中使用GridView创建自定义排序,主要演示在一组相同类别的数据前添加分界行,让用户更容易区分不同组的数据。
  • java自定义排序

    2022-04-22 17:08:30
    java中sort的自定义排序一、Arrays.sort(nums)的一般用法二、最大数(力扣179)三、合并区间(力扣59) 一、Arrays.sort(nums)的一般用法 整个数组按照升序排序 若需要降序排序,将数组转置即可 int[] testNums =...


    一、Arrays.sort(nums)的一般用法

    1. 整个数组按照升序排序
      若需要降序排序,将数组转置即可
    int[] testNums = {1,3,6,5,4,1,2,8};
    Arrays.sort(testNums);
    System.out.println(Arrays.toString(testNums));
    
    //输出:[1, 1, 2, 3, 4, 5, 6, 8]
    
    1. 对指定范围内的数组元素进行排序
    int[] testNums2 = {1,3,6,5,4,1,2,8};
    Arrays.sort(testNums2,1,6);
    System.out.println(Arrays.toString(testNums2));
    
    //输出:[1, 1, 3, 4, 5, 6, 2, 8]
    
    1. 自定义排序
      二维数组排序为例,比如,将:[[1,2],[3,4],[1,3],[2,4]] 按照每个一维数组的和的升序进行排序
    int[][] testNums3 = {{1,2},{3,4},{1,3},{2,4}};
    Arrays.sort(testNums3, new Comparator<int[]>() {
        @Override
        public int compare(int[] o1, int[] o2) {
            return (o1[0]+o1[1])-(o2[0]+o2[1]);
        }
    });
    for (int[] nums:testNums3){
        System.out.println(Arrays.toString(nums));
    }
    
    /*
        输出:
            [1, 2]
            [1, 3]
            [2, 4]
            [3, 4]
     */
    
    • 若要实现自定义排序,要给sort()函数传入一个继承Comparator接口的对象,在compare方法中定义自己的排序规则。
    • compare函数返回一个int类型:
      • o1,o2可以看成原数组中相邻的前后两个元素。返回值可以看成o1-o2的值。
      • 若返回负数,则说明o1-o2<0,sort方法将数组按升序(o1,o2)排列。
      • 反之若返回正数,说明o1-o2>0,按降序(o2,o1)排列。
      • 注意这里o1和o2并不一定能直接相加减,以上只是提供初学者一种记忆的方法,还是需要在实战中理解,接下来以两道算法题具体说明sort函数的一些应用。

    注意,要想改变默认的排列顺序,不能使用基本类型(int,double, char) ,而要使用它们对应的包装类。

    二、最大数(力扣179)

    原题连接
    在这里插入图片描述

    分析:先考虑两个数的情况,假设有两个数num1,num2,则答案要么是num1+num2,要么是num2+num1(注意这里的+表示拼接操作:1+2 = 12
    定义num1>num2:num1+num2>num2+num1,举例说明:因为"3"+“31”=“331”>“31”+“3”=“313”,所以"3">“31”。
    不难看出,当整个数组都按照我们定义的大小关系降序排序,最后依次拼接即为结果。比如:“31”>“30”>“2”,"31302"为所求最大数。代码如下:

    public class Solution179 {
        /*
            给定一组非负整数 nums,重新排列每个数的顺序(每个数不可拆分)使之组成一个最大的整数。
            注意:输出结果可能非常大,所以你需要返回一个字符串而不是整数。
    
            输入:nums = [3,30,34,5,9]
            输出:"9534330"
            链接:https://leetcode-cn.com/problems/largest-number/
         */
        public static void main(String[] args) {
            int[] nums = {0,20,2190,5,38,21,1};
            System.out.println(Solution.largestNumber(nums));
        }
        static class Solution {
    	    public static String largestNumber(int[] nums) {
    	        String ans = "";
    	        String[] temp = new String[nums.length];
    	        for (int i = 0; i < nums.length; i++) {
    	            temp[i] = Integer.toString(nums[i]);
    	        }
    	
    	        Arrays.sort(temp, new Comparator<String>() {
    	            @Override
    	            public int compare(String o1, String o2) {
    	                String o12 = o1+o2,o21 = o2+o1;
    	                for (int i = 0; i < o12.length(); i++) {//逐个比较对应字符的大小
    	                    //返回负数,顺序为(o1,o2)
    	                    if(o12.charAt(i)>o21.charAt(i)) return -1;
    	                    //返回正数,顺序为(o2,o1)
    	                    else if(o12.charAt(i)<o21.charAt(i)) return 1;
    	                    //无论是那种顺序,字符大的都在前面,因此是按降序排列
    	                }
    	                //若直到最后一个字符都相等,按照最后一个字符的大小来决定
    	                return o12.charAt(o12.length()-1)<o21.charAt(o21.length()-1)?1:-1;
    	            }
    	        });
    	        for (String s :
    	                temp) {
    	            ans += s;
    	        }
    	        return ans;
    	    }
    	}
    }
    

    三、合并区间(力扣59)

    原题连接
    在这里插入图片描述

    分析:首先对intervals进行排序,排序规则为第一列按升序,第一列相等时第二列按降序,例如:[1,2]>[0,3],[2,2]>[2,3](思考为什么要这样排序)。
    然后再遍历intervals进行合并。

    • 合并的过程中维护两个数值,左端点L,右端点R。
    • 一开始先给L和R赋初值为第一个区间的端点值,遍历intervals。
    • 若左端点和L相同,直接跳过(和一开始的排序有关)。
    • 若左端点大于L且大于R,说明L,R之间没有重叠区域了,记录L,R,并更新为当前区间的左右端点。
    • 若左端点大于L但是小于等于R,可能有重叠区域,将R更新为R与右端点之间的最大值。
    • 遍历结束后判断L,R是否记录。代码如下:
    /*
        以数组 intervals 表示若干个区间的集合,其中单个区间为 intervals[i] = [starti, endi] 。
        请你合并所有重叠的区间,并返回一个不重叠的区间数组,该数组需恰好覆盖输入中的所有区间。
    
        [[1,3],[1,2],[2,6],[8,10],[15,18]]
    
        输入:intervals = [[1,3],[2,6],[8,10],[15,18]]
        输出:[[1,6],[8,10],[15,18]]
        解释:区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
    
        链接:https://leetcode-cn.com/problems/merge-intervals
     */
    public class Solution56 {
        public static void main(String[] args) {
            int[][] intervals =  {{1,3},{1,2},{2,6},{8,10},{15,18},{19,20}};
    //        int[][] intervals =  {{1,4},{0,4}};
            System.out.println(Arrays.deepToString(Solution.merge(intervals)));
    
        }
    
        private static class Solution {
            public static int[][] merge(int[][] intervals) {
                //1.第一维升序,第二维降序进行排序
                //2.遍历数组,记录当前区间的端点;
                // 若下一个区间的左端点相同,直接跳过;若大于前一个的右端点,记录前一个区间,更新区间的左右端点;若小于前一个的右端点,则存在重合区域,更新区间端点
                int[][] ans = new int[10005][2];
                Arrays.sort(intervals, new Comparator<int[]>() {
                    @Override
                    public int compare(int[] o1, int[] o2) {
                        if(o1[0]!=o2[0]) return o1[0]-o2[0];
                        else return o2[1]-o1[1];
                    }
                });
    
                int L = 0,R = 0;//左右端点
                int nums = 0;//合并后的区间个数
                for (int i = 0; i < intervals.length; i++) {
                    if(i==0){
                        L = intervals[0][0];R = intervals[0][1];continue;
                    }
                    if(intervals[i][0]==L) continue;//左区间端点相等直接跳过
                    else if (intervals[i][0]>L){ //左区间端点大于前一个的左区间端点
                        if(intervals[i][0]>R){  //仍然大于右区间端点,记录
                            ans[nums][0] = L;ans[nums][1] = R;L = intervals[i][0];R = intervals[i][1];nums++;
                        }
                        else {//若小于等于右区间端点,比较它的右端点和原右端点的值,更新R
                            R = Math.max(intervals[i][1],R);
                        }
                    }
    
    
                }
    
                //存在结束循环但是最后一个区间还没有加入ans的情况
                //最后一个区间也是首个区间
                if(nums==0) {ans[nums][0]=L;ans[nums][1]=R;}
                //最后一个区间不是首个区间的话只需要判断左端点是否相等,不相等说明还没有记录
                if(nums!=0 && ans[nums][0]!=L) {ans[nums][0]=L;ans[nums][1]=R;}
    
                return Arrays.copyOfRange(ans,0,nums+1);
            }
        }
    }
    

    四、总结

    在理解各类排序算法的情况下,熟练使用Arrays.sort()方法解决问题,尤其掌握Comparator接口的写法!

    展开全文
  • MySQL常规排序、自定义排序和按中文拼音字母排序,在实际的SQL编写时,我们有时候需要对条件集合进行排序。 下面给出3种比较常用的排序方式,mark一下 1.常规排序ASC DESC ASC 正序 DESC倒叙 — 此处不用多讲 2....
  • SQL自定义排序

    2012-02-15 00:23:17
    在查询表时,当表的排序列并非所想要的排序方式并且不能修改表的排序数据时,这个自定义Order By来排序的SQL非常有用,只需要一句简单的查询。
  • JAVA实现自定义排序

    2021-12-16 11:22:28
    JAVA collections.sort中文自定义排序

    一、需求:

    最近接到一个需求,要求对成绩单的成绩进行排序。不是按照成绩排序,而是按照课程类别和上课的时间进行排序。我首先想到的是双循环,但是我认为这样的话if-else要写到猴年马月。

    之后我开始回忆以前的数据结构了,不论是二分法还是快排,他们分明比较的都是数字大小啊,字符串虽然可以比较,但是现在课程的排序是人为自定义的,我怎么比较呢?

    二、问题:

    根据现在遇到的情况我就认为,想要排序必然要把字符串转换成数字,毕竟排序都是数字的,那么只有这样才能够直接比较。因此很自然的需要创建一个HashMap存放课程类别和它对应的大小。

    成绩单长这样。
    在这里插入图片描述

    三、业务介绍

    我这里的课程类别是一个对象,因为课程类别里面有一级学科二级学科这样,不过这是业务知识不重要,因此直接开始讲我的解决方案。在实际业务当中,数据还有老成绩和新成绩的说法,所以判断的地方非常多,有一点点小复杂。

    四、代码

    使用的是Collections下的sort方法,传入你需要排序的List以及排序方法。

    //自定义排序1
    Collections.sort(list, new Comparator<Student>() {
        @Override
        public int compare(Student o1, Student o2) {
            return o1.getId() - o2.getId();
        }
    });
    

    前面提到过,既然是自定义排序,那么一定要对排序的东西事先定义好排序大小。

    //为给课程排序,自定义排序规则,key是course_category的id,value是排名
        private static Map<Long,Integer> zsCourseSortMap = new HashMap<>();//专硕
        private static Map<Long,Integer> xsCourseSortMap = new HashMap<>();//学硕
        static {
            xsCourseSortMap.put(1249L,0);//学位公共课(必修)
            xsCourseSortMap.put(18L,1);//学位基础课(必修)
            xsCourseSortMap.put(19L,2);//学位专业课(必修)
            xsCourseSortMap.put(20L,3);//学位专业课(选修)
            xsCourseSortMap.put(21L,4);//跨学科或跨专业课程(选修)
            xsCourseSortMap.put(23L,5);//公共选修课
            xsCourseSortMap.put(-1L,100);//其它
    
            zsCourseSortMap.put(1254L,0);//公共课 必修
            zsCourseSortMap.put(1265L,0);//公共课 通识
            zsCourseSortMap.put(18L,1);//学位基础课
            zsCourseSortMap.put(670L,2);//专业必修课
            zsCourseSortMap.put(671L,3);//专业选修课
            zsCourseSortMap.put(672L,4);//专业实践
            zsCourseSortMap.put(-1L,100);//
        }
    

    解释一下,这里的Key是课程类别对象的id,value是我自定义的大小,到时候只需要判断类别的id就能判断是哪一门课类别,之所以不直接存对象是我觉得这里new对象是一件很麻烦的事情,如果还要从数据库中一个个找出来存好,或许增加了不必要的开销。使用static是因为这些资源是亘古不变的,不随对象的变化而变化。


    这里介绍一下传入的成绩列表。传进去的每一个成绩实际上是一个Map而不是Score对象。因为业务上表要达到范式要求,表的属性不能要啥都有啥,很多时候是精简的,Score本身可能并不存课程类别之类的。因此实际上获取的数据是已经封装好的Map格式

    List<Map<String, Object>> scoreList;
    
    private void sortScoreListByCategory(List<Map<String,Object>> scoreList, Map<Long,Integer> degreeTypeMap) {
            Collections.sort(scoreList, new Comparator<Map<String, Object>>() {
                @Override
                public int compare(Map<String, Object> o1, Map<String, Object> o2) {
                    CourseCategory o1Category = new CourseCategory();
                    CourseCategory o2Category = new CourseCategory();
                    if( o1.get("courseCategory") instanceof CourseCategory) { //能否转型
                        o1Category = (CourseCategory) o1.get("courseCategory");
                    } else {
                        Map map1 =(Map) o1.get("courseCategory");
                        o1Category = courseCategoryRepository.findByFirstCategoryAndSecondCategory(map1.get("firstCategory").toString(), map1.get("secondCategory").toString());
                    }
                    if( o2.get("courseCategory") instanceof CourseCategory) {
                        o2Category = (CourseCategory) o2.get("courseCategory");
                    } else {
                        Map map2 =(Map) o2.get("courseCategory");
                        o2Category = courseCategoryRepository.findByFirstCategoryAndSecondCategory(map2.get("firstCategory").toString(), map2.get("secondCategory").toString());
                    }
    
                    String o1studyTime = (String) o1.get("studyTime");
                    String o2studyTime = (String) o2.get("studyTime");
                    if(o1Category.getId() != o2Category.getId()) { //判断课程类别ID是否相等
                        return degreeTypeMap.get(o1Category.getId()) == null ? degreeTypeMap.get(-1L) : degreeTypeMap.get(o1Category.getId()).compareTo(degreeTypeMap.get(o2Category.getId()) == null ? degreeTypeMap.get(-1L) : degreeTypeMap.get(o2Category.getId()));
                    } else if (!o1studyTime.equals(o2studyTime)){
                        return o1studyTime.compareTo(o2studyTime);
                    }
                    return 0;
                }
            });
        }
    

    五、代码解释
    根据最上面的格式,sort传进去一个List和comparator。degreeTypeMap是最前面第二个自定义的Map排序规则,要用到。

    compare里面其实就是传进去两个List里存放的两个随意对象。因为本质是两两比较。
    严谨点需要先判断,Map里取出的courseCategory(课程类别)能不能转型成课程类别,如果不能则说明是老数据(业务问题),从数据库中找出这个课程类别对象。那么至此就获取了需要比较的这两个对象的课程类别。

    核心: 关键就是下面的如果课程类别的id不相等则说明要比较,然后从自定义的Map中获取这门课程类别的排序值,但是这里需要多一个判断,因为自定义排序可能有其他的类型,如果没有找到这门课的课程类别说明是其它,按照其它处理。
    获取两门课的排序值以后,直接对他门进行.compareTo就行了当然相减也可以。

    如果课程类别的id一样则再判断他们课程的学年就行了,这里因为学年是时间字符串,可以直接比较。

    升序降序

    @Override
        public int compareTo(Student o1, Student o2) {
            //降序
            //return o1.compareTo(o2);
            //升序
            return o2.compareTo(o1);        
        }
    

    根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数

    降序就是由下往上是从大到小。

    暂时先这样写

    展开全文
  • Java List 自定义排序

    2021-02-05 13:40:03
    System.out.println("========== 排序前 ========="); for (MyStudent myStudent : students){ System.out.println("姓名:" + myStudent.getName() + ", 年龄:" + myStudent.getAge()); } System.out.println("=...

    不多说直接看代码:

    package leecode.sort;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    
    /**
     * @author: zjf
     * @description:
     * @date: 2021/2/3 下午6:03
     */
    public class ArrayList_Sort {
        public static void main(String[] args) {
            my_arraylist_sort();
        }
    
        public static void my_arraylist_sort(){
            ArrayList<MyStudent> students = new ArrayList<>();
            students.add(new MyStudent("z", 5));
            students.add(new MyStudent("c", 78));
            students.add(new MyStudent("v", 18));
    
            System.out.println("========== 排序前 =========");
            for (MyStudent myStudent : students){
                System.out.println("姓名:" + myStudent.getName() + ", 年龄:" + myStudent.getAge());
            }
    
            System.out.println("========== 按照年龄排序 =========");
            Collections.sort(students, new sortByAge());
            for (MyStudent myStudent : students){
                System.out.println("姓名:" + myStudent.getName() + ", 年龄:" + myStudent.getAge());
            }
    
            System.out.println("========== 按照姓名排序 =========");
            Collections.sort(students, new sortByName());
            for (MyStudent myStudent : students){
                System.out.println("姓名:" + myStudent.getName() + ", 年龄:" + myStudent.getAge());
            }
        }
    
    }
    
    
    class sortByName implements Comparator<MyStudent>{
        @Override
        public int compare(MyStudent o1, MyStudent o2) {
            return o1.getName().compareTo(o2.getName());
        }
    }
    
    
    class sortByAge implements Comparator<MyStudent>{
        @Override
        public int compare(MyStudent o1, MyStudent o2) {
            int age1 = o1.getAge();
            int age2 = o2.getAge();
            if (age1 == age2) {
                return 0;
            }else {
                // 从小到大; 如果需要从大到小,可以将return的值反过来即可
                return age1 > age2 ? 1 : -1 ;
            }
        }
    }
    
    
    class MyStudent {
        private String name;
        private int age;
    
        public MyStudent(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
    
    展开全文
  • Java 自定义排序

    千次阅读 2021-12-12 18:25:20
    java sort Comparable Comparable 可以认为是一个内比较器,实现了...如果开发者 add 进入一个 Collection 的对象想要 Collections 的 sort 方法帮你自动进行排序的话,那么这个对象必须实现 Comparable 接口。compareT
  • C++:map自定义排序

    千次阅读 多人点赞 2019-09-19 23:17:54
    甚至我一度怀疑我lambda写错了,然后换了自定义比较函数也不起作用;然后看了下sort支持二元谓词函数的啊;最后在网上找到相关解释了,记录一下吧。 map排序: map中的元素是关键字—值(key-val...
  • lucene自定义排序实现

    2015-05-24 23:11:00
    lucene自定义排序实现,大家有兴趣关注我的博客http://blog.csdn.net/wuyinggui10000/article/category/3173543
  • Go 自定义排序方法

    2021-12-02 12:55:16
    Go 自定义排序方法 前言 我们经常需要对数组进行排序,Go内置的sort包提供了一些排序函数来帮助我们实现排序。 对于[]int、[]float、[]string这些基础类型数组,使用sort包提供的下面几个函数进行排序: sort.Ints ...
  • 自定义排序规则怎么嵌入到sort排序函数中 知识点1: 1.自定义排序规则的编写 类似于这样:person是自定义结构体 bool sort_list(person& p1, person& p2) { if (p1.age == p2.age) return p1....
  • mysql自定义排序

    2022-05-27 22:35:28
    记录下最近遇到的一个mysql的自定义排序使用场景 在查询数据时想根据多个条件进行排序,其中有个是自定义的顺序,这时就需要用到FIELD函数。 可以参照一下方法 select * from 表名 where id in (519,531,521,536,520...
  • 易语言自定义数据类型数组排序源码,自定义数据类型数组排序,更新超级列表框,取随机品名,根据产地排序,根据类别排序,根据售价排序

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 384,662
精华内容 153,864
关键字:

怎样自定义排序