精华内容
下载资源
问答
  • 常用排序方法

    2018-09-01 17:09:51
    分别实现1)直接插入排序,2)冒泡排序;3)简单选择排序 ;4)希尔排序 5)快速排序
  • 常用排序方法汇总

    2018-11-13 10:00:00
    常用排序方法汇总 此篇博客为常用排序方法汇总帖: *点击即可查看详情 (1)冒泡排序 Bubble Sort (2)选择排序 Select Sort (3)插入排序 Insert Sort (4)希尔排序 Shell Sort (5)归并排序 Merge Sort...

    常用排序方法汇总

    此篇博客为常用排序方法汇总帖:

    *点击即可查看详情

    (1)冒泡排序  Bubble Sort

    (2)选择排序  Select Sort

    (3)插入排序  Insert Sort

    (4)希尔排序  Shell Sort

    (5)归并排序  Merge Sort

    (6)堆排序     Heap Sort

    (7)快速排序  Quick Sort

     

    转载于:https://www.cnblogs.com/iwangzhengchao/p/9846519.html

    展开全文
  • 主要介绍了js常用排序方法实例代码解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • C语言常用排序方法大全 C语言常用排序方法大全
  • Java之常用排序方法

    2020-02-18 14:06:27
    Java之常用排序方法参考链接Collections.sort实现源码解析Conllection中的sort方法实现排序十大经典排序算法Collections.sort排序案例简介List排序方式1:Entity实现Comparator接口方式2:自定义比较器实现...

    Collections.sort排序案例

    简介

    • 原理

      归根结底Collections就是调用Arrays的sort方法

    • 源码

      
          @SuppressWarnings({"unchecked", "rawtypes"})
          default void sort(Comparator<? super E> c) {
              Object[] a = this.toArray();
              Arrays.sort(a, (Comparator) c);
              ListIterator<E> i = this.listIterator();
              for (Object e : a) {
                  i.next();
                  i.set((E) e);
              }
          }
      
      
      
    • 备注

      Arrays的排序采用的是插入排序和归并排序,当数组长度较小时直接插入排序

    List排序

    • Comparator调用的两种使用方式

      
          Collections.sort(list,Comparator<T>;
          //List.sort方法是JDK8之后才有的
          list.sort(Comparator<T>);
      
      

    方式1:Entity实现Comparator接口

    • 自定义Entity

      
          package com.neighbor.nbsp.entity;
      
          /**
          * @ClassName Student
          * @Description TODO 学生实体类$
          * @Author charlesYan
          * @Date 2020/2/18 11:06
          * @Version 1.0
          **/
          public class Student implements Comparable<Student> {
      
              private int id;
              private int score;
              private String name;
      
              public Student() {
              }
      
              public Student(int id, int score, String name) {
                  this.id = id;
                  this.score = score;
                  this.name = name;
              }
      
              public int getId() {
                  return id;
              }
      
              public void setId(int id) {
                  this.id = id;
              }
      
              public int getScore() {
                  return score;
              }
      
              public void setScore(int score) {
                  this.score = score;
              }
      
              public String getName() {
                  return name;
              }
      
              public void setName(String name) {
                  this.name = name;
              }
      
              @Override
              public int compareTo(Student o) {
                      /**
                      * @Description //升序
                      **/
                      //写法一
                      return this.score - o.score;
      
                      //写法二
              //        if((this.score - o.score) > 0)
              //            return 1;
              //        else if((this.score - o.score) < 0)
              //            return -1;
              //        else
              //            return 0;
      
                      /**
                      * @Description //降序
                      **/
                      //写法一
              //        return o.score - this.score;
      
                      //写法二
              //        if((this.score - o.score) > 0)
              //            return -1;
              //        else if((this.score - o.score) < 0)
              //            return 1;
              //        else
              //            return 0;
              }
      
              @Override
              public String toString() {
                  return "Student{" +
                          "id=" + id +
                          ", score=" + score +
                          ", name='" + name + '\'' +
                          '}';
              }
          }
      
      
      
      
    • 测试main方法

      
          public static void main(String[] args) {
      
      
              List<Student> list = new ArrayList<>();
              list.add(new Student(1, 90, "ellin"));
              list.add(new Student(2, 98, "charles"));
              list.add(new Student(3, 78, "frank"));
              //使用默认排序
              Collections.sort(list);
              list.forEach(s -> System.out.println(s.toString()));
      
          }
      
      
      

    方式2:自定义比较器实现Comparator接口

    • 自定义对象

      
          package com.neighbor.nbsp.entity;
      
          /**
          * @ClassName User
          * @Description TODO 用户实体类$
          * @Author charlesYan
          * @Date 2020/2/18 11:49
          * @Version 1.0
          **/
          public class User {
      
              private int id;
              private int age;
              private String name;
      
              public User() {
              }
      
              public User(int id, int age, String name) {
                  this.id = id;
                  this.age = age;
                  this.name = name;
              }
      
              @Override
              public String toString() {
                  return "User{" +
                          "id=" + id +
                          ", age=" + age +
                          ", name='" + name + '\'' +
                          '}';
              }
      
              public int getId() {
                  return id;
              }
      
              public void setId(int id) {
                  this.id = id;
              }
      
              public int getAge() {
                  return age;
              }
      
              public void setAge(int age) {
                  this.age = age;
              }
      
              public String getName() {
                  return name;
              }
      
              public void setName(String name) {
                  this.name = name;
              }
          }
      
      
      
    • 自定义比较器

      
          package com.neighbor.nbsp.utils;
      
          import com.neighbor.nbsp.entity.User;
      
          import java.util.Comparator;
      
          /**
          * @ClassName MyComparator
          * @Description TODO 自定义比较器$
          * @Author charlesYan
          * @Date 2020/2/18 11:47
          * @Version 1.0
          **/
          public class MyComparator implements Comparator<User> {
      
              @Override
              public int compare(User o1, User o2) {
                  return o1.getAge() - o2.getAge();
              }
          }
      
      
      
      
      
    • 测试main方法

      
          public static void main(String[] args) {
      
              List<User> list = new ArrayList<>();
              list.add(new User(1, 90, "ellin"));
              list.add(new User(2, 98, "charles"));
              list.add(new User(3, 78, "frank"));
              //使用默认排序
              Collections.sort(list,new MyComparator());
              list.forEach(s -> System.out.println(s.toString()));
      
          }
      
      
      

    方式3:使用匿名类(常用)

    • 测试main方法

      
          public static void main(String[] args) {
      
              List<User> list = new ArrayList<>();
              list.add(new User(1, 90, "ellin"));
              list.add(new User(2, 98, "charles"));
              list.add(new User(3, 78, "frank"));
              //使用升序排序
              //方式1
      //        Collections.sort(list, new Comparator<User>() {
      //            @Override
      //            public int compare(User o1, User o2) {
      //                return o1.getAge() - o2.getAge();
      //            }
      //        });
      
              //方式2
              list.sort(new Comparator<User>() {
                  @Override
                  public int compare(User o1, User o2) {
                      return o1.getAge() - o2.getAge();
                  }
              });
              list.forEach(s -> System.out.println(s.toString()));
          }
      
      
      

    Set排序

    • 概念

      set包括HashSet和TreeSet,HashSet是基于HashMap的,TreeSet是基于TreeMap的。

      TreeMap是用红黑树实现,天然就具有排序功能,“天然就具有排序功能”是指它拥有升序、降序的迭代器。

      对于HashSet,将HashSet转成List,然后用List进行排序,或者转换成Arrays排序

    实现案例

    • 测试main方法

      
          public static void main(String[] args) {
      
              //HashSet排序
              Set<User> set = new HashSet<>();
              set.add(new User(1, 90, "ellin"));
              set.add(new User(2, 98, "charles"));
              set.add(new User(3, 78, "frank"));
      
              List<User> list = new ArrayList<>(set);
              Collections.sort(list, new Comparator<User>() {
                  @Override
                  public int compare(User o1, User o2) {
                      return o1.getAge() - o2.getAge();
                  }
              });
              list.forEach(s -> System.out.println(s.toString()));
      
              //TreeSet排序
              TreeSet<User> treeSet = new TreeSet<>(new Comparator<User>() {
                  @Override
                  public int compare(User o1, User o2) {
                      return o1.getAge() - o2.getAge();
                  }
              });
      
              treeSet.add(new User(1, 90, "ellin"));
              treeSet.add(new User(2, 98, "charles"));
              treeSet.add(new User(3, 78, "frank"));
              treeSet.forEach(s -> System.out.println(s.toString()));
      
          }
      
      
      

    Map排序

    • 概念

      map包括HashMap和TreeMap,上面已经提过,TreeMap用红黑树实现,天然具有排序功能。

      那么HashMap怎么按“key”排序呢?方法很简单,用HashMap来构造一个TreeMap。

    方式1:HashMap按key排序

    • 测试main方法

          public static void main(String[] args) {
      
              Map<String, Integer> map = new HashMap<String, Integer>();
              map.put("f1", 12);
              map.put("f2", 13);
              map.put("f5", 22);
              map.put("f4", 42);
              map.put("f3", 15);
              map.put("f8", 21);
              map.put("f6", 123);
              map.put("f7", 1);
              map.put("f9", 19);
              System.out.println(map.toString());
      
              //方式1:构造TreeMap
              System.out.println(new TreeMap<String, Integer>(map));
      
              //方式2:先单独对keySet进行排序
              Set<String> keySet = map.keySet();
              Object[] keyArray = keySet.toArray();
              //默认升序
              Arrays.sort(keyArray);
              for (Object key : keyArray) {
                  System.out.println(key + ": " + map.get(key));
              }
          }
      
      
      

    方式2:HashMap按value排序

    • 测试main方法

      
          public static void main(String[] args) {
          
              //首先需要得到HashMap中的包含映射关系的视图(entrySet)
              List<Map.Entry<String, Integer>> entryList = new ArrayList<>(map.entrySet());
              //将entrySet转换为List,然后重写比较器比较
              entryList.sort(new Comparator<Map.Entry<String, Integer>>() {
                  @Override
                  public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                      return o1.getValue().compareTo(o2.getValue());
                  }
              });
      
              entryList.forEach(i -> System.out.println(i.getKey() + ":" + i.getValue()));
          }
      
      

    参考链接

    Collections.sort实现源码解析

    https://blog.csdn.net/u011410529/article/details/56668545
    

    Conllection中的sort方法实现排序

    https://blog.csdn.net/qq_23179075/article/details/78753136
    

    十大经典排序算法

    https://www.cnblogs.com/guoyaohua/p/8600214.html
    
    展开全文
  • ElasticSearch之排序使用-ES常用排序方法 在搜索系统中,最常遇到的一个需求就是排序,同时排序也是搜索引擎需要改造最多的地方。 常见排序一般有如下两类: (1)按照相似度匹配得分排序 (2)按照指定字段...

    ElasticSearch之排序使用-ES常用排序方法

     

           在搜索系统中,最常遇到的一个需求就是排序,同时排序也是搜索引擎需要改造最多的地方。

     

    常见排序一般有如下两类:
    (1)按照相似度匹配得分排序

    (2)按照指定字段排序

        相似度得分排序是系统默认的排序方式,更多时候,我们需要按照指定字段排序。lucene中,基于字段内容的排序是由FieldComparator接口来实现的,在排序中又分为单字段排序和多字段排序。在排序速度方面,数值类型排序速度最快,在lucene中数值类型的排序是由 NumericComparator 的派生类来实现,NumericComparator派生类支持 float、double、int 、long 四钟类型(日期在底层会转化为long型存储)。
         字符串类型的字段一般都需要进行搜索的,那么需要对其进行分词处理。分词处理的结果就是将该字符串解析为多个词条。在lucene层面,根据docid可以取到多个索引词条,而无论采用哪个索引词条来进行排序其实都正确。
         所以为了对字符串类型字段进行排序,需要保存整个字符串作为一个索引词条,同时为了保证该字段能够被搜索,还要保存该字符串analyzed的结果(即需要保存完整的字符串作为一个词条,同时又分词索引)。

    在ES中为实现该功能,ES提供了 multi-field mapping 机制,配置通过配置即可实现字段即分词,又可排序:

    "title": {  
        "type":     "string",
        "analyzer": "ansj",
        "fields": {
            "sort": {
                "type":  "string",
                "index": "not_analyzed"
            }
        }
    }

    通过title字段作为搜索,而用title.sort字段作为排序:

    GET /_search
    {
        "query": {
            "match": {
                "title": "elasticsearch"
            }
        },
        "sort": "title.sort"

    }

     

    Lucene标准语法中多字段排序:
    {
      "from": 0,
      "size": 10,
      "query": {
        "query_string": {    "query": "*:*",    "default_operator": "and"  }
      },
      "sort": [

        {   

         "title.sort": { "order": "desc"   },

          "_score": {   "order": "desc"   }
        }
      ]

    }

    缺省字段排序:

    {
      "from": 0,
      "size": 10,
      "query": {
        "query_string": {    "query": "title:test",    "default_operator": "and"   }
      },
      "sort": [
        {
          "rpgendatetime": {      "order": "desc",      "missing": "_last"     }
        }
      ]
    }

    使用脚本排序:

     

    {
        "query" : {
         "query_string": {
             "query": "",
             "default_operator": "and"
              }
        },
        "sort" : {
            "_script" : {
                "type" : "number",
                "script" : {
                    "inline": "doc['field_name'].value * factor",
                    "params" : {
                        "factor" : 1.1
                    }
                },
                "order" : "asc"
            }
        }
    }
    展开全文
  • C语言常用排序方法大全.rarC语言常用排序方法大全.rar
  • 常用排序方法 1. 冒泡排序(Bubble Sort) 2. 直接选择排序(Straight Selection Sort) 3. 直接插入排序(Straight Insertion Sort) 4. 希尔排序(Shells Sort) 5. 堆排序(Heap Sort) 6. 快速排序(Quick Sort...

    声明:此文章仅供学习排序方法的原理,不附加代码

     

    一。常用排序方法

    1. 冒泡排序(Bubble Sort)
    2. 直接选择排序(Straight Selection Sort)
    3. 直接插入排序(Straight Insertion Sort)
    4. 希尔排序(Shells Sort)
    5. 堆排序(Heap Sort)
    6. 快速排序(Quick Sort)
    7. 归并排序(Merge Sort)
    8. 桶排序(Bucket Sort)/基数排序(Radix Sort)

    二。简介实现方法(皆以从小到大排列为例,设在正整数的情况下,如有其他情况请对比考虑)   注:附图皆为百度所得,感谢图主分享。

    1.冒泡排序,冒泡排序作为初学程序的第一种排序方法,其方法是对序列中所有数实行前后元素对比,小的在前大的在后,这样从头到尾进行n-1次

    2.直接选择排序,又叫简单选择排序,其方法是将序列中最小的元素比较出来放到序列头部,然后剩下的元素按此方法继续比较选择。白话说,就是直接选择出最小的挨个放

    3.直接插入排序,其方法是将序列11111111(1代表元素,不代表数值)看作两部分暂且用a来隔离这两部分,即1a1111111,a前为已经排好位置的元素,a后为未排好位置的元素,然后依次取出a后的元素与a前比较,放在合适的位置,即初始1a111111,第一次排序完之后为11a11111。白话说,就是挨个来找位置插入

    4.希尔排序,又叫做缩小增量排序,是直接插入排序的基础上进行的改进。方法是取间隔a的数进行比较,这个a称为增量,若前数大于后数,则将其交换位置,从头到尾全部比较完成后,再按照间隔a/2进行比较,若a是奇数,则按照 (a+1)/2的间隔计算,直至当增量a=1时,比较完a=1这一趟,便结束排序。附图为比较过程:

                       è¿éåå¾çæè¿°

    5.快速排序,在冒泡法的基础上进行的改进,序列arr,标记头尾为i ,j,设标记量temp = arr[i] 也就是arr[0]

    j开始 --,直到有arr[j]<temp,此时j找到位置了,站在此处不动,i开始动

    i开始++,直到有arr[i]>temp,此时i找到位置了,站在此处不动,j再开始动

    直到j与i相遇了,哎此时相遇位置的数与temp进行交换

    第一次排序结束,相遇位置左侧元素便均小于temp,右方均大于temp

    利用这种方法对两侧进行递归操作,直到temp实在无法拆分左右停止,次数的序列便排序完成。

    附图第一次排序心路历程。

                   temp在此,谁敢放肆!                 

            

         

               

             

                 

     

    6.归并排序,采用”分治策略“,灵感来自归并操作。首先理解什么是归并操作??

    归并操作是指两个有序列表,合成一个有序表。

    设俩表为:    abcdefg     ABCDEFG

    取两个列表得第一个元素比较,谁小谁放在合并表首位,后续元素依次前进,即第一次归并得 :(设a<A)

    bcdefg   ABCDEFG,       合并表为 a

    继续重复此操作,若有一方为空了,则将另一方元素直接跟随在合并表表尾  (设此时剩下efg)

    此时: efg      null            合并表为   abABCDEcdFG,故: abABCDEcdFG +efg  = abABCDEcdFGefg 

    好,理解了归并操作,来讲解什么是归并排序。

    分治,也可以叫分合

    (1)分,将序列分解

                    

    (2)治,合,将分解后得小模块进行归并操作

                    例如:8  4 进行归并操作得到合并序列  4 8

                                4 8           5 7序列进行归并操作得到合并序列4 5 7 8

                   

    注:https://www.cnblogs.com/crystalmoore/p/5930841.html  这位博主有个动态演示,可以进去看一下

    7.堆排序,堆排序是基于堆的概念上设计的排序算法

       堆,一般常用的也就是二叉堆,二叉堆的可以形象的比喻成一颗 完全二叉树。(对于堆与二叉树在此不多解释,需要的同学们请自行百度学习)。而二叉堆中分为大顶堆和小顶堆。

       大顶堆是节点处的值大于等于左右孩子,小顶堆是节点处的值小于等于左右孩子。附图:   左大右小

         

        一般升序采用大顶堆,降序采用小顶堆

        将待排序序列构造成一个大顶堆,此时,整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换,此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆,这样会得到n个元素的次小值。如此反复执行,便能得到一个有序序列了

        说白了,先将序列看作是一个完全二叉树,从最后一个非叶子节点开始,

        (1)将结点及其叶子,进行比较,把最大的换到结点处,这样一层层的把最大的节点拱到了堆顶

        (2)将堆顶元素跟末尾元素进行交换,这样就将最大值放到了序列最后

        (3)此时将剩余数看作完全二叉树进行如此计算,一步一步的将最大值拱出来,剩下一个节点无左右孩子的时候,排序完成。

       参考:https://www.cnblogs.com/chengxiao/p/6129630.html

    8.桶排序,又称桶排序

    其方法主要是:

    (1)从序列中找出最大值N,设置一个数组arr,并使其所有值为0,长度为N+1,其数组下标0--N也就代表了这N+1个桶

    (2)将所有数据放入他所匹配的下标桶,并在放入时使得此处arr得值加1表示计数

    (3)根据桶的下标取出所存在的元素,若某个桶得值为0,则直接跳过,通过桶得下标排序,通过桶的值判断有多少元素在这个桶里存放

    (4)排序结束,出现结果

    三。所有常用排序之间得比较(图来自百度,感谢图主无私分享)

          

    展开全文
  • 10种常用排序方法.cpp

    2021-05-02 16:25:33
    内含常用的10种排序方法,包括冒泡,插入,二分,希尔,桶,快排等, 对排序算法的理解很有帮助
  • C语言中常用排序方法分析与探讨.pdfC语言中常用排序方法分析与探讨.pdfC语言中常用排序方法分析与探讨.pdf
  • OC中常用排序方法:

    千次阅读 2016-12-29 16:33:34
    转自:... ①.OC中常用排序方法: 1).不可变数组 - (NSArray *)sortedArrayUsingSelector:(SEL)comparator; - (NSArray *)sortedArrayUsingComparator:(NSComparator)c
  • 几种常用排序方法的简单实现

    千次阅读 2017-12-11 16:47:43
    几种常用排序方法的简单实现以前对排序算法没有一个很好的认知,前一段时间在51NOD上刷题的时候,被大量数据的排序给困住了,好几种都是超时的,这也使我多学习了几种常用的排序算法,最后通过快排解决了问题
  • 常用排序方法 排序是一种非常常见的一种技能,在我学习算法时,我的算法老师说过:“如果有可能,最好每天把常用的排序算法写一遍。”本文对常用的排序算法进行总结,给出源码,方便大家学习。   冒泡排序 这是...
  • 工作之余,把写代码过程中比较重要的一些代码段收藏起来,如下的代码是关于使用几种常用排序方法对C#数组进行排序的代码,希望能对各朋友有帮助。 using System; namespace DataStruct { public class Sorter ...
  • 目录一、题目描述二、题解2.1 回顾常用排序方法2.1.1 冒泡排序2.1.2 直接插入排序2.1.3 快速排序2.1.4 归并排序 一、题目描述 给定一个数组,请你编写一个函数,返回该数组排序后的形式。 二、题解 import java....
  • js常用排序方法

    2020-07-11 15:40:40
    排序只能对正整数进行排序,利用js的数组特性,创建一个新数组作为桶,然后遍历原数组,将值放入对应的桶中,就是将原数组每一项的值作为新数组的索引,该方法为去重排序 function sortT(arr) { var index = [];...
  • 常用排序方法总结

    2018-01-19 21:39:28
    常用排序有简单插入排序,希尔排序,简单选择排序,冒泡排序,归并排序,堆排序还有快速排序。 其中稳定的排序有:简单插入排序,冒泡排序,归并排序。 不稳定的有:希尔排序,简单选择排序,堆排序,快速...
  • 常用排序方法介绍

    2016-11-23 09:52:23
    排序是我们在编程中使用到的最多的方法之一,好的方法既可以节省时间,也可以节省资源,在长沙网站开发时起到事半工倍的效果,今天笔者介绍几个常用排序方法。 冒择路希快归堆(口诀):冒泡排序,选择排序,插入...
  • Arrays.sort()排序方法在java中是最简单且最常用排序方法 int []arr= {3,5,6,2}; Arrays.sort(arr);//调用方法排序即可 其他还有 方法二:冒泡排序 方法三:选择排序 方法四:反转排序 ...
  • 8中业务中常用排序方法的java类实现,自己搞得,少点分分享给大家
  • 1.冒泡排序法 将数组中的相邻两个元素进行比较,将比较大(较小)的数通过两两比较移动到数组末尾(开始),执行一遍内层循环,确定一个最大(最小)的数,外层循环从数组末尾(开始)遍历到开始(末尾) ...
  • c语言的5种常用排序方法

    千次阅读 2020-03-09 15:39:25
    c语言的5种常用排序算法 1、冒泡排序(最常用) 冒泡排序是最简单的排序方法:原理是:从左到右,相邻元素进行比较。每次比较一轮,就会找到序列中最大的一个或最小的一个。这个数就会从序列的最右边冒出来。(注意...
  • C语言中常用排序方法

    2011-11-03 22:04:55
    常用排序方式,C语言初学者必学内容。。。。。。。。。。。。。。。。。。。
  • Java8_常用排序方法

    2020-06-11 10:07:30
    静态方法 Comparator.comparing 返回一个 Comparator 对象,该对象提供了一个函数可以提取排序 关键字。 新的实例方法包含了下面这些。 reversed ——对当前的 Comparator 对象进行逆序排序,并返回排序之后新的 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,289
精华内容 3,315
关键字:

常用排序方法