数组排序函数(vba数组排序函数)
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 ab;
}
排序的时候就写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.by.b;
return return x.cy.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;
}
编写一个对数组元素进行升序排序的函数。
#includestdio.h
#define?N?10?
void?fun(int?*a,int?n)?{?int?i,j,k;
??for?(?i=0;in-1;i++?)
????for?(?j=i+1;jn;j++?)
??????if?(?a[i]a[j]?)?{?k=a[i];?a[i]=a[j];?a[j]=k;?}
}
void?main()?{?int?a[N],i;
??for?(?i=0;iN;i++?)?scanf("%d",a[i]);
??fun(a,N);
??for?(?i=0;iN;i++?)?printf("%d?",a[i]);?printf("\n");
}
将数组的数由小到大排序是哪个函数
函数声明后面要加分号
/****************************** 改进的冒泡排序 ******************************
函 数 名：int BubbleImprovedSort(int a[], int n)
参 数：int a[]---待排序的数据
int len---待排序数据的个数，也即数组a的长度
功 能：完成改进的冒泡排序
返 回 值：排序过程中发生交换的次数
基本思想：对冒泡排序常见的改进方法是加入一标志性变量exchange，用于标志某一趟
排序过程中是否有数据交换，如果进行某一趟排序时并没有进行数据交换，
则说明数据已经按要求排列好，可立即结束排序，避免不必要的比较过程。
说 明：排序好的数据依然存放在数组a中
*****************************************************************************/
int BubbleImprovedSort(int a[], int len)
{
int i, j, temp, CompareNum=0;
int exchange; // 交换标志，若某趟排序中所有元素位置未发生交换则说明排序完成
for(i=0; ilen-1; i++) // 最多需len-1趟排序
{
exchange = 0;
for(j=0; jlen-i-1; j++) // 每趟排序最多需要len-i-1次比较
{
if(a[j] a[j+1]) // 将较大的值放到后面
{
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
exchange = 1;
}
CompareNum++; // 比较次数加1
}
if(exchange == 0) // 说明某趟排序没有发生交换，也即排序完成，可以提前终止
return CompareNum;
}
return CompareNum;
}
数组排序函数
#include stdio.h
int sort(int data[],int n);
main()
{
int mat[10];
for (int i = 0; i = 9; ++i)
scanf ("%d", mat[i]);
sort (mat,10);
for (int j = 0; j = 9; ++j)
printf ("%d ", mat[j]);
printf ("\n");
return 0;
}
int sort(int d[], int n)
{
int temp;
for (int i=1; in; i++)
{
for (int j=i-1; j=0; j--)
{
if (d[j] d[j+1])
{
temp = d[j];
d[j] = d[j+1];
d[j+1] = temp;
}
}
}
return 0;
}