在降序排序中，若要排序的一列中有空白单元的行会被______。

基本不能实现,cxcel都是按单元格操作的,把单元格内的值试为一个数值,
除非你这里的数值少,用公式,先把他分割成一个个数值,再注最小值,一个个求得后再组合一起,得多级嵌套,非常麻烦.

int a[50],b;
for(int i = 0;i

我觉得楼上的是错的!如果不能的话找我!qq776871598
那个排序的从第二个和第三个开始吗?第一个怎么办
而却循环次数也有歧义!不懂我是不是错的!所以楼主先试验下

group by 国家名称：按国家名称分组可得到每个国家名称对应的金牌数量
order by 2 desc,国家名称 desc：先根据第2个查询出来的字段也就是金牌数排序,desc指定降序.然后再根据“国家名称”排序,desc指定降序.
order by 可以根据一个或几个字段进行排序,放在前面的优先.

index on 学号 tag 学号 desc

选B，主要关键字必须指定。

全选整个表格,在数据->排序,选择列B,确定

你出的选择题,我认为选A

两个都对啊

#include "stdio.h" void main(void) { int a[10]={11,52,63,17,21,58,71,42,3,16}; int i,j,d; for(i=0;i

#include
#include
#include
#define N 40
typedef struct node{
int x,z;
struct node *next;
}*pnode;
int isnum(char c)
{
if(c>='0'&&cx=-(p->x);
q=create_duo(c,j);
p->next=q;
return p;
}
else
return create_duo(c,j); //系数为0项,不建立,跳过.
}//把一元多项式的字符串用链式存储.
pnode plus(pnode p,pnode q)
{
pnode P,H,t,m,n;
m=p;
n=q;
H=P=(pnode)malloc(sizeof(node));
while(m!=NULL&&n!=NULL)
{
t=(pnode)malloc(sizeof(node));
if(m->z>n->z)
{
t->x=m->x;
t->z=m->z;
m=m->next;
}
else
if(m->z==n->z)
{
if(m->x==-(n->x))
{
m=m->next;
n=n->next;
continue;
}//指数相同,系数相反,情况处理.
t->x=m->x+n->x;
t->z=n->z;
m=m->next;
n=n->next;
}
else
{
t->x=n->x;
t->z=n->z;
n=n->next;
}
P->next=t;
P=P->next;
}
while(m!=NULL)
{
t=(pnode)malloc(sizeof(node));
t->x=m->x;
t->z=m->z;
m=m->next;
P->next=t;
P=P->next;
}
while(n!=NULL)
{
t=(pnode)malloc(sizeof(node));
t->x=n->x;
t->z=n->z;
n=n->next;
P->next=t;
P=P->next;
}
P->next=NULL;
P=H;
H=H->next;
free(P);
return H;
}//两个一元多项式的相加.
pnode minus(pnode p,pnode q)
{
if(q==NULL) return p;
pnode t,h,g,q1;
t=q;
h=(pnode)malloc(sizeof(node));
h->x=-(t->x);
h->z=t->z;
t=t->next;
q1=h;
g=h;
while(t!=NULL)
{
h=(pnode)malloc(sizeof(node));
h->x=-(t->x);
h->z=t->z;
g->next=h;
g=g->next;
t=t->next;
}
g->next=NULL;
if(p==NULL) return q1;
return (plus(p,q1));
}//两个一元多项式的差.
pnode chen(pnode p,pnode q)
{
pnode k,h,t,g;
k=p;
t=(pnode)malloc(sizeof(node));
h=t;
h->x=(k->x)*(q->x);
h->z=k->z+q->z;
k=k->next;
g=h;
while(k!=NULL)
{
h=(pnode)malloc(sizeof(node));
h->x=(k->x)*(q->x);
h->z=k->z+q->z;
g->next=h;
g=g->next;
k=k->next;
}
g->next=NULL;
return t;
}//多项式中的一项与另一个多项式的乘.
pnode chenduo(pnode p1,pnode p2)
{
void free_pnode(pnode p);//释放一个链表空间.
if(p1==NULL||p2==NULL) return NULL;
pnode m,n,t,g;
n=p2;
t=NULL;
while(n!=NULL)
{
m=chen(p1,n);
g=plus(t,m);
free_pnode(m);
free_pnode(t);
t=g;
n=n->next;
}
return t;
}//两个多项式的乘.
void print(pnode p)
{
if(p==NULL)
{
cout

ABAC

Select a.sn as 姓名,avg(c.gr) as 平均成绩
From s a,c b,sc c
where a.s#=c.s#
and b.c#=c.c#
and b.cn!='c1'
group by a.sn
having count(*)=2
order by avg(c.gr) desc

请贴出具体的表结构
一般是这样的
select * from tableA order by col1 desc,col2 asc;
先按col1降序,相同则按col2 升序

首先 请将成绩表要排序的数据全选定 然后选择自定义排序（我这是2010版的） 03版的忘了是自定义排序 还是高级排序来着 接下来在主要关键字那里选择总分 然后排序依据是数值 次序是降序 （注意了 排序时切忌不要只选择总分那一列 这样排序之后你的人名分数跟总分就错乱了,记得把所有数据都选上）

请参考：
请参考源码:
#include
#include
#include
using namespace std;
class Node
{
public:
int exp; //指数
int coef; //系数
Node():exp(0),coef(0){}
};
class Polynomial
{
private:
listfirst_poly; //第一个多项式
listsecond_poly; //第二个多项式
listresult_poly; //储存结果
list MpAdd(list& t_first_poly,
list& t_second_poly);
public:
void MultipPoly(); //多项式相乘
void AddPoly(); //多项式相加
void InPut(); //输入多项式
void OutPut(); //输出多项式
};
void Polynomial::InPut()
{
Node temp;
int n;
cout

献上历史上最烂的算法,不知道哪年能算出来!
后面加了一个新算法
class TheBadOne
{
public static void main(String[] args)
{
int counter=0;
for(int i=1;i

堆作为满二叉树,应该是用数组来实现的那么root作为大根堆的最大元素位于data【0】,其他的元素不管此时做堆排序,删除root,保存在tmp变量中调整堆,那么原来的堆的大小减一,数组最后一位空出赋以tmp那么最大元素位于数组尾部以此类推. 查看原帖

order by 升序字段 asc,降序字段 desc

算法 参考出处：http://blog.csdn.net/ctu_85/archive/2008/05/11/2432736.aspx
一、什么是算法
算法是一系列解决问题的清晰指令,也就是说,能够对一定规范的输入,在有限时间内获得所要求的输出.算法常常含有重复的步骤和一些比较或逻辑判断.如果一个算法有缺陷,或不适合于某个问题,执行这个算法将不会解决这个问题.不同的算法可能用不同的时间、空间或效率来完成同样的任务.一个算法的优劣可以用空间复杂度与时间复杂度来衡量.
算法的时间复杂度是指算法需要消耗的时间资源.一般来说,计算机算法是问题规模n 的函数f(n),算法执行的时间的增长率与f(n) 的增长率正相关,称作渐进时间复杂度（Asymptotic Time Complexity）.时间复杂度用“O（数量级）”来表示,称为“阶”.常见的时间复杂度有： O（1）常数阶；O（log2n）对数阶；O（n）线性阶；O（n2）平方阶.
算法的空间复杂度是指算法需要消耗的空间资源.其计算和表示方法与时间复杂度类似,一般都用复杂度的渐近性来表示.同时间复杂度相比,空间复杂度的分析要简单得多.
[font class="Apple-style-span" style="font-weight: bold;" id="bks_etfhxykd"]算法 Algorithm [/font]
算法是在有限步骤内求解某一问题所使用的一组定义明确的规则.通俗点说,就是计算机解题的过程.在这个过程中,无论是形成解题思路还是编写程序,都是在实施某种算法.前者是推理实现的算法,后者是操作实现的算法.
一个算法应该具有以下五个重要的特征：
1、有穷性： 一个算法必须保证执行有限步之后结束；
2、确切性： 算法的每一步骤必须有确切的定义；
3、输入：一个算法有0个或多个输入,以刻画运算对象的初始情况,所谓0个输入是指算法本身定除了初始条件；
4、输出：一个算法有一个或多个输出,以反映对输入数据加工后的结果.没有输出的算法是毫无意义的；
5、可行性： 算法原则上能够精确地运行,而且人们用笔和纸做有限次运算后即可完成.
算法的设计要求
1）正确性（Correctness）
有4个层次：
A．程序不含语法错误；
B．程序对几组输入数据能够得出满足规格要求的结果；
C．程序对精心选择的、典型的、苛刻的、带有刁难性的几组输入数据能够得出满足规格要求的结果；
D．程序对一切合法的输入数据都能产生满足规格要求的结果.
2）可读性（Readability）
算法的第一目的是为了阅读和交流；
可读性有助于对算法的理解；
可读性有助于对算法的调试和修改.
3）高效率与低存储量
处理速度快；存储容量小
时间和空间是矛盾的、实际问题的求解往往是求得时间和空间的统一、折中.
算法的描述 算法的描述方式（常用的）
算法描述 自然语言
流程图 特定的表示算法的图形符号
伪语言 包括程序设计语言的三大基本结构及自然语言的一种语言
类语言 类似高级语言的语言,例如,类PASCAL、类C语言.
算法的评价 算法评价的标准：时间复杂度和空间复杂度.
1）时间复杂度 指在计算机上运行该算法所花费的时间.用“O（数量级）”来表示,称为“阶”.
常见的时间复杂度有： O（1）常数阶；O（logn）对数阶；O（n）线性阶；O（n＾2）平方阶
2）空间复杂度 指算法在计算机上运行所占用的存储空间.度量同时间复杂度.
时间复杂度举例
（a） X：=X+1 ； O（1）
（b） FOR I：=1 TO n DO
X：= X+1； O（n）
（c） FOR I：= 1 TO n DO
FOR J：= 1 TO n DO
X：= X+1； O（n＾2）
“算法”一词最早来自公元 9世纪 波斯数学家比阿勒·霍瓦里松的一本影响深远的著作《代数对话录》.20世纪的 英国 数学家 图灵 提出了著名的图灵论点,并抽象出了一台机器,这台机器被我们称之为 图灵机 .图灵的思想对算法的发展起到了重要的作用.
算法是 计算机 处理信息的本质,因为 计算机程序 本质上是一个算法,告诉计算机确切的步骤来执行一个指定的任务,如计算职工的薪水或打印学生的成绩单. 一般地,当算法在处理信息时,数据会从输入设备读取,写入输出设备,可能保存起来以供以后使用.
这是算法的一个简单的例子.
我们有一串随机数列.我们的目的是找到这个数列中最大的数.如果将数列中的每一个数字看成是一颗豆子的大小 可以将下面的算法形象地称为“捡豆子”：
首先将第一颗豆子（数列中的第一个数字）放入口袋中.
从第二颗豆子开始检查,直到最后一颗豆子.如果正在检查的豆子比口袋中的还大,则将它捡起放入口袋中,同时丢掉原先的豆子. 最后口袋中的豆子就是所有的豆子中最大的一颗.
下面是一个形式算法,用近似于 编程语言 的 伪代码 表示
给定：一个数列“list",以及数列的长度"length(list)" largest = list[1] for counter = 2 to length(list): if list[counter] > largest: largest = list[counter] print largest
符号说明:
= 用于表示赋值.即：右边的值被赋予给左边的变量.
List[counter] 用于表示数列中的第 counter 项.例如：如果 counter 的值是5,那么 List[counter] 表示数列中的第5项.
1时）.
写成递归函数有：
int fib(int n)
{ if (n==0) return 0;
if (n==1) return 1;
if (n>1) return fib(n-1)+fib(n-2);
}
递归算法的执行过程分递推和回归两个阶段.在递推阶段,把较复杂的问题（规模为n）的求解推到比原问题简单一些的问题（规模小于n）的求解.例如上例中,求解fib(n),把它推到求解fib(n-1)和fib(n-2).也就是说,为计算fib(n),必须先计算fib(n-1)和fib(n-2),而计算fib(n-1)和fib(n-2),又必须先计算fib(n-3)和fib(n-4).依次类推,直至计算fib(1)和fib(0),分别能立即得到结果1和0.在递推阶段,必须要有终止递归的情况.例如在函数fib中,当n为1和0的情况.
在回归阶段,当获得最简单情况的解后,逐级返回,依次得到稍复杂问题的解,例如得到fib(1)和fib(0)后,返回得到fib(2)的结果,……,在得到了fib(n-1)和fib(n-2)的结果后,返回得到fib(n)的结果.
在编写递归函数时要注意,函数中的局部变量和参数知识局限于当前调用层,当递推进入“简单问题”层时,原来层次上的参数和局部变量便被隐蔽起来.在一系列“简单问题”层,它们各有自己的参数和局部变量.
由于递归引起一系列的函数调用,并且可能会有一系列的重复计算,递归算法的执行效率相对较低.当某个递归算法能较方便地转换成递推算法时,通常按递推算法编写程序.例如上例计算斐波那契数列的第n项的函数fib(n)应采用递推算法,即从斐波那契数列的前两项出发,逐次由前两项计算出下一项,直至计算出要求的第n项.
【问题】 组合问题
问题描述：找出从自然数1、2、……、n中任取r个数的所有组合.例如n=5,r=3的所有组合为： （1）5、4、3 （2）5、4、2 （3）5、4、1
（4）5、3、2 （5）5、3、1 （6）5、2、1
（7）4、3、2 （8）4、3、1 （9）4、2、1
（10）3、2、1
分析所列的10个组合,可以采用这样的递归思想来考虑求组合函数的算法.设函数为void comb(int m,int k)为找出从自然数1、2、……、m中任取k个数的所有组合.当组合的第一个数字选定时,其后的数字是从余下的m-1个数中取k-1数的组合.这就将求m个数中取k个数的组合问题转化成求m-1个数中取k-1个数的组合问题.设函数引入工作数组a[ ]存放求出的组合的数字,约定函数将确定的k个数字组合的第一个数字放在a[k]中,当一个组合求出后,才将a[ ]中的一个组合输出.第一个数可以是m、m-1、……、k,函数将确定组合的第一个数字放入数组后,有两种可能的选择,因还未去顶组合的其余元素,继续递归去确定；或因已确定了组合的全部元素,输出这个组合.细节见以下程序中的函数comb.
【程序】
# include
# define MAXN 100
int a[MAXN];
void comb(int m,int k)
{ int i,j;
for (i=m;i>=k;i--)
{ a[k]=i;
if (k>1)
comb(i-1,k-1);
else
{ for (j=a[0];j>0;j--)
printf(“%4d”,a[j]);
printf(“n”);
}
}
}
void main()
{ a[0]=3;
comb(5,3);
}
3.回溯法
回溯法也称为试探法,该方法首先暂时放弃关于问题规模大小的限制,并将问题的候选解按某种顺序逐一枚举和检验.当发现当前候选解不可能是解时,就选择下一个候选解；倘若当前候选解除了还不满足问题规模要求外,满足所有其他要求时,继续扩大当前候选解的规模,并继续试探.如果当前候选解满足包括问题规模在内的所有要求时,该候选解就是问题的一个解.在回溯法中,放弃当前候选解,寻找下一个候选解的过程称为回溯.扩大当前候选解的规模,以继续试探的过程称为向前试探.
【问题】 组合问题
问题描述：找出从自然数1,2,…,n中任取r个数的所有组合.
采用回溯法找问题的解,将找到的组合以从小到大顺序存于a[0],a[1],…,a[r-1]中,组合的元素满足以下性质：
（1） a[i+1]>a,后一个数字比前一个大；
（2） a-i

降序选择排序,是在一组排序中选择最大值,这里对字符串进行排序,首先是第一个字母进行排序,如有相同字母进行第二字母排序,以此进行比较.
选择排序法 是对 定位比较交换法（也就是冒泡排序法） 的一种改进.
第一次排序比较your最大,us与your交换；交换后顺序为：your,our,my,us,his
第二次排序比较us最大,our与us交换,交换结果为：your,us,my,our,his
依次类推.

其实就是大于、小于、小于等于、大于等于的意思
用例子来说的话,设数列{an}
若符合a(n+1)>an,则数列的递增的,也是升序的
若符合a(n+1)

比如你有一组数字 1 2 3 4 5
降序排列就是从大到小排序,结果为：5 4 3 2 1

这个.怎么能叫选择排序,分明是归并排序的一个过程==
int a[a_size], b[b_size]；/* a, b are ordered list */
int c[c_size];
int pa=0, pb=0, pc=0;
while(pa

题目应该是这4个数的和是最后一位的3倍吧?
假设分别是x,x+1,x+2,x+3(最后一位）
他们的和,x+x+1+x+2+x+3=3(x+3)
4x+6=3x+9
x=3
所以这4位数为3456
所以是88293456

暂时只能想到这样的,结果是排序后的键列表.
d = {'a':3,'c':4,'b':3,'d':2,'f':4,'e':2}
result = []
keys = sorted(d,key=lambda k:d[k])
for k in keys:
if not result:
result.append(k)
elif d[k] == d[result[-1]] and k < result[-1]:
result.insert(len(result) - 1,k)
else:
result.append(k)
print result

说得不太清楚啊.
如果只是排序的话,你按这一列降序排序就行了,跟Rank公式有什么关系呢?
如果你想写这一列的名次,Rank倒是可用,但跟排序又有什么关系呢?
补充：
你的意思是,你已经算出了增长率?现在想以增长率为依据进行排名,同时算出系数?
得把增长率先排序,然后按正负增长分别设置公式：
假设你的增长率在C列,现在D列输入公式（正增长）：
=if((rank(C2,C$2:C$200)-1)*0.05+1>=0.5,((rank(C2,C$2:C$200)-1)*0.05+1,0.5)
负增长：
=-(rank(C2,C$201:C$400)-1)*0.1
这还真是个麻烦,如果用VBA的话,倒也简单,也无须排序.
现在我只有一个办法了：
先找一空列,按原始顺序拖出一个顺序号来,以备将来还原；
然后按增长率排序,照我刚才所说的算出结果,选定这一列,复制,在原列上“选择性粘贴”——只有值；
最后再按原始顺序号排序,恢复原状.

/D表示降序
/A表示升序(不写/A也表示升序）