精华内容
下载资源
问答
  • 看动画学算法之:排序-count排序

    万次阅读 2020-07-24 09:30:49
    今天我们介绍一种不需要作比较就能排序的算法:count排序count排序是一种空间换时间的算法,我们借助一个外部的count数组来统计各个元素出现的次数,从而最终完成排序。

    简介

    今天我们介绍一种不需要作比较就能排序的算法:count排序。

    count排序是一种空间换时间的算法,我们借助一个外部的count数组来统计各个元素出现的次数,从而最终完成排序。

    count排序的例子

    count排序有一定的限制,因为外部的count数组长度是和原数组的元素范围是一致的,所以count排序一般只适合数组中元素范围比较小的情况。

    我们举一个0-9的元素的排序的例子:3,4,2,5,6,2,4,9,1,3,5。

    先看一个动画,看看是怎么排序的:

    count数组里面存放的是从0到9这些元素出现的次数。

    我们遍历原始数组,遇到相应的数字就给相应的count+1。

    等所有的元素都count之后,再根据count数组中的值还原排序过后的数组。

    count排序的java实现

    count排序很简单,我们主要掌握下面两个大的步骤:

    1. 遍历原始数组&#
    展开全文
  • <pre><code>$total_query = "SELECT *, COUNT(users_sales_guild_id) AS users_sales_guild_id_count FROM sales_list WHERE sales_entry_date BETWEEN '2013-10-01 00:00:00' AND '2014-11-30 23:59:59' ORDER BY ...
  • 排序——计数排序Count sort)

    千次阅读 2020-02-11 19:30:54
    计数排序是一个非基于比较的排序算法,元素从未排序状态变为已排序状态的过程,是由额外空间的辅助和元素本身的值决定的。该算法于1954年由 Harold H. Seward 提出。它的优势在于在对一定范围内的整数排序时,它的...

    概述

    计数排序是一个非基于比较的排序算法,元素从未排序状态变为已排序状态的过程,是由额外空间的辅助和元素本身的值决定的。该算法于1954年由 Harold H. Seward 提出。它的优势在于在对一定范围内的整数排序时,它的复杂度为Ο(n+k)(其中k是整数的范围),快于任何比较排序算法。当然这是一种牺牲空间换取时间的做法,而且当 O(k)>O(nlogn) 的时候其效率反而不如基于比较的排序,因为基于比较的排序的时间复杂度在理论上的下限是 O(nlogn)

    算法思路

    计数排序对输入的数据有附加的限制条件:

    1、输入的线性表的元素属于有限偏序集 S;

    2、设输入的线性表的长度为 n,|S|=k(表示集合 S 中元素的总数目为 k),则 k=O(n)。

    在这两个条件下,计数排序的复杂性为O(n)。

    计数排序的基本思想是对于给定的输入序列中的每一个元素 x,确定该序列中值小于 x 的元素的个数(此处并非比较各元素的大小,而是通过对元素值的计数和计数值的累加来确定)。一旦有了这个信息,就可以将 x 直接存放到最终的输出序列的正确位置上。例如,如果输入序列中只有 17 个元素的值小于 x 的值,则 x 可以直接存放在输出序列的第 18 个位置上。当然,如果有多个元素具有相同的值时,我们不能将这些元素放在输出序列的同一个位置上,因此,上述方案还要作适当的修改。

    算法过程

    1. 根据待排序集合中最大元素和最小元素的差值范围,申请额外空间;
    2. 遍历待排序集合,将每一个元素出现的次数记录到元素值对应的额外空间内;
    3. 对额外空间内数据进行计算,得出每一个元素的正确位置;
    4. 将待排序集合每一个元素移动到计算得出的正确位置上。

    详解算法

    先假设 20 个数列为:{9, 3, 5, 4, 9, 1, 2, 7, 8,1,3, 6, 5, 3, 4, 0, 10, 9, 7, 9}。

    让我们先遍历这个无序的随机数组,找出最大值为 10 和最小值为 0。这样我们对应的计数范围将是 0 ~ 10。然后每一个整数按照其值对号入座,对应数组下标的元素进行加1操作。

    比如第一个整数是 9,那么数组下标为 9 的元素加 1,如下图所示。

    第二个整数是 3,那么数组下标为 3 的元素加 1,如下图所示。

    继续遍历数列并修改数组......。最终,数列遍历完毕时,数组的状态如下图。

    数组中的每一个值,代表了数列中对应整数的出现次数。

    有了这个统计结果,排序就很简单了,直接遍历数组,输出数组元素的下标值,元素的值是几,就输出几次。比如统计结果中的 1 为 2,就是数列中有 2 个 1 的意思。这样我们就得到最终排序好的结果。

    0, 1, 1, 2, 3, 3, 3, 4, 4, 5, 5, 6, 7, 7, 8, 9, 9, 9, 9, 10

    动画展示

    算法性能

    时间复杂度

    O(n+k)

    空间复杂度

    O(k)

    稳定性

    稳定

    特别说明

    虽然计数排序看上去很强大,但是它存在两大局限性

    1.当数列最大最小值差距过大时,并不适用于计数排序

    比如给定 20 个随机整数,范围在 0 到 1 亿之间,此时如果使用计数排序的话,就需要创建长度为 1 亿的数组,不但严重浪费了空间,而且时间复杂度也随之升高。

    2.当数列元素不是整数时,并不适用于计数排序

    如果数列中的元素都是小数,比如 3.1415,或是 0.00000001 这样子,则无法创建对应的统计数组,这样显然无法进行计数排序。

    正是由于这两大局限性,才使得计数排序不像快速排序、归并排序那样被人们广泛适用。

    代码实现

    C和C++

    int * countingSort1(int arr[],int count,int max) {
        int index = 0;
        int *tmpArr = (int *)malloc(max*sizeof(int));
        int *result = (int *)malloc(max*sizeof(int));
        
        for(int k = 0;k<max;k++) {
            tmpArr[k] = 0;
        }
        
        for (int i = 0; i<count; i++) {
            tmpArr[arr[i]]++;
        }
        for (int j = 0; j<max; j++) {
            while (tmpArr[j]) {
                result[index++] = j;
                tmpArr[j]--;
            }
        }
        free(tmpArr);
        tmpArr = NULL;
        return result;
    }
    

    Java

    public class CountingSort implements IArraySort {
        @Override
        public int[] sort(int[] sourceArray) throws Exception {
            // 对 arr 进行拷贝,不改变参数内容
            int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
    
            int maxValue = getMaxValue(arr);
    
            return countingSort(arr, maxValue);
        }
    
        private int[] countingSort(int[] arr, int maxValue) {
            int bucketLen = maxValue + 1;
            int[] bucket = new int[bucketLen];
    
            for (int value : arr) {
                bucket[value]++;
            }
    
            int sortedIndex = 0;
            for (int j = 0; j < bucketLen; j++) {
                while (bucket[j] > 0) {
                    arr[sortedIndex++] = j;
                    bucket[j]--;
                }
            }
            return arr;
        }
    
        private int getMaxValue(int[] arr) {
            int maxValue = arr[0];
            for (int value : arr) {
                if (maxValue < value) {
                    maxValue = value;
                }
            }
            return maxValue;
        }
    }
    

    Python

    def countingSort(arr, maxValue):
        bucketLen = maxValue+1
        bucket = [0]*bucketLen
        sortedIndex =0
        arrLen = len(arr)
        for i in range(arrLen):
            if not bucket[arr[i]]:
                bucket[arr[i]]=0
            bucket[arr[i]]+=1
        for j in range(bucketLen):
            while bucket[j]>0:
                arr[sortedIndex] = j
                sortedIndex+=1
                bucket[j]-=1
        return arr

     

    展开全文
  • ES聚合分组后count排序

    千次阅读 2020-06-09 11:42:40
    ES通过多个字段分组后count排序. 数据库SQL:select count(1) from table group by storeCode,productId order by count(1) desc; { "query": { "bool": { "must": [ { "exists": { "field": "storeCod

    ES通过多个字段分组后count排序.
    数据库SQL:select count(1) from table group by storeCode,productId order by count(1) desc;

    {
        "query": {
            "bool": {
                "must": [
                    {
                        "exists": {
                            "field": "storeCode"
                        }
                    },
                    {
                        "bool": {
                            "must_not": {
                                "term": {"storeCode" : ""}
                            }
                        }
                    }
                ]
            }
        },
        "size": 0,
        "aggs": {
            "storeCodeAggs": {
                "terms": {
                    "field": "storeCode",
                    "order": {
                        "_count": "desc"
                    }
                },
                "aggs": {
                    "prodAggs": {
                        "terms": {
                            "field": "productId"
                        }
                    }
                }
            }
        }
    }
    
    展开全文
  • 1.sql 一条sql 语句查询结果中 查询数据; 2.sql 统计 按照某列 分类 并按照递减 排序 3.sql 某列 sql语句查询结果集合当中的 进行查找

    从  一个sql 语句中查找另一个sql语句查询的结果:


    	public void  getSumCountgsMebDTO1(int memberSum){
    		
    		SQLiteDatabase db = helper.getReadableDatabase();
    		String COUNT_NUM="COUNT_NUM";
    		
    		String sql1 ="select * from "+ "(select  "+DBConstants.DB_SEND_GROUP_MB_groupsendid+","
    				+ " count("+DBConstants.DB_SEND_GROUP_MB_groupsendid+ ") "
    				+ " as "+ COUNT_NUM
    				+ " from " + DBConstants.DB_SEND_GROUP_MB
    				+ " group by "+DBConstants.DB_SEND_GROUP_MB_groupsendid+") as tabl2 "//内部用不了COUNT_NUM,外部可以使用
    				+ " where tabl2.COUNT_NUM = "+3;
    //		String sql1 = "select  "+DBConstants.DB_SEND_GROUP_MB_groupsendid+","
    //				+ " count("+DBConstants.DB_SEND_GROUP_MB_groupsendid+ ") "
    //				+ " as "+ COUNT_NUM
    //				+ " from " + DBConstants.DB_SEND_GROUP_MB
    //				+ " group by "+DBConstants.DB_SEND_GROUP_MB_groupsendid
    //				+ " order by "+ " count("+DBConstants.DB_SEND_GROUP_MB_groupsendid+ ") "+"  desc";
    		
    		Cursor cursor  = db.rawQuery(sql1, null);
    		
    		MyLog.e(TAG, " getSumCountgsMebDTO cursor.count =  "+cursor.getCount());
    		StringBuffer sb=new StringBuffer();
    		while (cursor.moveToNext()) {
    			int num = cursor.getInt(cursor.getColumnIndex(COUNT_NUM));
    //			String memberNum = cursor.getString(cursor.getColumnIndex(DBConstants.DB_SEND_GROUP_MB_membernumber));
    			String groupsendid = cursor.getString(cursor.getColumnIndex(DBConstants.DB_SEND_GROUP_MB_groupsendid));
    			
    			sb.append(" getSumCountgsMebDTO result = "
    //			+ memberNum +"  "
    					+groupsendid
    					+" = "+num
    					+";\n");
    		}
    		MyLog.e(TAG, sb.toString());
    	}

    =============获取 某列 在从sqlite语句中查询的结果的cursor当中,===============================================================



    /**按照群发组分类: 每个群发组有多少成员;*/
    	public void  getSumCountgsMebDTO(ArrayList<GroupSendMemberDTO> gsmdtos){
    	/**
    	 * 分析:
    	 * 1.gsmdtos 就是当前的群发的成员结果集合;
    	 * 2.如果gsmdtos  不包含cursor.get(index),则去除这个groupSendid(将其纪录下来,下次的groupSendid包含则跳过)
    	 * 3.如果都包含,则去取出这个groupSendid
    	 * 4.通过groupsendid,查询groupSenddto,和groupsendMsg
    	 */		
    		if (gsmdtos==null||gsmdtos.size()<1) {
    			throw new IllegalArgumentException(" getSumCountgsMebDTO2(ArrayList<GroupSendMemberDTO> gsmdtos) 的gsmdto 的参数异常");
    		}
    		SQLiteDatabase db = helper.getReadableDatabase();
    		String COUNT_NUM="COUNT_NUM";
    		String TABLE2="TABLE2";
    		
    		String sql1 =
    				"select * from " + DBConstants.DB_SEND_GROUP_MB+ " where "+DBConstants.DB_SEND_GROUP_MB_groupsendid+" in "
    					+"(select "+DBConstants.DB_SEND_GROUP_MB_groupsendid+" from "
    						+ "(select "+DBConstants.DB_SEND_GROUP_MB_groupsendid+","
    						+ " count("+DBConstants.DB_SEND_GROUP_MB_groupsendid+ ") "
    						+ " as "+ COUNT_NUM
    						+ " from " + DBConstants.DB_SEND_GROUP_MB
    						+ " group by "+DBConstants.DB_SEND_GROUP_MB_groupsendid+") as "+TABLE2//内部用不了COUNT_NUM,外部可以使用
    					+ " where "+TABLE2+"."+COUNT_NUM+" = "+gsmdtos.size()+" ) ";
    //		String sql1 = "select  "+DBConstants.DB_SEND_GROUP_MB_groupsendid+","
    //		+ " count("+DBConstants.DB_SEND_GROUP_MB_groupsendid+ ") "
    //		+ " as "+ COUNT_NUM
    //		+ " from " + DBConstants.DB_SEND_GROUP_MB
    //		+ " group by "+DBConstants.DB_SEND_GROUP_MB_groupsendid
    //		+ " order by "+ " count("+DBConstants.DB_SEND_GROUP_MB_groupsendid+ ") "+"  desc";
    		Cursor cursor  = db.rawQuery(sql1, null);
    		
    		ArrayList<String> cursorGrpSendIds=new ArrayList<String>();
    		MyLog.e(TAG, " getSumCountgsMebDTO cursor.count =  "+cursor.getCount());
    		StringBuffer sb=new StringBuffer();
    		while (cursor.moveToNext()) {
    			String memberNum = cursor.getString(cursor.getColumnIndex(DBConstants.DB_SEND_GROUP_MB_membernumber));
    			String groupsendid = cursor.getString(cursor.getColumnIndex(DBConstants.DB_SEND_GROUP_MB_groupsendid));
    			
    			sb.append(" getSumCountgsMebDTO result = "
    								+groupsendid
    									+" = "+memberNum
    								+";\n");
    		}
    		MyLog.e(TAG, sb.toString());
    	}





    展开全文
  • 示例1: GroupBy 分组在List<>泛型中的应用 ...按姓名Nam 分组后结果: 对DATATABLE 进行LAMDA查询时必须在项目的引用中添加 System.Data.DataSetExtensions public partial clas...
  • 聚合后根据count排序并取前2条数据 /** * 聚合后根据count排序并取前2条数据 */ @Test public void orderAfterAggregation(){ SearchResponse response = client.prepareSearch(&amp;quot;twitter&amp...
  • 基数排序(radix sort) 真言 科技是第一生产力。 引言 快过年了,祝大家新年快乐,在过年期间,博客也会一直出新。 思路 radix sort很牛叉,以空间换时间 时间复杂度O(n) 空间...
  • java的es分许排序查询 根据聚合结果排序 类似于SQL:select sex,count(*) from table_name group by sex order by count(*) 求大神解答?????急急急
  • (SELECT COUNT(*) FROM score B WHERE A.成绩<B.成绩)+1 AS Rank FROM score A 相同位次不跳过之后的位次 SELECT A.成绩 (SELECT COUNT(DISTANCT B.成绩) FROM score B WHERE A.成绩<B.成绩)+1 AS Rank ...
  • count_sort计数排序OpenMP的并行化

    千次阅读 2018-12-21 14:48:39
    计数排序,就是统计某个数值在所有的数字中所应该存在的位置,然后,放到一个确定的位置上。非常简单的排序算法。 程序 会读取data.txt中的文件 数据的样子 10 0 2 3 1 4 8 6 7 5 9 效果 PS D:\C++\VS\repo\...
  • Elasticsearch聚合学习之四:结果排序

    千次阅读 2019-05-04 18:18:00
    在前面的实战中,聚合的结果以桶(bucket)为单位,放在JSON数组中返回,这些数据是没有排序的,今天来学习如何给这些数据进行排序
  • UNION 查询结果排序

    2013-07-11 14:24:12
    今天想统计几个结果数据,于是用到了UNION关键字 select count(1) from XX_A UNION select count(1) from XX_B UNION select count(1) from XX_C   这样查询的结果会默认按升序排列,也就是A表的结果可能排...
  • jpql 怎么将子查询结果作为排序条件 比如 sql语句:select u.id,u.account,u.name,(select COUNT(m) from Usermessage m where m.userid=u.id and m.isreaded=0) AS aa from Memberuser u ORDER BY aa DESC 这样给他...
  • * 把前面的排序程序改成把排序结果用2种方式存储(二进制文件、文本文件)。 (该实验是在下面实验的基础上完成的) 已有的实验: 设计一个由自动测试排序算法性能(比较次数compare_count、交换次数exchange_...
  • 项目源码:...world前面已经介绍过了那么来介绍一个稍微那么高级一丢丢的基于排序的worldcount。 其实就是在worldcount 的基础上增加了一个 key-value 反转。和排序 下面给出java 示例...
  • elasticsearch 查询聚合结果排序

    万次阅读 2018-01-25 16:00:11
    一、查询结果按某个字段进行排序 { "size" : 5, "query" : { "bool" : { "filter" : [ { "range" : { "startTime" : { "from" : 1517046960000, "to" :
  • 看动画学算法之:排序-基数排序

    万次阅读 2020-07-25 13:07:35
    之前的文章我们讲了count排序,但是count排序有个限制,因为count数组是有限的,如果数组中的元素范围过大,使用count排序是不现实的,其时间复杂度会膨胀。 而解决大范围的元素排序的办法就是基数排序。
  • 程序员那些必须掌握的排序算法(上)

    万次阅读 多人点赞 2019-08-17 16:03:39
    如果有一个已经有序的数据序列,要求在这个已经排好的数据序列中插入一个数,但要求插入后此数据序列仍然有序,这个时候就要用到一种新的排序方法——插入排序法,插入排序的基本操作就是将一个数据插入到已经排好序...
  • 关于mysql查询出结果之后进行排序

    千次阅读 2019-01-02 21:57:04
    1、在进行排序之后进行序号: select (@i:=@i+1) as id,YX,ZY,ONE,TWO,THREE,FOUR,FIVE,SIX,SEVEN,EIGHT,NINE,TEN,SUM FROM ( select student.YX,student.ZY, sum(detail.ONE)/count() AS ONE,sum(detail.TWO)/count...
  • 在group函数的第5个参数处可指定分组后对组的排序表达式,这样报表展现时能够直接根据该表达式排序,但是将来某些单元格的数据可能是通过其他单元格计算后的结果,这样就无法通过group函数的参数指定,如下图: ...
  • elasticsearch 7.6 获取查询结果count

    千次阅读 2020-04-23 11:00:09
    分页插件需要{count}这个参数,类似MYSQL中的select count(*) from user where userType=1,获取结果集的count数量。 JAVA有两种方式可以获得 1、查询语句不变,将SearchSourceBuilder的“size”参数设置为0,获取...
  • 八大排序算法(C语言实现)

    万次阅读 多人点赞 2021-05-09 13:50:26
    文章目录插入排序插入排序希尔排序选择排序选择排序排序交换排序冒泡排序快速排序并归排序并归排序 插入排序 插入排序 希尔排序 选择排序 选择排序排序 交换排序 冒泡排序 快速排序 并归排序 并归排序 ...
  • 排序算法系列:基数排序

    万次阅读 多人点赞 2016-06-16 23:14:07
    这也是基数排序的魅力所在,基数排序可以理解成是建立在“计数排序”的基础之上的一种排序算法。在实际项目中,如果对效率有所要求,而不太关心空间的使用时,我会选择用计数排序(当然还有一些其他的条件),或是...
  • 八大排序算法 一、直接插入 - 1.基本思路 - 2.代码实现 - 3.时间复杂度和空间复杂度 二、希尔排序 - 1.基本思路 - 2.代码实现 - 3.时间复杂度和空间复杂度 三、简单选择 - 1.基本思路 - 2.代码实现 - 3.时间复杂度...
  • SQL---count()函数结果为null时替换为0

    万次阅读 2017-11-14 15:51:37
    在sql中,做count()统计时,如果结果为null,这条数据是不显示的,但是经常会有类似的需求,比如:统计江西省下的某11个市的企业数量,如果有些城市企业数量为null,会发现最后返回的结果不到11条。怎么办?
  • sql语法基础,对查询结果进行排序

    千次阅读 2019-11-09 21:13:15
    在学习GROUP BY 子句的时候我们知道要想对结果进行排序,就要对select进行相关命令。下面我们一起来学习一下,如何对查询结果进行排序 01 order by子句 格式: SELECT 列名1,列名2。。。。。 FROM 表名 ORDER ...
  • 各位老铁 Match (n:User)-[r:CALL]->(end:Friend)-[r1:CALL]->(u:User) return u,r,r1,n,end,返回能按有关系节点的个数排序返回?就是按count(n)+count(end)+count(u)的多少降序排序,类似于mysql中的groupby

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 490,659
精华内容 196,263
关键字:

count结果排序