精华内容
下载资源
问答
  • 常用排序方法
    千次阅读
    2019-09-27 15:38:52

    springboot-data-jpa默认方法支持排序,当然复杂的场景需要自己重写默认的方法,下面介绍四种常用的排序方法

    首先需要定义一个依赖的对象

    @Data
    public class Person{
    
     private Integer id;
     
     private String name;
    
     private int sex;
    
     private String address;
     
    }
    

    定义Repository

    @Repository
    public interface PersonRepository extends JpaRepository<Person, Integer> {
       ///方法的定义
    }
    
    

    • 自定义接口
      如果我们只需要做简单查询,其中一个字段需要作为排序,则可以使用jpa支持自定义接口的办法即可
    @Repository
    public interface PersonRepository extends JpaRepository<Person, Integer> {
        findByNameOrderByIdDesc(String name);
        findByNameOrderByIdAsc(String name);
    }
    

    使用该方法的好处是业务逻辑代码简单,缺点是可扩展性不太好,支持升序或者降序操作,当一个接口需要同时支持升序或者降序时,则不适用。


    • @query接口
    @Repository
    public interface PersonRepository extends JpaRepository<Person, Integer> {
        @Query(" from Person WHERE name = ?1 ORDER BY id ?2")
        List<Person> findInOrders(String name, String order);
    }
    

    使用该方法还是只能支持单个字段排序,优点是业务逻辑代码简单,另外比上一种更灵活,同时支持升序和降序排序。


    • Sort方法
    @Repository
    public interface PersonRepository extends JpaRepository<Person, Integer> {
       
        List<Person > findByname(String name, Sort sort)
    }
    

    使用该方法支持多个字段排序,优点是业务逻辑代码简单,代码看上去更优雅,同时支持升序和降序排序。缺点是所有字段必须同时支持同一种排序方式


    除了上述三种方式外,还有支持复杂的查询及排序

    • 接口重写
      需要继承接口JpaSpecificationExecutor
    @Repository
    public interface PersonRepository extends JpaRepository<Person, Integer>, JpaSpecificationExecutor<Person> {  
      
    }
    

    在服务实现类里面需要重写toPredicate方法

    public class PersonServiceImpl{
      PersonRepository  repository;
       findByCond(Condition cond){
          repository.findAll(new Specification<Person>(){
            PageRequest pageable = new PageRequest(cond.page, cond.size);
             @Override
              public Predicate toPredicate(Root<Person> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
              //业务逻辑代码
           }, pageable)       
      }    
    }
    

    该方法最大的优势是可扩展性非常的高,可以添加多条件,同时支持多字段排序字段,每个字段的排序规则根据实际情况可以自由变化。
    好了,先分享到这里

    更多相关内容
  • 常用排序方法

    2018-09-01 17:09:51
    分别实现1)直接插入排序,2)冒泡排序;3)简单选择排序 ;4)希尔排序 5)快速排序
  • 主要介绍了js常用排序方法实例代码解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 10种常用排序方法.cpp

    2021-05-02 16:25:33
    内含常用的10种排序方法,包括冒泡,插入,二分,希尔,桶,快排等, 对排序算法的理解很有帮助
  • js代码-常用排序方法总结
  • C语言教学中常用排序方法分析.pdf
  • 8中业务中常用排序方法的java类实现,自己搞得,少点分分享给大家
  • C语言常用排序方法大全,实用排序技术.欢迎下载.
  • js的几种常用排序方法

    千次阅读 2021-11-19 14:58:08
    冒泡排序 依次比较两个相邻的元素,如果前一个数比后一个数大时就交换位置,比较晚第一轮最后一个元素是最大的元素,所以就不需要在比较最后一个元素了 var arr = [1, 2, 5, 7, 9, 22, 40] for(var i=0; i<arr....

    冒泡排序

    依次比较两个相邻的元素,如果前一个数比后一个数大时就交换位置,比较完第一轮最后一个元素是最大的元素,所以就不需要在比较最后一个元素了

    var arr = [1, 2, 5, 7, 9, 22, 40]
    for(var i=0; i<arr.length-1; i++){
        for(var j=0; j<arr.length-i-1; j++) {
           if (arr[j] > arr[j+1]) {
                 var temp = arr[j]
                 arr[j] = arr[j+1]
                 arr[j+1] = temp
            } 
        }
    }
    

    选择排序

    首先在元素中找到最小的元素,把他放在最前边,然后再从剩下的元素中寻找最小的元素,依次放在最左边…

    var arr = [1,4,7,9,10,4,7,90,22]
    for (var i=0; i<arr.length-1; i++) {
        var minIndex = i
            for (var j=i; j<arr.length; j++) {
                if (arr[j] < arr[minIndex]) {
                     minIndex = j              
                }
            }
            var temp = arr[i]   
            arr[i] = arr[minIndex]
            arr[minIndex] = temp   
    }  
    

    快速排序

    先从数组中取出一个数作为基准值,将比这个数大的放在它右边,将比这个小的放在它左边,依次…

    function quickSort (arr) {   
    	if(arr.length<=1){return arr}   
    	var left = [], right = [], mid = arr.splice(Math.floor(arr.length/2), 1)
    	for (var i=0; i<arr.length; i++) {
            if (arr[i] < mid) {
                 left.push(arr[i])
            } else {
                right.push(arr[i])
            }
        }
    	return quickSort(left).concat(mid,quickSort(right))
    }
     
    console.log(quickSort([1,5,7,9,23,67,8,2,4]))
    

    插入排序

    从第一个元素开始该元素可以被认为已经被排序,取出下一个元素,如果该元素大于新的元素,则将该元素移到下一个位置,依次…

    function insertSort (arr) {
      for (var i=0; i<arr.length; i++) {
            var j = i-1     
            var key = arr[i] 
            while (j >=0 && arr[j] > key) {
                    arr[j+1] = arr[j]
                    j--;
            }  
            arr[j+1] = key    
        }   
        return arr 
    }
    
    展开全文
  • C语言中常用排序方法

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

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

    c语言的5种常用排序算法

    1、冒泡排序(最常用)
    冒泡排序是最简单的排序方法:原理是:从左到右,相邻元素进行比较。每次比较一轮,就会找到序列中最大的一个或最小的一个。这个数就会从序列的最右边冒出来。(注意每一轮都是从a[0]开始比较的)

    • 以从小到大排序为例,第一轮比较后,所有数中最大的那个数就会浮到最右边;第二轮比较后,所有数中第二大的那个数就会浮到倒数第二个位置……就这样一轮一轮地比较,最后实现从小到大排序。
    #include<stdio.h>
    int main()
    {
    	int i,j,t,a[10];
    	printf("输入10个整数:\n");
    	for(i=0;i<10;i++)
    		scanf("%d",&a[i]);
    	for(i=0;i<9;i++)				//变量i仅代表比较的趟数(n-1)趟
    		for(j=0;j<9-i;j++)
    			if(a[j]>a[j+1])			//相邻两个数相互比较
    			{
    				t=a[j];
    				a[j]=a[j+1];
    				a[j+1]=t;
    			}
    	for(i=0;i<10;i++)
    		printf("%5d",a[i]);
    	printf("\n");
    	return 0;
    }
    

    2、鸡尾酒排序
    鸡尾酒排序又称双向冒泡排序、鸡尾酒搅拌排序、搅拌排序、涟漪排序、来回排序或快乐小时排序, 是冒泡排序的一种变形。该算法与冒泡排序的不同处在于排序时是以双向在序列中进行排序。
    原理:数组中的数字本是无规律的排放,先找到最小的数字,把他放到第一位,然后找到最大的数字放到最后一位。然后再找到第二小的数字放到第二位,再找到第二大的数字放到倒数第二位。以此类推,直到完成排序。

    #include<stdio.h>
    int main()
    {
    	void cocktail_sort(int a[],int left,int right);
    	int i,a[10];	
    	printf("输入10个整数:\n");
    	for(i=0;i<10;i++)
    		scanf("%d",&a[i]);
    	cocktail_sort(a,0,9);
    	for(i=0;i<10;i++)
    		printf("%5d",a[i]);	
    	printf("\n");
    	return 0;
    }
    void cocktail_sort(int a[],int left,int right)
    {
    	if(left>=right)
    	{
    		return;
    	}
    	int i,t;
    	if(left<right)
    	{
    		for(i=left;i<right;i++)
    			if(a[i]>a[i+1])//最大值移动到最右端处
    			{
    				t=a[i];
    				a[i]=a[i+1];
    				a[i+1]=t;
    			}
    		for(i=right;i>left;i--)
    			if(a[i]<a[i-1])//最小值移动到最左端处
    			{
    				t=a[i];
    				a[i]=a[i-1];
    				a[i-1]=t;
    			}
    	cocktail_sort(a,left+1,right-1);	//重复运算,直到left>=right(此处使用递归调用)
    	}	
    }
    

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

    原理
    设要排序的数组是A[0]……A[N-1],首先任意选取一个数据(通常选
    用数组的第一个数)作为关键数据,然后将所有比它小的数都放到它左边,所有比它大的数都放到它右边,这个过程称为一趟快速排序。值得注意的是,快速排序不是一种稳定的排序算法,也就是说,多个相同的值的相对位置也许会在算法结束时产生变动。
    一趟快速排序的算法是:
    1)设置两个变量i、j,排序开始的时候:i=0,j=N-1;
    2)以第一个数组元素作为关键数据,赋值给key,即key=A[0];
    3)从j开始向前搜索,即由后开始向前搜索(j–),找到第一个小于key的值A[j],将A[j]和A[i]的值交换;
    4)从i开始向后搜索,即由前开始向后搜索(i++),找到第一个大于key的A[i],将A[i]和A[j]的值交换;
    5)重复第3、4步,直到i=j; (3,4步中,没找到符合条件的值,即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值,使得j=j-1,i=i+1,直至找到为止。找到符合条件的值,进行交换的时候i, j指针位置不变。另外,i==j这一过程一定正好是i+或j-完成的时候,此时令循环结束)。

    #include<stdio.h>
    int main()
    {
    	void quicksort(int a[],int left,int right);//函数声明
    	int i,a[10];
    	printf("输入10个整数:\n");
    	for(i=0;i<10;i++)
    		scanf("%d",&a[i]);
    	quicksort(a,0,9);
    	for(i=0;i<10;i++)
    		printf("%5d",a[i]);
    	printf("\n");
    	return 0;
    }
    void quicksort(int a[],int left,int right)//函数实现快速排序
    {
    	if(left>=right)		/*如果左边索引大于或者等于右边的索引就代表已经整理完成一个组了*/
    	{
    		return;
    	}
    	int i=left;
    	int j=right;
    	int key=a[left];
    
    	while(i<j)
    	{
    		while(i<j && key<=a[j])/*而寻找结束的条件就是,1,找到一个小于或者大于key的数(大于或小于取决于你想升
    								序还是降序)2,没有符合条件1的,并且i与j的大小没有反转*/ 
    			j--;	/*向前寻找*/
    		a[i]=a[j];	/*找到一个这样的数后就把它赋给前面的被拿走的i的值(如果第一次循环且key是
    					 a[left],那么就是给key)*/
    		while(i<j && key>=a[i])		/*这是i在当组内向前寻找,同上,不过注意与key的大小关系停止循环和上面相反,
    									因为排序思想是把数往两边扔,所以左右两边的数大小与key的关系相反*/
    			i++;
    		a[j]=a[i];		/*当在当组内找完一遍以后就把中间数key回归*/
    	}
    	a[i]=key;
    	quicksort(a,left,i-1);/*最后用同样的方式对分出来的左边的小组进行同上的做法*/
    	quicksort(a,i+1,right);/*用同样的方式对分出来的右边的小组进行同上的做法*/
    							/*当然最后可能会出现很多分左右,直到每一组的i = j 为止*/
    }
    
    

    4、选择排序
    思路是设有10个元素a[1]-a[10],将a[1]与a[2]-a[10]比较,若a[1]比a[2]-a[10]都小,则不进行交换。若a[2]-a[10]中有一个以上比a[1]小,则将其中最大的一个与a[1]交换,此时a[1]就存放了10个数中最小的一个。同理,第二轮拿a[2]与a[3]-a[10]比较,a[2]存放a[2]-a[10]中最小的数,以此类推。

    #include<stdio.h>
    int main()
    {
    	int i,j,t,a[10];
    	printf("请输入10个整数:\n");
    	for(i=0;i<10;i++)
    		scanf("%d",&a[i]);    //输入10个整数存到数组里
    	for(i=0;i<9;i++)
    		for(j=i+1;j<10;j++)
    			if(a[i]>a[j])     //如果前一个数比后一个大,则调换值
    			{
    				t=a[i];
    				a[i]=a[j];
    				a[j]=t;
    			}
    	for(i=0;i<10;i++)
    		printf("%d  ",a[i]);
    	printf("\n");
    
    	return 0;
    }
    

    5、插入排序
    插入排序是在一个已经有序的小序列的基础上,一次插入一个元素*
    一般来说,插入排序都采用in-place在数组上实现。

    具体算法描述如下:
    ⒈ 从第一个元素开始,该元素可以认为已经被排序
    ⒉ 取出下一个元素,在已经排序的元素序列中从后向前扫描
    ⒊ 如果该元素(已排序)大于新元素,将该元素移到下一位置
    ⒋ 重复步骤3,直到找到已排序的元素小于或者等于新元素的位置
    ⒌ 将新元素插入到下一位置中
    ⒍ 重复步骤2~5

    #include<stdio.h>
    int main()
    {
    	void insert(int a[],int first,int last);
    	int i,a[10];	
    	printf("输入10个整数:\n");
    	for(i=0;i<10;i++)
    		scanf("%d",&a[i]);
    	insert(a,0,9);
    	for(i=0;i<10;i++)
    		printf("%5d",a[i]);	
    	printf("\n");
    	return 0;
    }
    void insert(int a[],int first,int last)
    {
    	int i,j,t;
    	for(i=first+1;i<=last;i++)
    	{
    		t=a[i];
    		j=i-1;
    		while((j>=0) && (a[j]>t))//与已排序的数逐一比较,大于t时,该数移后
    		{
    			a[j+1]=a[j];
    			j--;
    		}
    	//	if(j!=i-1)
                a[j+1]=t;
    	}
    }
    
    展开全文
  • 排序方法, 用动画的形式的,给您演示了排序的原理
  • 数据结构-算法-排序-常用排序方法简介

    千次阅读 多人点赞 2018-11-02 21:01:11
    常用排序方法 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)排序结束,出现结果

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

          

    展开全文
  • C语言常用排序方法大全.rarC语言常用排序方法大全.rar
  • 有时你需要的可能是一个简单的排序,但是通常你需要做更多,你需要分组来进行分析和统计。幸运的是,SQL提供了大量语句和操作来进行排序,分组和摘要。下面的一些技巧将会帮助你识别什么时候排序,什么时候分组,...
  • ElasticSearch之排序使用-ES常用排序方法 在搜索系统中,最常遇到的一个需求就是排序,同时排序也是搜索引擎需要改造最多的地方。 常见排序一般有如下两类: (1)按照相似度匹配得分排序 (2)按照指定字段...
  • C语言中常用排序方法分析与探讨.pdfC语言中常用排序方法分析与探讨.pdfC语言中常用排序方法分析与探讨.pdf
  • 本文主要介绍了一些常用排序算法,以及PHP的代码实现等,希望对您能有所帮助。 本文来自于awaimai.com,由火龙果软件Luca编辑推荐。 作为phper,一般接触算法的编程不多。 但基本的排序算法还是应该掌握。 毕竟算法...
  • 该软件包包含以下常用排序算法的 MATLAB 实现 1) 冒泡排序2)桶排序3) 鸡尾酒排序4) 梳状排序5) 计数排序6) 堆排序7) 插入排序8) 归并排序9) 快速排序10) 基数排序11) 选择排序12) 壳排序 代码的编写方式使得它可以...
  • Array的三种常用排序方法

    千次阅读 2018-09-14 11:58:16
    却总有这样那样的原因不得不放弃,今天终于有时间整理一点儿关于java数组的排序方法笔记了…… 关于数组的排序常用的有快速排序、冒泡排序、选择排序、插入排序…… 快速排序: java中有对数组进行快速排序的方法...
  • 本文实例讲述了C#数组排序的两种常用方法。分享给大家供大家参考。具体如下: 1.第一个例子 定义代码 #region Array数组排序1 public class Pigeon : IComparable //类元素本身继承比较接口 { int XValue; int ...
  • java常用排序方法

    千次阅读 2022-01-22 21:35:15
    java常用排序方法
  • java常用排序方法

    2008-12-11 22:24:35
    复习过程中遇到的几种排序,总结一下,望对各位有点用处!
  • 排序是程序设计中非常重要的内容...排序有很多种方法常用的有三种:冒泡排序、选择排序、插入排序等,下面我们就对这三种方法做一下分析和比较,以便大家能够更好的理解和应用。一、冒泡排序 1、冒泡排序的基本思想

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 460,390
精华内容 184,156
关键字:

常用排序方法