sql="select id,ClassId,TopID,VoteNum,VoteName,hits,addtime from zhi_rui_v_po where ViewFlag=1 order by VoteNum desc,hits desc"
改成
sql="select id,ClassId,TopID,VoteNum,VoteName,hits,addtime from zhi_rui_v_po where ViewFlag=1 order by ClassId desc,hits desc"
如果升序，就把desc去掉
/
前3名的票数:
候选人 1: 14票。
候选人 2: 10票。
候选人 8: 8票。
Press any key to continue
/
#include <stdioh>#define N 21 // 选举人数
int isLegal(int a[3]) { // 选票合法性检查
int i;
for(i = 0; i < 3; ++i) {
if(a[i] < 0 || a[0] > 9) // 未投选举人，作废
return 0;
if(a[i] && a[i] == a[(i + 1)%3]) // 有重复票，作废
return 0;
}
return 1; // 其余的都是有效票
}
void sort(int a[],int b[],int n) {
int i,j,k,t;
for(i = 0; i < n - 1; ++i) {
k = i;
for(j = i + 1; j < n; ++j)
if(a[k] < a[j]) k = j;
if(k != i) {
t = a[k];
a[k] = a[i];
a[i] = t;
t = b[k];
b[k] = b[i];
b[i] = t;
}
}
}
int main() {
int candidates[11]; // 10名候选人
int electors[N][3] = { // 选举人及投票情况，0表示不投任何人的票
{3,2,1},{1,2,8},{3,2,5},{2,1,8},{3,1,6},{5,3,1},{8,6,9},
{6,8,9},{3,8,9},{5,1,4},{0,1,2},{1,1,2},{3,2,5},{2,2,8},
{5,2,1},{0,0,1},{1,0,2},{8,1,2},{2,1,8},{3,1,4},{8,1,7},
};
int i,j,poll[11] = {0};
for(i = 1; i < 11; ++i) candidates[i] = i;
for(i = 0; i < N; ++i) {
if(isLegal(electors[i])) {
for(j = 0; j < 3; ++j) {
if(electors[i][j]) // 0表示不投任何人的票
++poll[electors[i][j]];
}
}
}
sort(poll + 1,candidates + 1,10);
printf("前3名的票数:\n");
for(i = 1; i < 4; ++i)
printf("候选人%3d: %d票。\n",candidates[i],poll[i]);
return 0;
}
#include "stdioh"
#include "stringh"
#include "stdlibh"
#define N 50
#define M 500
struct sporter
{
int num;
char name[20];
int vote_num;
}spt[N]; / spt[N]中每个数组元素对应一个运动员信息,vote_num记录得票数目/
struct vote
{
char id[10];
char name[20];
char address[20];
int a[10];
int score_order;/次序分 /
int score_hit;/命中分/
int score_sum;
}vot[M]; / vot[M]中每个数组元素对应一张选票信息,score_sum记录该票命中率/
void printf_back();
void menu();
void menu_vote();
int save_spt();
void printf_onevote(int j);
int load_vote();
void search_vote();
void search_vote()
{
int m,i,flag=0;
char vs[20];
printf("Please input vote_id:\n");
scanf("%s",&vs);
m=load_vote();
for(i=0;i<m;i++)
{
if(strcmp(vs,vot[i]id)==0)
{
flag=1;
printf_onevote(i);
}
}
if(flag==1)
printf("Found!");
else
printf("Not found!");
printf_back();
}
/1_1 加载候选运动员记录并可以计算记录个数的函数/
int load_sporter() /加载记录并可以计算记录个数的函数/
{FILE fp;
int i;
if((fp=fopen("sportertxt","r"))==NULL) /以输出打开方式,在此前的记录被覆盖/
{printf("\nCannot open file\n");
return 0;
}
for(i=0;!feof(fp);i++)
fscanf(fp,"%d%s",&spt[i]num,&spt[i]name);
fclose(fp);
return(i); /返回记录个数/
}
/1_2 显示一个运动员记录的函数/
void printf_one(int i)
{
printf("%2d %-17s %d \n",spt[i]num,spt[i]name,spt[i]vote_num);
}
/1_3 显示n个运动员记录的函数/
void printf_n(int n)
{int j;
for(j=0;j<n;j++)
{
if(j%10==0)
{ printf("\n\nPass any key to contiune ");
getchar();
puts("\n\n");
}
printf_one(j);
}
getchar();
}
/1_4 加载候选选票记录并可以计算记录个数的函数/
int load_vote()
{FILE fp;
int i,j;
if((fp=fopen("votetxt","r"))==NULL)
{printf("\nCannot open file\n");
return 0;
}
for(i=0;!feof(fp);i++)
{ fscanf(fp,"%s%s%s%",&vot[i]id,&vot[i]name,&vot[i]address);
for(j=0;j<10;j++)
fscanf(fp,"%d",&vot[i]a[j]);
}
fclose(fp);
return(i); /返回记录个数/
}
/1_5 显示一张**记录的函数/
void printf_onevote(int j)
{
int i;
printf("vote_id:%s\n",vot[j]id);
printf("vote_name:%s vote_address:%s\n",vot[j]name,vot[j]address);
printf("vote_sporter:");
for(i=0;i<10;i++)
printf("%d, ",vot[j]a[i]);
printf("\n\n");
}
/1_6 显示n张**记录的函数/
void printf_n_vote(int m)
{int j;
for(j=0;j<m;j++)
{
if(j%10==0)
{ printf("\nPass any key to contiune ");
getchar();
puts("\n\n");
}
printf_onevote(j);
}
getchar();
}
/1_7 唱票函数/
void stat_vote(int m)
{
int i,j,k;
for(i=0;i<=m;i++)
{
for(j=0;j<10;j++)
for(k=0;k<20;k++)
if(vot[i]a[j]==spt[k]num)spt[k]vote_num++;
}
}
/1_8 依据得票数排序函数,使用选择排序法/
void order_by_vote(int m)
{
int i,j,k;
struct sporter s;
for(i=0;i<m-1;i++)
{ k=i;
for(j=i+1;j<m;j++) if(spt[j]vote_num>spt[k]vote_num)k=j;
s=spt[i]; spt[i]=spt[k]; spt[k]=s;
}
}
/1_9 显示10佳信息及输出到文件函数/
void print_spt10()
{
int i;
printf("\n\nThe 10 best sporter is:\n");
printf("order, num, name, vote_num\n");
for(i=0;i<10;i++)
{
printf("%5d: %3d, %10s, %d \n",i+1,spt[i]num,spt[i]name,spt[i]vote_num);
}
getchar();
save_spt();
}
/1_10 保存函数/
int save_spt() /保存函数,保存10佳运动员记录/
{FILE fp1;
int i;
if((fp1=fopen("spt10txt","w"))==NULL) /以输出打开方式,在此前的记录被覆盖/
{printf("\nCannot open file\n");
return 0;
}
for(i=0;i<10;i++)
fprintf(fp1,"%d %s %d\n",spt[i]num,spt[i]name,spt[i]vote_num);
fclose(fp1);
return 1;
}
/1_11 计算命中率函数/
int calc_hit(int m)
{FILE fp;
int i,j,k;
struct sporter s[10];
for(i=0;i<10;i++)
{
s[i]=spt[i];
}
for(i=0;i<m;i++)
for(j=0;j<10;j++)
for(k=0;k<10;k++)
{
if(vot[i]a[j]==s[j]num) vot[i]score_order+=9-j; /次序分/
if(vot[i]a[j]==s[k]num) vot[i]score_hit+=10; /命中分/
vot[i]score_sum=vot[i]score_hit+vot[i]score_order;
}
if((fp=fopen("hittxt","w"))==NULL)
{printf("\nCannot open file\n");
return 0;
}
for(i=0;i<m;i++)
fprintf(fp,"%s %d %d %d\n",vot[i]id,vot[i]score_order,vot[i]score_hit,vot[i]score_sum);
fclose(fp);
return 1;
}
/1_12 依据命中率对选票排序函数,使用选择排序法/
void sort_vote(int m)
{
int i,j,k;
struct vote v;
for(i=0;i<m-1;i++)
{ k=i;
for(j=i+1;j<m;j++) if(vot[j]score_sum>vot[k]score_sum)k=j;
v=vot[i]; vot[i]=vot[k]; vot[k]=v;
}
}
/1_13 显示前10名获奖参选者信息函数/
void print_vot10()
{
int i;
printf("\n\nThe 10 best voter is:\n");
printf("order, id, name, vote_sum\n");/名次 选票号 姓名 命中率/
for(i=0;i<10;i++)
{
printf("%5d: %s, %10s, %d \n",i+1,vot[i]id,vot[i]name,vot[i]score_sum);
}
getchar();
}
/1_14 保存前10名获奖参选者信息到文件的函数/
int save_vot10()
{FILE fp1;
int i;
if((fp1=fopen("vot10txt","w"))==NULL) /以输出打开方式,在此前的记录被覆盖/
{printf("\nCannot open file\n");
return 0;
}
for(i=0;i<10;i++)
fprintf(fp1,"%5d: %s, %10s, %d \n",i+1,vot[i]id,vot[i]name,vot[i]score_sum);
fclose(fp1);
return 1;
}
int n,m;
/1_15 从文件读入运动员及选票记录/
void readfiles()
{
n=load_sporter();/从文件读入候选运动员记录/
printf_n(n);/ 显示候选运动员记录/
m=load_vote();/从文件读入选票记录/
}
/1_16 计算10佳运动员/
void calctensp()
{
stat_vote(m); /唱票/
order_by_vote(n); /依据得票数对运动员记录排序/
print_spt10();/输出10佳运动员信息/
}
/1_17 计算10个获奖参选者/
void stattenvoter()
{
calc_hit(m); /计算选票的命中率/
sort_vote(m); /依据命中率对选票记录排序/
print_vot10();/显示10个获奖参选者信息/
save_vot10();/输出10个获奖参选者信息到文件/
}
/1_18 统计函数/
void stat()
{
readfiles();
calctensp();
stattenvoter();
}
/2_1 浏览选票函数/
void browse_vote()
{
int k;
k=load_vote();
printf_n_vote(k);
printf_back();
}
/2_2 /查找选票函数/
////////////////////////////////////
/////////////////////////////////
/2_3 核对选票函数/
void check()
{
int n,w;
/变量n保存选择菜单数字，w判断输入的数字是否在功能菜单对应数字范围内/
do
{
puts("\t\tMENU\n\n");
puts("\t\t\t\t 1browse_vote"); /浏览所有**/
puts("\t\t\t\t 2search_vote");/输入**号码查找该**信息/
puts("\t\t\t\t 3back");/返回/
puts("\n\n\t\t \n");
printf("Choice your number(1-3): [ ]\b\b");
scanf("%d",&n);
if(n<1||n>3) /对选择的数字作判断/
{
w=1;
getchar();
}
else {w=0;}
}while(w==1);
/选择功能/
switch(n)
{case 1:browse_vote();break; /统计模块/
case 2:search_vote();break; /查找选票模块/
case 3:menu(); /退出/
}
}
/公共函数/
/（1）任务结束时的选择退出还是返回/
void printf_back()
{int w;
printf("\n\n\tSuccessful ^_^\n\n");
printf("What do you want to do \n\n\t1)Exit\t2)Back: [ ]\b\b");
scanf("%d",&w);
if(w==1) exit(0);
else menu_vote();
}
/（2）任务结束时的选择退出还是返回主菜单/
void menu()
{
int n,w;
/变量n保存选择菜单数字，w判断输入的数字是否在功能菜单对应数字范围内/
do
{
puts("\t\tMENU\n\n");
puts("\t\t\t\t 1statistic"); /统计/
puts("\t\t\t\t 2check_vote");/核对选票/
puts("\t\t\t\t 3exit");/退出/
puts("\n\n\t\t \n");
printf("Choice your number(1-3): [ ]\b\b");
scanf("%d",&n);
if(n<1||n>3) /对选择的数字作判断/
{
w=1;
getchar();
}
else w=0;
}
while(w==1);
/选择功能/
switch(n)
{case 1:stat();break; /统计模块/
case 2:check();break; /核对选票模块/
case 3:exit(0); /退出/
}
}
/（3）任务结束时的选择退出还是返回核对**菜单/
void menu_vote()
{
int n,w;
/变量n保存选择菜单数字，w判断输入的数字是否在功能菜单对应数字范围内/
do
{
puts("\t\tMENU\n\n");
puts("\t\t\t\t 1browse_vote"); /浏览所有**/
puts("\t\t\t\t 2search_vote");/输入**号码查找该**信息/
puts("\t\t\t\t 3esc");/返回/
puts("\n\n\t\t \n");
printf("Choice your number(1-3): [ ]\b\b");
scanf("%d",&n);
if(n<1||n>3) /对选择的数字作判断/
{
w=1;
getchar();
}
else {w=0;}
}while(w==1);
/选择功能/
switch(n)
{case 1:browse_vote();break; /统计模块/
case 2:search_vote();break; /查找选票模块/
case 3:exit(0); /退出/
}
}
main() /主函数/
{
menu();
}
猎云网北京6月4日报道（文/田甜）
根据规划，8月份，灵动 科技 自主研发的OVIS智能侧面跟随行李箱就要量产，并在国内首发。此前，OVIS在美国市场仅两月预售的销售额就达千万元人民币，这一数据也进入了2018年中国硬件类产品海外众筹TOP10。
2019年4月，在被誉为“美国 科技 界的奥斯卡奖”的爱迪生奖评选中，在竞争最激烈的“消费电子”类别，OVIS捧得银奖，灵动 科技 也因此成为第一家获此殊荣的人工智能公司。
颁奖现场，机器学习之父、“图灵奖”获得者Yann Lecun在使用过OVIS行李箱后，高度赞扬道：“目前在美国，神经网络还主要应用在互联网领域。但你们却已经将神经网络应用在硬件产品上。”
除了爱迪生奖，OVIS还于2018荣获上格奖全球 时尚 创科大赛最高奖项-上格之星奖。在2019年的CES展上斩获16项大奖。
光环加身的OVIS虽然表面看起来是一款行李箱，背后却应用了灵动 科技 自2016年创立以来自主研发的大量硬核技术，包括摄像头实时高通量信息处理、多神经网络并行的计算机视觉能力、基于VSLAM视觉感知的速度闭环、侧面跟随的算法等核心技术。更确切地说，它是一个行李箱形态的视觉自主机器人。
通过研发OVIS，灵动 科技 还打通了软件开发、硬件设计和供应链落地的整个链条，形成了一个视觉自主机器人的PAAS开发平台。在这个平台基础上，灵动 科技 推出了2B的仓储协作机器人——视觉导航AMR（电商小件3C仓BX100、电商中大件仓BX350、叉车等）。目前，这些视觉导航机器人已经在德国3PL客户和日本客户的核心仓库上线运行，并逐步在海外和国内推广，实现了单件拣货成本下降30%以上的运行效果。灵动 科技 规划，今年视觉导航AMR部署量将超过1000台。
齐欧表示，OVIS研发用了三年时间，而视觉导航AMR首款机器人研发只用了一年零六个月，其他产品研发时间还在缩短。这充分证明灵动 科技 自主机器人技术平台具有足够的通用性。
从2C到2B，灵动 科技 实现了从智能硬件到PAAS平台，再到赋能行业的延展和提升。在灵动 科技 的布局中，如果OVIS能成功走向市场，无疑将是灵动 科技 的现金牛，有助于灵动 科技 实现从融资输血到自身造血的根本性提升。
根据齐欧观察到的数据，全球范围内，行李箱的市场规模为300亿美元，国内市场也有300亿元的规模。在早期规划的时候，齐欧就设想能够实现一年量产，两年国际化商业回报的场景。他表示，我们对自己有很清醒的认知，希望从一个端到端可控的环境下把产品做出来。
量产的关键要看供应链的控制能力。实际上，硬件创业中，供应链可以说是最大的一个坑。这是一个庞大的体系和生态，涉及到结构是否可靠，供应商选择是否正确，量产是否能按时推进，硬件能否快速迭代等一系列问题。
同样，对灵动 科技 而言，三年来，除了技术研发，最大的一个课题就是构建供应链。齐欧坦言，做出一个产品比想象得难。但幸运的是，中国有深圳、东莞这样的硬件硅谷。
在供应链的构建上，灵动 科技 一方面引入专业的硬件设计及量产人才，在产品定义阶段，就考虑到工程的合理性。同时，邀请传感器等关键零部件厂商一起参与设计产品原型。量产阶段工程师团队由一位具有21年行业经验的老兵带队。
据齐欧介绍，OVIS行李箱箱体的供应商是全球某顶级箱包品牌的中国核心代工厂。在相互尊重的情况下，该工厂接受了灵动 科技 更高的质量要求，比如毫米级的装配精度，对此，双方共同规划了生产线的SOP（标准 *** 作程序）。
通过与工厂沟通，齐欧也发现，中国制造业从业者非常有理想。箱体生产工厂负责人虽然已经50多岁了，但是自创业以来的十多年里，一直在向价值微笑曲线的两端——技术和品牌努力。为了做好产品，对方也招聘多位技术总监来负责生产线的改造。齐欧透露，目前，产线规划的OVIS产能是1万台/月。
“跑通供应链，首先保证了产品的可靠性，其次，也有助于我们打造有竞争力的价格。”以传感器为例，三年时间，灵动 科技 对市场上的传感器进行了摸底式的调查。齐欧表示，我们希望每出一款产品的时候，都能够根据市场要求去灵活组合这些传感器，实现成本最低，性能最好。这就好比一个工具箱，工具可以自由组合。
OVIS量产之后，用户买不买帐，使用体验如何，都将是灵动科要面对的最直接的考验。
齐欧表示，对OVIS的市场表现充满信心。在使用上，OVIS的成功率大概在98%以上，这是经过一定规模的测试得出的概率。还有非常重要的一点，OVIS属于自带流量的硬件。只要被使用，就是在传播。
根据前期预售用户画像统计，购买OVIS的用户，基本上每个季度都要出差1-2次以上。他们本身对 科技 就比较敏感，有一半数量的用户购买过无人机，有接近一半的用户买过扫地机。“产品就像小孩子一样不断去成长。”齐欧表示，他们将尽量倾听消费者的声音，做到产品的快速迭代。
在销售上，OVIS划分海外和国内两个市场。灵动 科技 成立当年，也在美国注册了分公司，承担研发部分研发工作。齐欧透露，灵动 科技 已经获得OVIS这个商标在美国的授权，接下来要在北美做自己的渠道和市场。
他也透露，预售阶段，海外订单占到98%以上。但量产后，应该是国内外市场平均分配。海外市场，尤其是北美和欧洲等地，主要通过和渠道商合作实现销售，而在国内，主要是自己构建渠道，最先在线上渠道铺货。在软硬件的升级、故障诊断和维修上，灵动 科技 计划和维修点开展合作。
齐欧还透露，他们也对国内市场其他品牌的智能行李箱做了调查，OVIS产品价格相对合理。“我们尽量做好一款可靠，价格合理，大家喜闻乐见的产品，渗透率没有想太多。”
考虑创业时，齐欧之所以选择从OIVS入手，其中一个重要原因是，他曾经在微软亚研院供职1年，SAP产品开发5年，又在甲骨文负责产品和销售7年，是个不折不扣的空中飞人。行李箱是其最常用的工具之一。
此外，他身上还带有一些极客色彩。2003年，他曾获得获得全国机器人大赛（Robocon）中国区冠军。大疆创始人汪滔拿下2005年大赛Robocon机器人大赛的香港赛区冠军，而2007年第六届Robocon中国区冠军周伟，则从平衡车起步创立了乐行 科技 。
在齐欧心里，一直埋藏着机器人的种子，“希望我们每个人都有像**《星球大战》一样的贴身机器人，OVIS就是在这样的初衷下诞生的。”
“听到工程师敲击键盘的声音，我心里就非常踏实。”
齐欧心里清楚，灵动 科技 强大的产品研发和迭代能力，源于公司的工程师队伍。目前，公司研发人员近110人，占到公司总人数的70%以上，博士及博士后7人，占到公司人数的5%，硕士学历工程师占总人数的29%。其中，团队成员主要来自于清华、中科院、微软研究院、贝尔实验室等知名学校及研究机构，还有VOT-RT2018、ImageNet 2017、ACM等多项比赛的全球冠亚军。
据了解，公司研发人员已在行人检测、多物体追踪、行人再识别、物体检测、计算机算法、超级计算机等多个领域斩获了20多项全球NO1；在全球三大计算机视觉顶级期刊（ECCV/ICCV/EVPR）上，陆续发表了10多篇论文；公司在创立3年内共申请专利97项，包括43项国际发明专利申请，以及2项美国发明专利授权。
齐欧表示，在专利部署上，真正和灵动 科技 在专利上可能产生冲突的是谷歌、本田，所以。“我们不得不面对一个全球的专业化的竞争，并且在全球的技术专家和商业闭环上，也要跟全球企业做到同样的量级。”而每当设想企业未来的模样时，他都忍不住想到特斯拉。
智能硬件是一个集合了软件功能、硬件技术、云服务等的复杂体系。这就注定，硬件创业的艰难程度和可能踩到的“雷”远非互联网创业可以比拟。创业成本高、时间长、盈利性难以预估是硬件创业铁打的三个标签。
即便如此，齐欧还是带领团队跳进了这个“火坑”，淬炼难熬，但一旦扛住了，灵动 科技 就有可能成长为一家伟大的公司。苹果手机、大疆无人机还有特斯拉，哪一家不是这样走过来的呢？
// 排序
public class Array
{
public static int[] random(int n) //产生n个随机数，返回整型数组
{
if (n>0)
{
int table[] = new int[n];
for (int i=0; i<tablelength; i++)
table[i] = (int)(Mathrandom()100); //产生一个0～100之间的随机数
return table; //返回一个数组
}
return null;
}
public static void print(int[] table) //输出数组元素
{
if (table!=null)
for (int i=0; i<tablelength; i++)
Systemoutprint(" "+table[i]);
Systemoutprintln();
}
public static void insertSort(int[] table) //直接插入排序
{ //数组是引用类型，元素值将被改变
Systemoutprintln("直接插入排序");
for (int i=1; i<tablelength; i++) //n-1趟扫描
{
int temp=table[i], j; //每趟将table[i]插入到前面已排序的序列中
// Systemoutprint("移动");
for (j=i-1; j>-1 && temp<table[j]; j--) //将前面较大元素向后移动
{
// Systemoutprint(table[j]+", ");
table[j+1] = table[j];
}
table[j+1] = temp; //temp值到达插入位置
Systemoutprint("第"+i+"趟: ");
print(table);
}
}
public static void shellSort(int[] table) //希尔排序
{
Systemoutprintln("希尔排序");
for (int delta=tablelength/2; delta>0; delta/=2) //控制增量，增量减半，若干趟扫描
{
for (int i=delta; i<tablelength; i++) //一趟中若干组，每个元素在自己所属组内进行直接插入排序
{
int temp = table[i]; //当前待插入元素
int j=i-delta; //相距delta远
while (j>=0 && temp<table[j]) //一组中前面较大的元素向后移动
{
table[j+delta] = table[j];
j-=delta; //继续与前面的元素比较
}
table[j+delta] = temp; //插入元素位置
}
Systemoutprint("delta="+delta+" ");
print(table);
}
}
private static void swap(int[] table, int i, int j) //交换数组中下标为i、j的元素
{
if (i>=0 && i<tablelength && j>=0 && j<tablelength && i!=j) //判断i、j是否越界
{
int temp = table[j];
table[j] = table[i];
table[i] = temp;
}
}
public static void bubbleSort(int[] table) //冒泡排序
{
Systemoutprintln("冒泡排序");
boolean exchange=true; //是否交换的标记
for (int i=1; i<tablelength && exchange; i++) //有交换时再进行下一趟，最多n-1趟
{
exchange=false; //假定元素未交换
for (int j=0; j<tablelength-i; j++) //一次比较、交换
if (table[j]>table[j+1]) //反序时，交换
{
int temp = table[j];
table[j] = table[j+1];
table[j+1] = temp;
exchange=true; //有交换
}
Systemoutprint("第"+i+"趟: ");
print(table);
}
}
public static void quickSort(int[] table) //快速排序
{
quickSort(table, 0, tablelength-1);
}
private static void quickSort(int[] table, int low, int high) //一趟快速排序，递归算法
{ //low、high指定序列的下界和上界
if (low<high) //序列有效
{
int i=low, j=high;
int vot=table[i]; //第一个值作为基准值
while (i!=j) //一趟排序
{
while (i<j && vot<=table[j]) //从后向前寻找较小值
j--;
if (i<j)
{
table[i]=table[j]; //较小元素向前移动
i++;
}
while (i<j && table[i]<vot) //从前向后寻找较大值
i++;
if (i<j)
{
table[j]=table[i]; //较大元素向后移动
j--;
}
}
table[i]=vot; //基准值的最终位置
Systemoutprint(low+""+high+", vot="+vot+" ");
print(table);
quickSort(table, low, j-1); //前端子序列再排序
quickSort(table, i+1, high); //后端子序列再排序
}
}
public static void selectSort(int[] table) //直接选择排序
{
Systemoutprintln("直接选择排序");
for (int i=0; i<tablelength-1; i++) //n-1趟排序
{ //每趟在从table[i]开始的子序列中寻找最小元素
int min=i; //设第i个数据元素最小
for (int j=i+1; j<tablelength; j++) //在子序列中查找最小值
if (table[j]<table[min])
min = j; //记住最小元素下标
if (min!=i) //将本趟最小元素交换到前边
{
int temp = table[i];
table[i] = table[min];
table[min] = temp;
}
Systemoutprint("第"+i+"趟: ");
print(table);
}
}
private static void sift(int[] table, int low, int high) //将以low为根的子树调整成最小堆
{ //low、high是序列下界和上界
int i=low; //子树的根
int j=2i+1; //j为i结点的左孩子
int temp=table[i]; //获得第i个元素的值
while (j<=high) //沿较小值孩子结点向下筛选
{
if (j<high && table[j]>table[j+1]) //数组元素比较（改成<为最大堆）
j++; //j为左右孩子的较小者
if (temp>table[j]) //若父母结点值较大（改成<为最大堆）
{
table[i]=table[j]; //孩子结点中的较小值上移
i=j; //i、j向下一层
j=2i+1;
}
else
j=high+1; //退出循环
}
table[i]=temp; //当前子树的原根值调整后的位置
Systemoutprint("sift "+low+""+high+" ");
print(table);
}
public static void heapSort(int[] table)
{
Systemoutprintln("堆排序");
int n=tablelength;
for (int j=n/2-1; j>=0; j--) //创建最小堆
sift(table, j, n-1);
// Systemoutprintln("最小堆？ "+isMinHeap(table));
for (int j=n-1; j>0; j--) //每趟将最小值交换到后面，再调整成堆
{
int temp = table[0];
table[0] = table[j];
table[j] = temp;
sift(table, 0, j-1);
}
}
public static void mergeSort(int[] X) //归并排序
{
Systemoutprintln("归并排序");
int n=1; //已排序的子序列长度，初值为1
int[] Y = new int[Xlength]; //Y数组长度同X数组
do
{
mergepass(X, Y, n); //一趟归并，将X数组中各子序列归并到Y中
print(Y);
n=2; //子序列长度加倍
if (n<Xlength)
{
mergepass(Y, X, n); //将Y数组中各子序列再归并到X中
print(X);
n=2;
}
} while (n<Xlength);
}
private static void mergepass(int[] X, int[] Y, int n) //一趟归并
{
Systemoutprint("子序列长度n="+n+" ");
int i=0;
while (i<Xlength-2n+1)
{
merge(X,Y,i,i+n,n);
i += 2n;
}
if (i+n<Xlength)
merge(X,Y,i,i+n,n); //再一次归并
else
for (int j=i; j<Xlength; j++) //将X剩余元素复制到Y中
Y[j]=X[j];
}
private static void merge(int[] X, int[] Y, int m, int r, int n) //一次归并
{
int i=m, j=r, k=m;
while (i<r && j<r+n && j<Xlength) //将X中两个相邻子序列归并到Y中
if (X[i]<X[j]) //较小值复制到Y中
Y[k++]=X[i++];
else
Y[k++]=X[j++];
while (i<r) //将前一个子序列剩余元素复制到Y中
Y[k++]=X[i++];
while (j<r+n && j<Xlength) //将后一个子序列剩余元素复制到Y中
Y[k++]=X[j++];
}
public static void main(String[] args)
{
// int[] table = {52,26,97,19,66,8,49};//Arrayrandom(9);{49,65,13,81,76,97,38,49};////{85,12,36,24,47,30,53,91,76};//;//{4,5,8,1,2,7,3,6};// {32,26,87,72,26,17};//
int[] table = {13,27,38,49,97,76,49,81}; //最小堆
Systemoutprint("关键字序列: ");
Arrayprint(table);
// ArrayinsertSort(table);
// ArrayshellSort(table);
// ArraybubbleSort(table);
// ArrayquickSort(table);
// ArrayselectSort(table);
// ArrayheapSort(table);
// ArraymergeSort(table);
Systemoutprintln("最小堆序列 "+ArrayisMinHeap(table));
}
//第9章习题
public static boolean isMinHeap(int[] table) //判断一个数据序列是否为最小堆
{
if (table==null)
return false;
int i = tablelength/2 -1; //最深一棵子树的根结点
while (i>=0)
{
int j=2i+1; //左孩子
if (j<tablelength)
if (table[i]>table[j])
return false;
else
if (j+1<tablelength && table[i]>table[j+1]) //右孩子
return false;
i--;
}
return true;
}
}
/
程序运行结果如下：
关键字序列: 32 26 87 72 26 17 8 40
直接插入排序
第1趟排序: 26 32 87 72 26 17 8 40
第2趟排序: 26 32 87 72 26 17 8 40
第3趟排序: 26 32 72 87 26 17 8 40
第4趟排序: 26 26 32 72 87 17 8 40 //排序算法稳定
第5趟排序: 17 26 26 32 72 87 8 40
第6趟排序: 8 17 26 26 32 72 87 40
第7趟排序: 8 17 26 26 32 40 72 87
关键字序列: 42 1 74 25 45 29 87 53
直接插入排序
第1趟排序: 1 42 74 25 45 29 87 53
第2趟排序: 1 42 74 25 45 29 87 53
第3趟排序: 1 25 42 74 45 29 87 53
第4趟排序: 1 25 42 45 74 29 87 53
第5趟排序: 1 25 29 42 45 74 87 53
第6趟排序: 1 25 29 42 45 74 87 53
第7趟排序: 1 25 29 42 45 53 74 87
关键字序列: 21 12 2 40 99 97 68 57
直接插入排序
第1趟排序: 12 21 2 40 99 97 68 57
第2趟排序: 2 12 21 40 99 97 68 57
第3趟排序: 2 12 21 40 99 97 68 57
第4趟排序: 2 12 21 40 99 97 68 57
第5趟排序: 2 12 21 40 97 99 68 57
第6趟排序: 2 12 21 40 68 97 99 57
第7趟排序: 2 12 21 40 57 68 97 99
关键字序列: 27 38 65 97 76 13 27 49 55 4
希尔排序
delta=5 13 27 49 55 4 27 38 65 97 76
delta=2 4 27 13 27 38 55 49 65 97 76
delta=1 4 13 27 27 38 49 55 65 76 97
关键字序列: 49 38 65 97 76 13 27 49 55 4 //严书
希尔排序
delta=5 13 27 49 55 4 49 38 65 97 76
delta=2 4 27 13 49 38 55 49 65 97 76 //与严书不同
delta=1 4 13 27 38 49 49 55 65 76 97
关键字序列: 65 34 25 87 12 38 56 46 14 77 92 23
希尔排序
delta=6 56 34 14 77 12 23 65 46 25 87 92 38
delta=3 56 12 14 65 34 23 77 46 25 87 92 38
delta=1 12 14 23 25 34 38 46 56 65 77 87 92
关键字序列: 84 12 43 62 86 7 90 91
希尔排序
delta=4 84 7 43 62 86 12 90 91
delta=2 43 7 84 12 86 62 90 91
delta=1 7 12 43 62 84 86 90 91
关键字序列: 32 26 87 72 26 17
冒泡排序
第1趟排序: 26 32 72 26 17 87
第2趟排序: 26 32 26 17 72 87
第3趟排序: 26 26 17 32 72 87
第4趟排序: 26 17 26 32 72 87
第5趟排序: 17 26 26 32 72 87
关键字序列: 1 2 3 4 5 6 7 8
冒泡排序
第1趟排序: 1 2 3 4 5 6 7 8
关键字序列: 1 3 2 4 5 8 6 7
冒泡排序
第1趟排序: 1 2 3 4 5 6 7 8
第2趟排序: 1 2 3 4 5 6 7 8
关键字序列: 4 5 8 1 2 7 3 6
冒泡排序
第1趟排序: 4 5 1 2 7 3 6 8
第2趟排序: 4 1 2 5 3 6 7 8
第3趟排序: 1 2 4 3 5 6 7 8
第4趟排序: 1 2 3 4 5 6 7 8
第5趟排序: 1 2 3 4 5 6 7 8
关键字序列: 38 26 97 19 66 1 5 49
07, vot=38 5 26 1 19 38 66 97 49
03, vot=5 1 5 26 19 38 66 97 49
23, vot=26 1 5 19 26 38 66 97 49
57, vot=66 1 5 19 26 38 49 66 97
关键字序列: 38 5 49 26 19 97 1 66
07, vot=38 1 5 19 26 38 97 49 66
03, vot=1 1 5 19 26 38 97 49 66
13, vot=5 1 5 19 26 38 97 49 66
23, vot=19 1 5 19 26 38 97 49 66
57, vot=97 1 5 19 26 38 66 49 97
56, vot=66 1 5 19 26 38 49 66 97
关键字序列: 49 38 65 97 76 13 27 49
07, vot=49 49 38 27 13 49 76 97 65
03, vot=49 13 38 27 49 49 76 97 65
02, vot=13 13 38 27 49 49 76 97 65
12, vot=38 13 27 38 49 49 76 97 65
57, vot=76 13 27 38 49 49 65 76 97
关键字序列: 27 38 65 97 76 13 27 49 55 4
low=0 high=9 vot=27 4 27 13 27 76 97 65 49 55 38
low=0 high=2 vot=4 4 27 13 27 76 97 65 49 55 38
low=1 high=2 vot=27 4 13 27 27 76 97 65 49 55 38
low=4 high=9 vot=76 4 13 27 27 38 55 65 49 76 97
low=4 high=7 vot=38 4 13 27 27 38 55 65 49 76 97
low=5 high=7 vot=55 4 13 27 27 38 49 55 65 76 97
关键字序列: 38 26 97 19 66 1 5 49
直接选择排序
第0趟排序: 1 26 97 19 66 38 5 49
第1趟排序: 1 5 97 19 66 38 26 49
第2趟排序: 1 5 19 97 66 38 26 49
第3趟排序: 1 5 19 26 66 38 97 49
第4趟排序: 1 5 19 26 38 66 97 49
第5趟排序: 1 5 19 26 38 49 97 66
第6趟排序: 1 5 19 26 38 49 66 97
最小堆
关键字序列: 81 49 76 27 97 38 49 13 65
sift 38 81 49 76 13 97 38 49 27 65
sift 28 81 49 38 13 97 76 49 27 65
sift 18 81 13 38 27 97 76 49 49 65
sift 08 13 27 38 49 97 76 49 81 65
13 27 38 49 97 76 49 81 65
sift 07 27 49 38 65 97 76 49 81 13
sift 06 38 49 49 65 97 76 81 27 13
sift 05 49 65 49 81 97 76 38 27 13
sift 04 49 65 76 81 97 49 38 27 13
sift 03 65 81 76 97 49 49 38 27 13
sift 02 76 81 97 65 49 49 38 27 13
sift 01 81 97 76 65 49 49 38 27 13
sift 00 97 81 76 65 49 49 38 27 13
最大堆
关键字序列: 49 65 13 81 76 27 97 38 49
sift 38 49 65 13 81 76 27 97 38 49
sift 28 49 65 97 81 76 27 13 38 49
sift 18 49 81 97 65 76 27 13 38 49
sift 08 97 81 49 65 76 27 13 38 49
97 81 49 65 76 27 13 38 49
sift 07 81 76 49 65 49 27 13 38 97
sift 06 76 65 49 38 49 27 13 81 97
sift 05 65 49 49 38 13 27 76 81 97
sift 04 49 38 49 27 13 65 76 81 97
sift 03 49 38 13 27 49 65 76 81 97
sift 02 38 27 13 49 49 65 76 81 97
sift 01 27 13 38 49 49 65 76 81 97
sift 00 13 27 38 49 49 65 76 81 97
关键字序列: 52 26 97 19 66 8 49
归并排序
子序列长度n=1 26 52 19 97 8 66 49
子序列长度n=2 19 26 52 97 8 49 66
子序列长度n=4 8 19 26 49 52 66 97
关键字序列: 13 27 38 49 97 76 49 81 65
最小堆序列 true
/
以上就是关于asp网站综合排名代码修改成小类排名代码全部的内容，包括:asp网站综合排名代码修改成小类排名代码、求编写一个C语言程序。、谁能帮我用C语言设计一个有奖评选程序题目是：十佳运动员评选活动（一、功能要求等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）