精华内容
下载资源
问答
  • 参考资料:《C++ Primer》 ...一、对向量(vector)中的元素排序  #include <vector> ///可能需要 #include <algorithm> ///可能需要 std::vector<int> n...

    参考资料:《C++ Primer》


    一、对向量(vector)中的元素排序     

    #include <vector>                                 ///可能需要
    #include <algorithm>                              ///可能需要
    
    
    std::vector<int> nVec(8,124);                     ///建立8个int型元素,将8个元素通通赋值为124
    std::sort(nVec.begin(),nVec.end());               ///对nVec中的元素从小到大排序
    sort( nVec.begin(), nVec.begin()+nVec.size()/2 ); ///只对向量的前一半进行排序
     

    二、对内置数组指针对排序

    #include <algorithm>                   ///可能需要
    
    int ia[7] = { 10, 7, 9, 5, 3, 7, 1 };
    std::sort(ia,ia+7);                    ///对ia数组中的7个值按照从小到大排序
    std::sort(ia,ia+4);                    ///只对前4个元素从小到大排序

     

    展开全文
  • 下面将一下array_multisort函数array_multisort() 可以用来一次对多个数组进行排序,或者根据某一维或多维对多维数组进行排序。 关联(string)键名保持不变,但数字键名会被重新索引。 排序顺序标志:SORT_ASC – ...
  • 下面将一下array_multisort函数array_multisort() 可以用来一次对多个数组进行排序,或者根据某一维或多维对多维数组进行排序。 关联(string)键名保持不变,但数字键名会被重新索引。 排序顺序标志:SORT_ASC ...

    数据库中有4个字段分别是id,volume,edition,name. 要求对查询结果按照volume+edition从大到小排序。
    下面将一下array_multisort函数
    array_multisort() 可以用来一次对多个数组进行排序,或者根据某一维或多维对多维数组进行排序。

    关联(string)键名保持不变,但数字键名会被重新索引。

    排序顺序标志:
    SORT_ASC C 按照上升顺序排序
    SORT_DESC C 按照下降顺序排序
    排序类型标志:
    SORT_REGULAR C 将项目按照通常方法比较
    SORT_NUMERIC C 将项目按照数值比较
    SORT_STRING C 将项目按照字符串比较
    每个数组之后不能指定两个同类的排序标志。每个数组后指定的排序标志仅对该数组有效 C 在此之前为默认值 SORT_ASC 和 SORT_REGULAR。

    输入数组被当成一个表的列并以行来排序――这类似于 SQL 的 ORDER BY 子句的功能。第一个数组是要排序的主要数组。数组中的行(值)比较为相同的话就按照下一个输入数组中相应值的大小来排序,依此类推。

    本函数的参数结构有些不同寻常,但是非常灵活。第一个参数必须是一个数组。接下来的每个参数可以是数组或者是下面列出的排序标志。

    这样我们现在有这样一组数据

    复制代码 代码如下:

    // 这是一组从数据库查询出来的结果
    $data[] = array('volume' => 67, 'edition' => 2);
    $data[] = array('volume' => 86, 'edition' => 1);
    $data[] = array('volume' => 85, 'edition' => 6);
    $data[] = array('volume' => 98, 'edition' => 2);
    $data[] = array('volume' => 86, 'edition' => 6);
    $data[] = array('volume' => 67, 'edition' => 7);
    //我们需要先做出一个volume+edition的数组来
    foreach($data as $val){
         $arr[] = $val['volume'] + $val['edition']; 
    }
    // 将$arr根据降序排列
    // 把 $data 作为最后一个参数,以通用键排序
    array_multisort($arr, SORT_DESC, $data);

    转载于:https://www.cnblogs.com/2881064178dinfeng/p/6229747.html

    展开全文
  • 如何能够利用泛型的思想,相对什么数据进行排序就可以对什么数据进行排序,在写今天这篇博客之前,我们虽然都接触过函数指针,但很少去使用,也许是在学校根本涉及不到,因此,我们并不能知道其强大的功能。...

    我们在实际应用中的排序可能会不止一种,这时我们可能会在之前的基础上,进行进一步的比较,说白了,也就是多级排序。

    如何能实现自己的多级排序呢?如何能够利用泛型的思想,相对什么数据进行排序就可以对什么数据进行排序,在写今天这篇博客之前,我们虽然都接触过函数指针,但很少去使用,也许是在学校根本涉及不到,因此,我们并不能知道其强大的功能。

    最近看到这样一个题,要求从文件中读取一个学生的结构体,在成绩的基础上,女生优先,在同样性别的情况下,身高高的优先。这就好比在面试过程中(虽然我还没有面临这个问题,但马上会面对),如果在笔试或者面试成绩相同情况下,这时候公司会考虑其他的情况,比如学历,性别,出生地等各种信息。这就引出了多级排序的思想,当然你也可以确定数据类型,然后写多个不同的排序来完成这个功能。但数据类型变了呢,你的代码又要被改动。因此,我们要尽可能写出泛型的代码。好了,废话不多说了,其实,当我的代码写完时,发现其实C语言函数库其实为我们提供了这个功能,qsort()函数,大家有兴趣可以去看看。不过在写代码的过程中还是学习到了很多东西。大家可能等不及了,上代码。

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    struct student;
    int cmp_score(void *,void *);
    int cmp_sex(void *,void *);
    int cmp_height(void *,void *);
    void write(struct student *s,int len,char *path);
    void read(struct student *s,int len,char *path);
    void any_sort(void* s,int size,int nu,int (*cmp)(void*,void*));
    
    struct student
    {
    	char name[10];
    	short age;
    	short score;
    	short height;
    	char sex[6];
    };
    
    
    int main(int argc,char *argv[])
    {
    	if(argc!=2)
    	{
    		printf("canshubuzu\n");
    		return -1;
    	}
    	int i =0;
    
    	struct student s[7]=
    		{{"abc",23,60,160,"men"},{"ade",23,60,160,"women"},
    {"adf",23,60,165,"women"},{"asdf",24,67,166,"men"},{"sfs",23,68,156,"men"},
    {"def",25,78,165,"women"},{"sfw",24,35,178,"men"}};
    
    	struct student s1[7];
    	write(s,7,argv[1]);
    	read(s1,7,argv[1]);
    	any_sort((void*)s,sizeof(struct student),7,cmp_score);
    
    	for(i = 0;i<7;i++)
    	{
    		printf("%s %d %d %d %s\n",s[i].name,s[i].age,s[i].score,s[i].height,s
    [i].sex);
    	}
    	return 0;
    }
    
    
    void read(struct student *s,int len,char *path)
    {
    	FILE *fp = NULL;
    	int i = 0;
    	fp = fopen(path,"rb");
    
    	if(NULL == fp)
    	{
    		perror("fopen fail\n");
    		return;
    	}
    	while(i<len)
    	{
    		fread(s+i,sizeof(struct student),1,fp);
    		i++;
    	}
    	fclose(fp);
    }
    
    
    void write(struct student *s,int len,char *path)
    {
    	int i =0;
    	FILE *fp = NULL;
    	fp =  fopen(path,"wb");
    	if(NULL == fp)
    	{
    		return;
    	}
    
    	while(i<len)
    	{
    		fwrite(s+i,sizeof(struct student),1,fp);
    		i++;
    	}
    	fclose(fp);
    }
    
    void any_sort(void* s,int size,int nu,int (*cmp)(void*,void*))
    {
    	int i,j;
    	void* buf=malloc(size);
    	int index;
    
    	if(NULL == buf)
    	{
    		return;
    	}
    
    	for(i = 0;i<nu-1;i++)
    	{
    		index = i;
    		for(j =i;j<nu;j++)
    		{
    			if(cmp((void*)((char*)s+index*size),(void*)((char*)s+j*size))>0)
    				index = j;
    		}
    		if(i!=index)
    		{
    			memcpy(buf,(void*)((char*)s+i*size),size);
    			memcpy((void*)((char*)s+i*size),(void*)((char*)s+index*size),size);
    			memcpy((void*)((char*)s+index*size),buf,size);
    		}
    	}
    	free(buf);
    }
    
    int cmp_score(void *a,void *b)
    {
    	struct student s1 = *(struct student*)a;
    	struct student s2 = *(struct student*)b;
    
    	if(s1.score == s2.score)
    	{
    		if(0 == cmp_sex(a,b))
    		{
    			return cmp_height(a,b);
    		}
    		else
    			return cmp_sex(a,b);
    	}
    	return s1.score-s2.score;
    }
    
    int cmp_sex(void *a,void *b)
    {
    	struct student s1 =*(struct student*)a;
    	struct student s2 =*(struct student*)b;
    
    	return -strcmp(s1.sex,s2.sex);
    }
    
    
    
    int cmp_height(void *a,void *b)
    {
    	struct student s1 = *(struct student*)a;
    	struct student s2 = *(struct student*)b;
    	return s2.height-s1.height;
    
    }
    

    运行结果:



    展开全文
  • 我们可以对列表调用sort函数,进行原地排序,或者是调用内置的sorted函数,不修改原始列表,并返回一个新的排好序的列表。两个函数都有相同的参数,基于目的来说可以认为是相同的,除了我们上面提到的不同。 ...

    Python中对一个列表或者元组进行排序是很简单的!既然元组基本上可以认为是一个不可以修改的数组,我们几乎可以将其视为一个列表。

    对Python列表排序的最简单的方式

    如果你只是想对一个数字列表进行排序,Python内置的函数可以帮你实现。

    我们有一个数字列表:

    >>> a = [3, 6, 8, 2, 78, 1, 23, 45, 9]
    我们想对其进行升序排列。我们可以对列表调用sort函数,进行原地排序,或者是调用内置的sorted函数,不修改原始列表,并返回一个新的排好序的列表。两个函数都有相同的参数,基于目的来说可以认为是相同的,除了我们上面提到的不同。

    我们试一下:

    >>> sorted(a)
    [1, 2, 3, 6, 8, 9, 23, 45, 78]
    >>>
    >>> a.sort()
    >>> a
    [1, 2, 3, 6, 8, 9, 23, 45, 78]
    如果想要实现降序排序呢,如下所示:

    >>> sorted(a, reverse=True)
    [78, 45, 23, 9, 8, 6, 3, 2, 1]
    >>> a.sort(reverse=True)
    >>> a
    [78, 45, 23, 9, 8, 6, 3, 2, 1]
    在这种场景下Python在背后做了什么呢?它在列表中调用一个mergesort的版本。当比较值时,它调用__cmp__函数在每一个对象上,基于__cmp__的返回值,来决定哪一个应该放在另一个的前面。返回值为0代表两个值相等,1代表大于,-1代表小于。后面我们会用到这些信息来做我们自己的对象的排序。

    你可能会说,对元组排序又是什么情况呢?我们这就开始介绍。

    对Python元组排序的最简单方式

    既然元组是一个你不能改变的数组,所以没有一个原地排序的函数可以直接被调用。它们必须使用sorted函数来返回一个列表。记住,这儿是怎么做的:

    >>> tup = (3, 6, 8, 2, 78, 1, 23, 45, 9)
    >>> sorted(tup)
    [1, 2, 3, 6, 8, 9, 23, 45, 78]
    注意sorted返回的是一个数组。

    好了,我们开始看看如何对更复杂的进行排序。

    对列表的列表或者元组的列表进行排序


    这有点复杂,但是仍然很简单,所以不用害怕!sorted函数和sort函数都接受一个关键字参数key。

    key的作用是提供了一种方式指定一个函数,该函数返回你想要你的元素怎样排序。这个函数有一个"不可见"的参数,代表了一个列表中的元素,并返回一个你想要的元素的key来排序的值。

    让我们用示例说明这个key关键字参数!

    所以,取一个新的列表,我们想测试根据每个子列表的第一个元素进行排序:

    >>> def getKey(item):
    ...     return item[0]
    >>> l = [[2, 3], [6, 7], [3, 34], [24, 64], [1, 43]]
    >>> sorted(l, key=getKey)
    [[1, 43], [2, 3], [3, 34], [6, 7], [24, 64]]
    这里我们看到列表根据子列表的第一个值进行了升序排序。你也可以使用sort函数,但是我个人认为sorted函数更好,所以在后面的例子中我还会使用它。

    发生什么?还记得我之前谈到的"不可见"参数吗?那就是每一次sorted需要一个值,传入getKey函数的值。这是一个Python的小技巧。

    如果想要对子列表的第二个值进行排序,很简单,只需要改变getKey函数像下面这样:

    def getKey(item):
        return item[1]
    好了,一切都很好。那如何对元组的列表进行排序呢?很高兴你问了这个!

    实际上和我们上面的例子是完全一样的,但是列表定义如下:

    >>> a = [(2, 3), (6, 7), (3, 34), (24, 64), (1, 43)]
    >>> sorted(l, key=getKey)
    [(1, 43), (2, 3), (3, 34), (6, 7), (24, 64)]
    唯一改变的是我们现在得到了一个元组的列表,而不是一个列表的列表。

    同样的方法也可以作用在元组的元组上,所以我就不深入介绍它了,因为那就显得多余了。

    对自定义Python对象的列表进行排序

    这里是我自定义的一个对象:

    class Custom(object):
        def __init__(self, name, number):
            self.name = name
            self.number = number
    为了排序的目的,我们建立一个它们的列表:

    customlist = [
        Custom('object', 99),
        Custom('michael', 1),
        Custom('theodore the great', 59),
        Custom('life', 42)
    ]
    好了,我们得到了一个花哨的自定义对象的列表,并且我们想要对它进行排序。我们应该怎么做呢?

    好的,我们可以定义一个函数,就像我们上面做的那样,接受元素并返回一个列表。所以我们这么做。

    def getKey(custom):
        return custom.number
    有一点不同的是,因为我们的对象不再是一个列表。这允许我们根据自定义对象的数字属性进行排序。

    所以如果我们在我们的花里胡哨的自定义对象上应用sorted函数,我们得到这些:

    >>> sorted(customlist, key=getKey)
    [<__main__.Custom object at 0x7f64660cdfd0>,
    <__main__.Custom object at 0x7f64660d5050>,
    <__main__.Custom object at 0x7f64660d5090>,
    <__main__.Custom object at 0x7f64660d50d0>]
    一大堆我们看不明白的东西。很好。但是不用担心,亲爱的读者,有一个简单的方法可以作用到我们的自定义对象上,使它看起来好看一些!

    我们重新定义对象类:

    class Custom(object):
        def __init__(self, name, number):
             self.name = name
             self.number = number
        
        def __repr__(self):
             return '{}: {} {}'.format(self.__class__.__name__,
                                       self.name,
                                       self.number)
    好的,我们对它做了什么呢?首先,__repr__函数告诉Python我们想让对象如何被表达。在更复杂的情况下,当它被打印在屏幕上时,它告诉解释器如何显示对象。
    现在我们试着对它再一次排序:

    >>> sorted(customlist, key=getKey)
    [Custom: michael 1, Custom: life 42,
     Custom: theodore the great 59, Custom: object 99]
    这看起来好很多了!我们现在实际已经知道排序是正确的!

    但是,仍然有一点小问题。看起来有点吹毛求疵,但是我不想每次我想要调用sorted的时候都输入key关键字

    我们再次重新定义我们的对象,如下所示:

    class Custom(object):
        def __init__(self, name, number):
            self.name = name
            self.number = number
     
        def __repr__(self):
            return '{}: {} {}'.format(self.__class__.__name__,
                                      self.name,
                                      self.number)
     
        def __cmp__(self, other):
            if hasattr(other, 'number'):
                return self.number.__cmp__(other.number)
    看起来很好。它所做的是告诉Python如何去比较当前对象的值与在列表中的另一个对象的值。如我所述,sorted函数将会调用__cmp__函数在对象上,为了决定它应该放在那儿根据与其它对象的关系。

    现在我们可以调用sorted而不用担心包括key关键字,如下所示:

    >>> sorted(customlist)
    [Custom: michael 1, Custom: life 42, Custom: theodore the great 59, Custom: object 99]
    它工作的很好。请注意所有上面的也作用在自定义对象组成的元组上。但是,正如你知道的,我喜欢节省我的数字树(digital tree)。

    对各种各样的Python自定义对象列表的排序

    好吧。既然Python是一门动态语言,它并不是很关心我们扔到列表中的是什么对象。它们可以是相同的类型,或者完全不同。

    所以,我们定义另一个不同的对象来使用我们的Custom对象。

    class AnotherObject(object):
         def __init__(self, tag, age, rate):
              self.tag = tag
              self.age = age
              self.rate = rate
    
         def __repr__(self):
             return '{}: {} {} {}'.format(self.__class__.__name__,
                                          self.tag,
                                          self.age,
                                          self.rate)
    
         def __cmp__(self, other):
             if hasattr(other, 'age'):
                 return self.age.__cmp__(other.age)
    这是一个相似的对象,但是和我们的Custom对象仍然有些不同。
    让我们建立一个这些对象与Custom对象的列表:

    customlist = [
        Custom('object', 99),
        Custom('michael', 1),
        Custom('theodore the great', 59),
        Custom('life', 42),
        AnotherObject('bananas', 37, 2.2),
        AnotherObject('pants', 73, 5.6),
        AnotherObject('lemur', 44, 9.2)
    ]
    现在我们试着在列表上运行sorted函数:

    >>> sorted(customlist)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: an integer is required
    我们得到了一个可爱的错误。为什么?因为Custom没有叫做age的属性,AnotherObject没有叫做number的属性。

    我们能做什么呢?Panic!

    只是开个玩笑而已。我们知道做什么。让我们再次重新顶一个这些对象。

    class Custom(object):
        def __init__(self,name,number):
            self.name = name
            self.number = number
     
        def __repr__(self):
            return '{}: {} {}'.format(self.__class__.__name__,
                                      self.name,
                                      self.number)
     
        def __cmp__(self, other):
            if hasattr(other, 'getKey'):
                return self.getKey().__cmp__(other.getKey())
     
        def getKey(self):
            return self.number
     
     
    class AnotherObject(object):
        def __init__(self, tag, age, rate):
            self.tag = tag
            self.age = age
            self.rate = rate
     
        def __repr__(self):
            return '{}: {} {} {}'.format(self.__class__.__name__,
                                         self.tag,
                                         self.age, self.rate)
     
        def __cmp__(self, other):
            if hasattr(other, 'getKey'):
                return self.getKey().__cmp__(other.getKey())
     
        def getKey(self):
            return self.age

    多么令人惊叹呀!我们刚才做了些什么?我们定义了一个公共的getKey函数,两个对象都有该公共的函数,所以我们可以轻易地进行比较。

    现在我们再运行一次sorted函数,我们得到:

    >>> sorted(customlist)
    [Custom: michael 1, AnotherObject: bananas 37 2.2,
    Custom: life 42, AnotherObject: lemur 44 9.2,
    Custom: theodore the great 59, AnotherObject: pants 73 5.6,
    Custom: object 99]
    很好!现在我们的对象可以比较并排序,根据它们核心的内容。

    你说你仍然喜欢使用key关键字?
    你也可以这么做。如果你省去每个对象中的__cmp__函数,并且在函数外定义类似于下面的函数:

    def getKey(customobj):
        return customobj.getKey()
    然后像下面这样调用sorted:
    >>> sorted(customlist, key=getKey)
    [Custom: michael 1, AnotherObject: bananas 37 2.2,
    Custom: life 42, AnotherObject: lemur 44 9.2,
    Custom: theodore the great 59, AnotherObject: pants 73 5.6,
    Custom: object 99]
    这里你学会了它。非常简洁,但是并不像一些人想的那样简洁。Python使用内置的sorted函数使他变得很容易。

    更多关于排序的想法,可以去看How to sort Python Dictionaries by Key or Value。你也可以通过Lambda Function Syntax (Inline Functions) in Python得到如何根据lambda函数进行排序。

    离成为Python专家又更近了一步。




    本文翻译自这篇文章

    展开全文
  • 2、全选B2:D14单元格区域,右击鼠标选择【排序】,点击【升序】(此步骤适合高版本excel,低版本可以点击数据选择排序然后按照户主进行升序排序) 3、在A2单元格输入数值1 4、在A3单元格输入公式=IF((COUNTIF($B$2...
  • 单独去写排序我想并不如何困难,但是想要利用函数似乎并不是很容易。涉及到函数传递的问题从来就没有简单过,有时候即使编译器并没有报错但是在执行的过程中并没有实现排序的功能。 以下的代码是最经典的排序代码,...
  • 本次分享将讲述如何利用Python中的reduce函数对序列求最值以及排序。我们用reduce函数对序列求最值的想法建立在冒泡排序的算法上。先上例子?from functools import reducefrom random import randintA = [randint(1...
  • 排序优化:如何实现一个通用的、高性能的排序函数 几乎所有的编程语言都提供排序函数,这些排序函数如何实现的?底层都利用了哪种排序算法? 如何选择合适的排序算法 对小规模数据进行排序,可以选择时间复杂度是o...
  •   在一般讲述Python的reduce函数的例子中,通常都是拿...  本次分享将讲述如何利用Python中的reduce函数对序列求最值以及排序。   我们用reduce函数对序列求最值的想法建立在冒泡排序的算法上。先上例子? f...
  • 几乎所有的编程语言都会提供排序函数,比如C语言中的...那你知道这些排序函数如何实现的吗?底层都利用了那种排序算法呢?基于这些问题,今天我们就来看排序这部分的最后一块内容:如何实现一个通用的,高性能...
  • 那你知道这些排序函数如何实现的吗?底层都利用了哪种排序算法呢? 基于这些问题,今天我们就来看排序这部分的最后一块内容:如何实现一个通用的、高性能的排序函数如何选择合适的排序算法? 如果要实现一个...
  • Excel中分组排序只需要对数据进行升序降序,再利用if函数...下面介绍如何利用用户变量进行分组排序并取top1数据。1、现在有一份数据表tmp_provice_sales,如下:表格记录的是某商品省份城市销售数量,现在需要提取...
  • # sort.py # -*- coding: gbk -*# 这个类用来演示如何对自定义对象进行排序 class Sortobj: a = 0 b = '' def __init__(self, a, b): self.a = a self.b = b def printab(self): ...
  • int minindex(float array[], int n, int i, int mode)//这是已知的函数 { int k1,k2, s;...如何利用上面的函数对一个数组进行排序呢?(我只会纯冒泡法来解决,但要是利用调用函数我就真的不会了)
  • 题目:给定无序a[] = {77,2,80,48,25,56,90,84,71,10,},如何排列成有序数组? 思考方向一:在数组里找出最大的数组,输出它的位置 设第0位为maxid 如果 a[1]&amp;amp;amp;amp;amp;gt;a[maxid], 让 maxid = 1 ...
  • list容器已经给出排序函数sort。 只需要重载比较函数就可以。 typedef struct inforNode { unsigned char name[20]; unsigned char number[10]; unsigned char age[3]; unsigned char country[20]; struct ...
  • 今天是度量学习损失函数的第二部分,N-Pair和Angular损失。 这是排序损失综述的第二部分。第一部分涵盖了对比损失和三元组损失。在这一部分中,给出了N-pairs和angular损失。 N-Pairs Loss 对比损失和三元组损失...
  • 前言 在程序中使用字典进行数据信息统计时,由于字典是无序的所以打印字典时内容也是无序的。因此,为了使统计得到的...排序用sorted内置函数,关键字key参数用lambda表达式取出字典中x值作为排序依据,关键字reverse
  • 一篇关于度量学习损失函数的综述,这是第一部分,对比损失和三元组损失。 检索网络对于搜索和索引是必不可少的。深度学习利用各种排名损失来学习一个对象的嵌入 —— 来自同一类的对象的嵌入比来自不同类的对象的...
  • sql中把varchar类型转换为int型然后进行排序 如果我们数据库的ID设置为varchar型的 在查询的时候order by id的话 我们是不希望看到如下情况的 我们可以把varchar转换为int 然后进行排序 一、 [sql] select * ...
  • sort()函数排序原理

    2020-05-18 17:42:08
    首先,要理解sort()内部是利用递归进行冒泡排序的; 例如: var arr = [1, 5, 4, 2]; sort()方法的比较逻辑为: 第一轮:1和5比,1和4比,1和2比 第二轮:5和4比,5和2比 第三轮:4和2比 其次,sort()方法会接受一个...
  • 伴随着SQL Server 2005 ,微软发布了公共语言运行库(CLR),允许开发人员和DBA能够利用SQL Server之外的托管代码。  CLR为那些懂的.net开发语言,但是不...在本文中,我们通过一个例子,来看看如何使用CLR函数,对...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 437
精华内容 174
关键字:

如何利用函数排序