sort函数降序？sort函数怎么降序
大家好，今天小编来为大家解答sort函数降序这个问题，sort函数怎么降序很多人还不知道，现在让我们一起来看看吧！
sort函数的具体用法
sort函数的用法：
做ACM题的时候，排序是一种经常要用到的操作。如果每次都自己写个冒泡之类的O(n^2)排序，不但程序容易超时，而且浪费宝贵的比赛时间，还很有可能写错。STL里面有个sort函数，可以直接对数组排序，复杂度为n*log2(n)。使用这个函数，需要包含头文件。
这个函数可以传两个参数或三个参数。第一个参数是要排序的区间首地址，第二个参数是区间尾地址的下一地址。也就是说，排序的区间是[a,b)。简单来说，有一个数组int a[100]，要对从a[0]到a[99]的元素进行排序，只要写sort(a,a+100)就行了，默认的排序方式是升序。
拿我出的“AC的策略”这题来说，需要对数组t的第0到len-1的元素排序，就写sort(t,t+len);
对向量v排序也差不多，sort(v.begin(),v.end());
排序的数据类型不局限于整数，只要是定义了小于运算的类型都可以，比如字符串类string。
如果是没有定义小于运算的数据类型，或者想改变排序的顺序，就要用到第三参数——比较函数。比较函数是一个自己定义的函数，返回值是bool型，它规定了什么样的关系才是“小于”。想把刚才的整数数组按降序排列，可以先定义一个比较函数cmp
bool cmp(int a,int b)
{
return a>b;
}
排序的时候就写sort(a,a+100,cmp);
假设自己定义了一个结构体node
struct node{
int a;
int b;
double c;
}
有一个node类型的数组node arr[100]，想对它进行排序：先按a值升序排列，如果a值相同，再按b值降序排列，如果b还相同，就按c降序排列。就可以写这样一个比较函数：
以下是代码片段：
bool cmp(node x,node y)
{
if(x.a!=y.a) return x.a
if(x.b!=y.b) return x.b>y.b;
return return x.c>y.c;
}排序时写sort(arr,a+100,cmp);
qsort(s[0],n,sizeof(s[0]),cmp);
int cmp(const void*a,const void*b)
{
return*(int*)a-*(int*)b;
}
一、对int类型数组排序
int num[100];
Sample:
int cmp( const void*a, const void*b)
{
return*(int*)a-*(int*)b;
}
qsort(num,100,sizeof(num[0]),cmp);
二、对char类型数组排序（同int类型）
char word[100];
Sample:
int cmp( const void*a, const void*b)
{
return*(char*)a-*(int*)b;
}
qsort(word,100,sizeof(word[0]),cmp);
三、对double类型数组排序（特别要注意）
double in[100];
int cmp( const void*a, const void*b)
{
return*(double*)a>*(double*)b? 1:-1;
}
qsort(in,100,sizeof(in[0]),cmp)；
四、对结构体一级排序
struct In
{
double data;
int other;
}s[100]
//按照data的值从小到大将结构体排序,关于结构体内的排序关键数据data的类型可以很多种，参考上面的例子写
int cmp( const void*a,const void*b)
{
return((In*)a)->data-((In*)b)->data;
}
qsort(s,100,sizeof(s[0]),cmp);
五、对结构体
struct In
{
int x;
int y;
}s[100];
//按照x从小到大排序，当x相等时按照y从大到小排序
int cmp( const void*a, const void*b)
{
struct In*c=(In*)a;
struct In*d=(In*)b;
if(c->x!= d->x) return c->x- d->x;
else return d->y- c->y;
}
qsort(s,100,sizeof(s[0]),cmp);
六、对字符串进行排序
struct In
{
int data;
char str[100];
}s[100];
//按照结构体中字符串str的字典顺序排序
int cmp( const void*a, const void*b)
{
return strcmp(((In*)a)->str,((In*)b)->str);
}
qsort(s,100,sizeof(s[0]),cmp);
七、计算几何中求凸包的cmp
int cmp(const void*a,const void*b)//重点cmp函数，把除了1点外的所有点，旋转角度排序
{
struct point*c=(point*)a;
struct point*d=(point*)b;
if( calc(*c,*d,p[1])< 0) return 1;
else if(!calc(*c,*d,p[1])&& dis(c->x,c->y,p[1].x,p[1].y)< dis(d->x,d->y,p[1].x,p[1].y))//如果在一条直线上，则把远的放在前面
return 1;
else return-1;
}
VC++怎么降序排列
首先看sort函数见下表：
函数名
功能描述
sort
对给定区间所有元素进行排序
stable_sort
对给定区间所有元素进行稳定排序
partial_sort
对给定区间所有元素部分排
partial_sort_copy
对给定区间复制并排序
nth_element
找出给定区间的某个位置对应的元素
is_sorted
判断一个区间是否已经排好序
partition
使得符合某个条件的元素放在前面
stable_partition
相对稳定的使得符合某个条件的元素放在前面
要使用此函数只需用#include
<algorithm>
sort即可使用，语法描述为：
sort(begin,end)，表示一个范围，例如：
int
_tmain(int
argc,
_TCHAR*
argv[])
{
int
a[20]={2,4,1,23,5,76,0,43,24,65},i;
for(i=0;i<20;i++)
cout<<a[i]<<endl;
sort(a,a+20);
for(i=0;i<20;i++)
cout<<a[i]<<endl;
return
0;
}
输出结果将是把数组a按升序排序，说到这里可能就有人会问怎么样用它降序排列呢？这就是下一个讨论的内容.
一种是自己编写一个比较函数来实现，接着调用三个参数的sort：sort(begin,end,compare)就成了。对于list容器，这个方法也适用，把compare作为sort的参数就可以了，即：sort(compare).
1）自己编写compare函数：
bool
compare(int
a,int
b)
{
return
a<b;
//升序排列，如果改为return
a>b，则为降序
}
int
_tmain(int
argc,
_TCHAR*
argv[])
{
int
a[20]={2,4,1,23,5,76,0,43,24,65},i;
for(i=0;i<20;i++)
cout<<a[i]<<endl;
sort(a,a+20,compare);
for(i=0;i<20;i++)
cout<<a[i]<<endl;
return
0;
}
2）更进一步，让这种操作更加能适应变化。也就是说，能给比较函数一个参数，用来指示是按升序还是按降序排,这回轮到函数对象出场了。
为了描述方便，我先定义一个枚举类型EnumComp用来表示升序和降序。很简单：
enum
Enumcomp{ASC,DESC};
然后开始用一个类来描述这个函数对象。它会根据它的参数来决定是采用“<”还是“>”。
class
compare
{
private:
Enumcomp
comp;
public:
compare(Enumcomp
c):comp(c)
{};
bool
operator
()
(int
num1,int
num2)
{
switch(comp)
{
case
ASC:
return
num1<num2;
case
DESC:
return
num1>num2;
}
}
};
接下来使用
sort(begin,end,compare(ASC)实现升序，sort(begin,end,compare(DESC)实现降序。
主函数为：
int
main()
{
int
a[20]={2,4,1,23,5,76,0,43,24,65},i;
for(i=0;i<20;i++)
cout<<a[i]<<endl;
sort(a,a+20,compare(DESC));
for(i=0;i<20;i++)
cout<<a[i]<<endl;
return
0;
}
3)其实对于这么简单的任务（类型支持“<”、“>”等比较运算符），完全没必要自己写一个类出来。标准库里已经有现成的了，就在functional里，include进来就行了。functional提供了一堆基于模板的比较函数对象。它们是（看名字就知道意思了）：equal_to<Type>、not_equal_to<Type>、greater<Type>、greater_equal<Type>、less<Type>、less_equal<Type>。对于这个问题来说，greater和less就足够了，直接拿过来用：
升序：sort(begin,end,less<data-type>());
降序：sort(begin,end,greater<data-type>()).
int
_tmain(int
argc,
_TCHAR*
argv[])
{
int
a[20]={2,4,1,23,5,76,0,43,24,65},i;
for(i=0;i<20;i++)
cout<<a[i]<<endl;
sort(a,a+20,greater<int>());
for(i=0;i<20;i++)
cout<<a[i]<<endl;
return
0;
}
4)既然有迭代器，如果是string
就可以使用反向迭代器来完成逆序排列，程序如下：
int
main()
{
string
str("cvicses");
string
s(str.rbegin(),str.rend());
cout
<<
s
<<endl;
return
0;
}
qsort():
原型:
_CRTIMP
void
__cdecl
qsort
(void*,
size_t,
size_t,int
(*)(const
void*,
const
void*));
解释:
qsort
(
数组名
，元素个数，元素占用的空间(sizeof)，比较函数)
比较函数是一个自己写的函数
遵循
int
com(const
void
*a,const
void
*b)
的格式。
当a
b关系为
>
<
=
时，分别返回正值
负值
零
（或者相反）。
使用a
b
时要强制转换类型，从void
*
转换回应有的类型后，进行操作。
数组下标从零开始,个数为N,
下标0-(n-1)。
实例：
int
compare(const
void
*a,const
void
*b)
{
return
*(int*)b-*(int*)a;
}
int
main()
{
int
a[20]={2,4,1,23,5,76,0,43,24,65},i;
for(i=0;i<20;i++)
cout<<a[i]<<endl;
qsort((void
*)a,20,sizeof(int),compare);
for(i=0;i<20;i++)
cout<<a[i]<<endl;
return
0;
}
vector中的升序算法是sort()但降序算法是啥呀求用法
一个名为v的vector中，降序排序用法如下：
sort(v.begin(), v.end(),greater<int>())；
自定义类型排序：
bool SortByM1( const Test&v1, const Test&v2)//注意：本函数的参数的类型一定要与vector中元素的类型一致
{ return v1.member1< v2.member1;//升序排列}
std::sort(vecTest.begin(),vecTest.end(),SortByM1)；
迭代器访问
vector<int>::iterator iter=test.begin()；//定义一个可以迭代int型vector的迭代器iter，它指向test的首位
for(;iter!=test.end();iter++) cout<<(*iter)；//iter++指的是向后迭代一位，直到iter到超出末端迭代器为止，输出迭代器指向的值。
扩展资料
vector是同一种类型的对象的集合,每个对象都有一个对应的整数索引值。和string对象一样,标准库将负责管理与存储元素相关的内存。
把 vector称为容器,是因为可以包含其他对象，能够存放任意类型的动态数组，增加和压缩数据。一个容器中的所有对象都必须是同一种类型的。
vector是一个类模板(class template)。使用模板可以编写一个类定义或函数定义,而用于多个不同的数据类型。因此，可以定义保存string对象的 vector，或保存int值的vector，又或是保存自定义的类类型对象(如Sales_items对象)的 vector。
vector不是一种数据类型，而只是一个类模板，可用来定义任意多种数据类型。vector类型的每一种都指定了其保存元素的类型。
参考资料来源：百度百科-vector
关于sort函数降序，sort函数怎么降序的介绍到此结束，希望对大家有所帮助。