算法历年题

Ⅰ 高中数学算法、程序的题

1. 说法1和3是正确的（2错，算法是不唯一的，故有好算法与差算法之分，在编程时应选择最好的算法，加快程序的运行速度）

2. 1错了（赋值号=右端需为确定的值，而非变量；）

Ⅱ 面试会出哪些经典算法题

1、排序算法∶快速排序、归并排序、计数排序

2、搜索算法∶回溯、递归、剪枝技巧

3、图论∶最短路、最小生成树、网络流建模

4、动态规划：背包问题、最长子序列、计数问题

5、基础技巧：分治、倍增、二分、贪心

6、数组与链表：单/双向链表、跳舞链

7、栈与队列

8、树与图：最近公共祖先、并查集

9、哈希表

10、堆：大/小根堆、可并堆

11、字符串∶字典树、后缀树

(2)算法历年题扩展阅读：

算法的重要性：

1、算法能力能够准确辨别一个程序员的技术功底是否扎实；

2、算法能力是发掘程序员的学习能力与成长潜力的关键手段；

3、算法能力能够协助判断程序员在面对新问题时，分析并解决问题的能力；

4、算法能力是设计一个高性能系统、性能优化的必备基础。

Ⅲ 知名公司经典算法笔试题和面试题答案

微软

有一个整数数组，请求出两两之差绝对值最小的值，记住，只要得出最小值即可，不需要求出是哪两个数。

写一个函数，检查字符是否是整数，如果是，返回其整数值。(或者：怎样只用4行代码编写出一个从字符串到长整形的函数?)

给出一个函数来输出一个字符串的所有排列。

请编写实现malloc()内存分配函数功能一样的代码。给孙答出一个函数来复制两个字符串A和B。字符串A的后几个字节和字符串B的前几个字节重叠。

怎样编写一个程序，把一个有序整数数组放到二叉树中?

怎样从顶部开始逐层打印二叉树结点数据?请编程。

怎样把一个链表掉个顺序(也就是反序，注意链表的边界条件并考虑空链表)?

请编写能直接实现int atoi(const char * pstr)函数功能的代码。

编程实现两个正整数的除法，编程实现两个正整数的除法，当然不能用除法操作符。

1

// return x/y.

2

int span(const int x, const int y)

3

{

4

....

5

}

在排序数组中，找出给定数字的出现次数，比如 [1, 2, 2, 2, 3] 中2的出现次数是3次。

平面上N个点，每两个点都确定一条直线，求出斜率最大的那条直线所通过的两个点(斜率不存在的情况不考虑)。时间效率越高越好。

一个整数数列，元素取值可能是0~65535中的任意一个数，相同数值不会重复出现。0是例外，可以反复出现。请设计一个算法，当你从该数列中随意选取5个数值，判断这5个数值是否连续相邻。注意：

5个数值允许是乱序的。比如：8 7 5 0 6

0可以通配任意数值。比如：8 7 5 0 6 中的0可以通配成9或者4

0可以多次出现。

复杂度如果是O(n2)则不得分。

设计一个算法，找出二叉树上任意两个结点的最近共同父结点。复杂度如果是O(n2)则不得分。

一棵排序二叉树，令 f=(最大值+最小值)/2，设计一个算法，找出距离f值最近、大于f值的结点。复杂度如果是O(n2)则不得分。

一个整数数列，元素取值可能是1~N(N是一个较大的正整数)中的任意一个数，相同数值不会重复出现。设计一个算法，找出数列中符合条件的数对的个数，满足数对中两数的和等于N+1。复杂度最好是O(n)，如果是O(n2)则不得分。

Google

正整数序列Q中的每个元素都至少能被正整数a和b中的一个整除，现给定a和b，需要计算出Q中的前几项，例如，当a=3，b=5，N=6时，序列为3，5，6，9，10，12 (1)、设计一个函数void generate(int a,int b,int N ,int * Q)计算Q的前几项(2)、设计测试数据来验证函数程序在各种输入下的正确性。

有一个由大小写组成的字符串，现在需要对他进行修改，将其中的所有小写字母排在答谢字母的前面(大写或小写字母之间不要求保持原来次序)，如有可能尽量选择时间和空间效率高的算法 c语言函数原型void proc(char *str) 也可以采用你自己熟悉的语言。

如何随机选取1000个关键字，给定一个数据流，其纯宴中包含无穷尽的搜索关键字(比如，人们在谷歌搜索时不断输入的关键字)。如何才能从这个无穷尽的流中随机的选取1000个关键字?

判断一个自然数是否是某个数的平方。说明：当然不能使用开方运算。

给定能随机生成整数1到5的函数，写出能随机生成整数1到7的函数。

1024! 末尾有多少个0?

有5个海盗，按照等级从5到1排列，最大的海盗有权提议他们如何分享100枚金币。但其他人要对此表决，如果多数反对，那他就会被杀死。他应该提出怎样的方案，既让自己拿到尽可能多的金币又不会被杀死?(提示：有一个海盗能拿到98%的金币)

23、Google2015华南地区笔试题。给定一个集合A=[0,1,3,8](该集合中的元素都是在0，9之间的数字，但未必全部包含)，指定任意一个正整数K，做凯银请用A中的元素组成一个大于K的最小正整数。比如，A=[1,0] K=21 那么输出结构应该为100。

网络

用C语言实现一个revert函数，它的功能是将输入的字符串在原串上倒序后返回。

用C语言实现函数void * memmove(void *dest, const void *src, size_t n)。memmove 函数的功能是拷贝src所指的内存内容前n个字节到dest所指的地址上。分析：由于可以把任何类型的指针赋给void类型的指针，这个函数主要是实现各种数据类型的拷贝。

有一根27厘米的细木杆，在第3厘米、7厘米、11厘米、17厘米、23厘米这五个位置上各有一只蚂蚁。木杆很细，不能同时通过一只蚂蚁。开始时，蚂蚁的头朝左还是朝右是任意的，它们只会朝前走或调头，但不会后退。当任意两只蚂蚁碰头时，两只蚂蚁会同时调头朝反方向走。假设蚂蚁们每秒钟可以走一厘米的距离。编写程序，求所有蚂蚁都离开木杆的最小时间和最大时间。

腾讯

请定义一个宏，比较两个数a、b的大小，不能使用大于、小于、if语句

两个数相乘，小数点后位数没有限制，请写一个高精度算法

有A、B、C、D四个人，要在夜里过一座桥。他们通过这座桥分别需要耗时1、2、5、10分钟，只有一支手电，并且同时最多只能两个人一起过桥。请问，如何安排，能够在17分钟内这四个人都过桥?

有12个小球,外形相同,其中一个小球的质量与其他11个不同，给一个天平,问如何用3次把这个小球找出来，并且求出这个小球是比其他的轻还是重

在一个文件中有 10G 个整数，乱序排列，要求找出中位数。内存限制为 2G。只写出思路即可。

一个文件中有40亿个整数，每个整数为四个字节，内存为1GB，写出一个算法：求出这个文件里的整数里不包含的一个整数。

腾讯服务器每秒有2w个QQ号同时上线，找出5min内重新登入的qq号并打印出来。 1 2

Ⅳ 软件设计师下午考试历年c语言算法有哪些 有代码更好

07年下：
试题五（共15分）
阅读以下说明和C代码，将应填入 （n） 处的字句写在答题纸的对应栏内。
【说明】
在差薯敏一个简化的绘图程序中，支持的图形种类有点(point)和圆(circle)，在设计过程中采用面向对象思想，认为所有的点和圆都是一种图形(shape)，并定义了类型shape_t、point_t和circle_t分别表示基本图形、点和圆，并且点和圆具有基本图形的所有特征。
[C代码]
typedef enum { point,circle } shape_type; /* 程序中的两种图形：点和圆 */
typedef struct { /* 基本的图形类型 */
shape_type type; /* 图形手链种类标识：点或者圆 */
void (*destroy)(); /* 销毁图形操作的函数指针 */
void (*draw)(); /* 绘制图形操作的函数指针 */
} shape_t;
typedef struct { shape_t common; int x; int y; } point_t; /* 定义点类型，x、y为点坐标 */
void destroyPoint(point_t* this) { free(this); printf("Point destoryed!\n"); } /* 销毁点对象 */
void drawPoint(point_t* this) { printf("P(%d,%d)", this->x, this->y); } /* 绘制点对象 */
shape_t* createPoint(va_list* ap) { /* 创建点对象，并设置其属性 */
point_t* p_point;
if( (p_point = (point_t*)malloc(sizeof(point_t))) == NULL ) return NULL;
p_point->common.type = point; p_point->common.destroy = destroyPoint;
p_point->common.draw = drawPoint;
p_point->x = va_arg(*ap, int); /* 设置点的横坐标 */
p_point->y = va_arg(*ap, int); /* 设置点的纵坐标 */
return (shape_t*)p_point; /* 返回点对象虚枝指针 */
}
typedef struct { /* 定义圆类型 */
shape_t common;
point_t *center; /* 圆心点 */
int radius; /* 圆半径 */
} circle_t;
void destroyCircle(circle_t* this){
free( （1） ); free(this); printf("Circle destoryed!\n");
}
void drawCircle(circle_t* this) {
printf("C(");
（2） .draw( this->center ); /* 绘制圆心 */
printf(",%d)", this->radius);
}
shape_t* createCircle(va_list* ap) { /* 创建一个圆，并设置其属性 */
circle_t* p_circle;
if( (p_circle = (circle_t*)malloc(sizeof(circle_t))) == NULL ) return NULL;
p_circle->common.type = circle; p_circle->common.destroy = destroyCircle;
p_circle->common.draw = drawCircle;
（3） = createPoint(ap); /* 设置圆心 */
p_circle->radius = va_arg(*ap, int); /* 设置圆半径 */
return p_circle;
}
shape_t* createShape(shape_type st, ...) { /* 创建某一种具体的图形 */
va_list ap; /* 可变参数列表 */
shape_t* p_shape = NULL;
（4） (ap, st);
if( st == point ) p_shape = createPoint( &ap); /* 创建点对象 */
if( st == circle ) p_shape = createCircle(&ap); /* 创建圆对象 */
va_end(ap);
return p_shape;
}
int main( ) {
int i; /* 循环控制变量，用于循环计数 */
shape_t* shapes[2]; /* 图形指针数组，存储图形的地址 */
shapes[0] = createShape( point, 2, 3); /* 横坐标为2，纵坐标为3 */
shapes[1] = createShape( circle, 20, 40, 10); /* 圆心坐标(20,40)，半径为10 */
for(i=0; i<2; i++) { shapes[i]->draw(shapes[i]); printf("\n"); } /* 绘制数组中图形 */
for( i = 1; i >= 0; i-- ) shapes[i]->destroy(shapes[i]); /* 销毁数组中图形 */
return 0;
}
[运行结果]
P(2,3)

08上：
试题四（10 分）
阅读下列说明，回答问题 1 至问题 3，将解答填入答题纸的对应栏内。
[说明]
以下代码由 C 语言书写，在输入三个整数后，能够输出最大数和最小数。
int main( void )
{
int a, b, c, max, min;
printf( "input three numbers: " );
scanf( "%d%d%d", &a, &b, &c );
if( a > b ) /*判断 1*/
{
max = a;
min = b;
}
else
{
max = b;
min = a;
}
if( max < c ) /*判断 2*/
max = c;
else if( min > c ) /*判断 3*/
min = c;
printf( "max=%d\nmin=%d", max, min );
return 0;
}
08下
【问题 3】（2 分） 【问题 1】中伪代码的时间复杂度为 （6） （用 Ο 符号表示）。
试题五（共 15 分）
阅读下列说明和 C 函数，将应填入 （n） 处的字句写在答题纸的对应栏内。
【说明】
已知集合 A 和 B 的元素分别用不含头结点的单链表存储，函数 Difference()用于求解集合 A 与 B 的差集，并将结果保存在集合 A 的单链表中。例如，若集合 A={5，10，20，15，25，30}，集合 B={5，15，35，25}，如图 5-1(a)所示，运算完成后的结果如图 5-1(b)所示。

图 5-1 集合 A、B 运算前后示意图
链表结点的结构类型定义如下：
typedef struct Node{
ElemType elem;
struct Node *next;
}NodeType;

【C 函数】
void Difference(NodeType **LA, NodeType *LB)
{
NodeType *pa, *pb, *pre, *q;
pre = NULL;
(1) ;
while (pa) {
pb = LB;
while ( （2） )
pb = pb->next;
if ( （3） ) {
if (!pre)
*LA = （4） ;
else
（5） = pa->next;
q = pa;
pa = pa->next;
free(q);
}
else {
（6） ;
pa = pa->next;
}
}
}

09年
试题五（共 15 分）
阅读下列说明和 C 函数代码，将应填入 （n） 处的字句写在答题纸的对应栏内。
【说明】
对二叉树进行遍历是二叉树的一个基本运算。遍历是指按某种策略访问二叉树的每个结点，且每个结点仅访问一次的过程。函数 InOrder()借助栈实现二叉树的非递归中序遍历运算。
设二叉树采用二叉链表存储，结点类型定义如下：
typedef struct BtNode{
ElemType data; /*结点的数据域，ElemType 的具体定义省略*/
struct BtNode *lchild,*rchild; /*结点的左、右孩子指针域*/
}BtNode, *BTree;
在函数 InOrder()中，用栈暂存二叉树中各个结点的指针，并将栈表示为不含头结点的单向链表（简称链栈），其结点类型定义如下：
typedef struct StNode{
BTree elem; /*链栈的结点类型*/
struct StNode *link; /*栈中的元素是指向二叉链表结点的指针*/
}StNode;
假设从栈顶到栈底的元素为 en、en-1、…、e1，则不含头结点的链栈示意图如图 5-1所示。

图 5-1 链栈示意图
【C 函数】
int InOrder(BTree root) /* 实现二叉树的非递归中序遍历 */
{
BTree ptr; /* ptr 用于指向二叉树中的结点 */
StNode *q; /* q 暂存链栈中新创建或待删除的结点指针*/
StNode *stacktop = NULL; /* 初始化空栈的栈顶指针 stacktop */
ptr = root; /* ptr 指向二叉树的根结点 */
while ( （1） || stacktop != NULL) {
while (ptr != NULL) {
q = (StNode *)malloc(sizeof(StNode));
if (q == NULL)
return -1;
q->elem = ptr;
(2) ;
stacktop = q; /*stacktop 指向新的栈顶*/
ptr = （3） ; /*进入左子树*/
}
q = stacktop;
（4） ; /*栈顶元素出栈*/
visit(q); /*visit 是访问结点的函数，其具体定义省略*/
ptr = （5） ; /*进入右子树*/
free(q); /*释放原栈顶元素的结点空间*/
}
return 0;
}/*InOrder*/

09年下：
试题七（共 15 分）
阅读以下说明和C程序，将应填入 （n） 处的字句写在答题纸的对应栏内。
【说明】
现有 n（n < 1000）节火车车厢，顺序编号为 1,2,3,...,n，按编号连续依次从 A 方向的 铁轨驶入，从 B 方向铁轨驶出，一旦车厢进入车站（Station）就不能再回到 A 方向的铁轨 上；一旦车厢驶入 B 方向铁轨就不能再回到车站，如图 7-1 所示，其中 Station 为栈结构， 初始为空且最多能停放 1000 节车厢。

图 7-1 车站示意图
下面的 C 程序判断能否从 B 方向驶出预先指定的车厢序列，程序中使用了栈类型STACK,关于栈基本操作的函数原型说明如下：
void InitStack(STACK *s)：初始化栈。
void Push(STACK *s,int e): 将一个整数压栈，栈中元素数目增 1。
void Pop(STACK *s)：栈顶元素出栈，栈中元素数目减 1。
int Top(STACK s)：返回非空栈的栈顶元素值，栈中元素数目不变。
int IsEmpty(STACK s)：若是空栈则返回 1，否则返回 0。
【C程序】
#include<stdio.h>
/*此处为栈类型及其基本操作的定义，省略*/
int main( ){
STACK station;
int state[1000];
int n; /*车厢数*/
int begin, i, j, maxNo; /*maxNo 为 A 端正待入栈的车厢编号*/
printf("请输入车厢数： ");
scanf("%d",&n);
printf("请输入需要判断的车厢编号序列（以空格分隔）： ");
if (n < 1) return -1;
for (i = 0; i<n; i++) /* 读入需要驶出的车厢编号序列,存入数组 state[] */
scanf("%d",&state[i]);
（1） ; /*初始化栈*/
maxNo = 1;
for(i = 0; i < n; ){/*检查输出序列中的每个车厢号 state[i]是否能从栈中获取*/
if ( （2） ){/*当栈不为空时*/
if (state[i] == Top(station)){ /*栈顶车厢号等于被检查车厢号*/
printf("%d ",Top(station)); Pop(&station); i++;
}
else
if
( （3） ){ printf("error\n"); return 1;
}
else{
begin (4) ;
for(j = begin+1; j<=state[i]; j++)
{ Push(&station, j);
}
}
}
else { /*当栈为空时*/
begin = maxNo;
for(j = begin; j<=state[i]; j++){ Push(&station, j);
}
maxNo = （5） ;
}
}
printf("OK");
return 0;
}

Ⅳ 几个算法分析方面的题目

1. 局部最优能达到全局最优。
2. 一个问题能被分解成子问题，这个问题的解最优当且仅当所有子问题的解最优。
3. 解空间指所有的可行解组成的集合。

2. 贪心算法可用来解这个问题，按顺序将物品按重量递增顺序加入背包，直到不能加入，正确性显然，每个物品只被考虑一次，时间复杂度O( n )，可以认为是Theta( k ),其中k为最优解加入的物品数。
3. 对于每个区间[ a , b ] ， 另mid = ( a + b ) / 2 ，cnt[ a , b ] = cnt[ a , mid ] + cnt( mid , b ] , 其中cnt[ a , a ] = 1 ， 当 num[ a ] = x , 否则 cnt[ a , a ] = 0 ;时间复杂度是O( n )的，考虑满二叉树的性质，得证。（ 硬搞出来的分治算法... ）
4. 题目不完整。
5. 自己画吧...这里不好贴图，然后前序厉遍一下，写出来，伪代码也自己写吧。

时间不多，只能这么简略地写一下，希望能帮到你。

BillWSY

Ⅵ 逻辑算法题(不断更新)

问：有1000瓶药剂和10只老鼠，药剂中有1瓶毒药，喝了一周内死亡（有的题目改成了五分钟，五分钟真亏他能喂完），如何在仿早一周内找到这瓶毒药。
答：将这1000瓶药剂编号0~999，并转换为二进制 就是0000000001~1111101000，从右向左开始，让第一只老鼠喝所有右起第一位编号为1的药剂，第二只老鼠喝所有右起第二位编号为1的药剂，依次类推，10只老鼠喝完10位的药剂，一周后，如果第一只老鼠死亡，那么毒药的从右起第一位为1，未死亡的话就为0，所以根据死亡状态就可以知道该瓶毒药的二进制。
例如状态是：死亡，存活，死亡，存活，存活，存活，死亡，存活，死亡，存活 = 010111010=186
从上面例银瞎子就可以知道第二种和第三种问题的解法了吧

测试时间提升为两周就说明第一周测试不死的老鼠可以拿来继续第二周的测试 ，所以老鼠的状态就变成了三种：存活（未实验），死亡，实验后存活。
将全部药剂编号后转为三进制数，老鼠右起依次喝0编号的药剂，如果死亡，那么该位编号为0，锋大空如果未死亡，那么可能为1和2，第二周把存活的老鼠继续喝该位1编号的药剂，如果死亡就为1，存活就为2，这样就找到了毒药的三进制编号，然后转换成下标即可。

总结:有 n 只小白鼠 m周的时间可以从 (m+1)^n 个瓶子中检验出毒药来。

Ⅶ 算法问题

#include <stdio.h>
#include <stdlib.h>
#include <string.h>物饥

int money_count(int money) //第一题判蚂搏
{
int SortedMonType[7] = {100,50,20,10,5,2,1};
int Money_left = money;
int Money_count = 0;
int CurMoney_index = 0;
int i;

for(i=0;i<7;i++)
{
int Tempcount = (int)(Money_left/掘祥SortedMonType[i]);
Money_count += Tempcount;
Money_left = Money_left - Tempcount*SortedMonType[i];
if(Money_left==0) break;
}

return Money_count;

}

float equal(float *arr, int size) //第二题
{
if(size == 1)
return arr[0]/size;

return (arr[0] + equal(arr+1, size-1) * (size-1))/size;
}

void main()
{
float arr[8] = {11,22,33,44,55,66,77,88};

printf("equal = %f \n",equal(arr, 8));

printf("%d\n", money_count(381));
}

Ⅷ 算法题目

C C B A
给点分吧，嘿嘿

Ⅸ 算法分析与设计题目

第一题用贪心思想 找出用时最短的m个作业交给机器同时开始加工 然后再依次将剩下的作业中最短完成作业取出放入已完成的机器加工 当最后一台机器完工时间就是所用最短时间 思路是这样子 具体算法实现的话。。由于我也是学生=、=写代码还不是很熟练。。可能等我写好了你考试来不及。。。你还是自己来吧

第二题
1.背包问题是什么=、=我们教材不一样 不了解具体问题。。
2.4皇后
#include<iostream.h>
const int n = 4 ;
const int n_sub = n - 1 ;
int queen[n] ;
bool row[n] ;
bool passive[2*n-1];
bool negative[2*n-1];
int main()
{
int cur = 0 ;
bool flag = false ;
queen[0] = -1 ;
int count = 0 ;
while(cur>=0)
{
while(cur>=0 && queen[cur]<n && !flag)
{
queen[cur]++ ;
if(queen[cur] >= n)
{
queen[cur] = -1 ;
cur-- ;
if(cur>=0)
{
row[queen[cur]] = false ;
passive[queen[cur] + cur] = false ;
negative[n_sub + cur - queen[cur]] = false ;
}
false ;
}
else
{
if(row[queen[cur]] == false)
{
flag = true ;
if( passive[queen[cur] + cur] == true || negative[n_sub + cur - queen[cur]] == true) {
flag = false ;
}
else
flag = true ;
if(flag) {
if(cur == n-1)
{
count++ ;
}
row[queen[cur]] = true ;
passive[queen[cur] + cur] = true ;
negative[n_sub + cur - queen[cur]] = true ;
cur++ ;
if(cur >= n) {
cur-- ;
row[queen[cur]] = false ;
passive[queen[cur] + cur] = false ;
negative[n_sub + cur - queen[cur]] = false ;
}
flag = false ;
}
}
}
}
}
cout<<n<<"皇后问题一共有"<<count<<"种解法"<<endl ;
return 0 ;
}
这个是代码。。。状态空间树这里画不出来。。。

第三题
你网络下基本都有的=、=。。。我网络出来不好意思贴了你自己去看下吧
比如1.的答案：
最坏情况给出了算法执行时间的上界，我们可以确信，无论给什么输入，算法的执行时间都不会超过这个上界，这样为比较和分析提供了便利。

Ⅹ 算法与数据结构试题 急用！！！

这是我写的顺序查找和二分查找代码
#include<iostream.h>
#define elemtype int

int sqsearch(elemtype a[],int n,elemtype x); //顺序查找
int sqsearch2(elemtype a[],int n,elemtype x); //顺序查找，打印查找过程
int binsearch(elemtype a[],int n,elemtype x); //折半查找
int binsearch2(elemtype a[],int n,elemtype x); //折半查找，打印查找过程

void printarray(elemtype a[],int n); //打印数组数据

int main()
{
int i,x;
const int n=9;
elemtype a1[10]={0,34,23,12,56,90,78,89,45,67};
elemtype a2[10]={0,12,23,34,45,56,67,78,89,90};

//顺序查找
cout<<"顺序查找："<<endl;
cout<<"a1[]=";
printarray(a1,n);
cout<<"输入要查找的数据：";
cin>>x;
if((i=sqsearch(a1,n,x))>0) //找到
cout<<"找到x==a1["<<i<<"]"<<endl;
else //未找到
cout<<"找不到"<<x<<endl;
cout<<endl<<"查找过程："<<endl;
sqsearch2(a1,n,x); //查找过程
cout<<"完成顺序查找！"<<endl;
//二分法查找
cout<<"二分法查找："<<endl;
cout<<"a2[]=";
printarray(a2,n);
cout<<"输入要查找的数据：";
cin>>x;
if((i=binsearch(a2,n,x))>0) //找到
cout<<"找到x==a1["<<i<<"]"<<endl;
else //未找到
cout<<"找不到"<<x<<endl;
cout<<endl<<"查找过程："<<endl;
binsearch2(a2,n,x);
cout<<"完成顺序查找！"<<endl;
return 0;
}

//在数组a[1.2...n]中顺序查找x
//找到时返回元素下标，否则返回0
int sqsearch(elemtype a[],int n,elemtype x) //a[]是数组，n是元素个数，x是要查找的数
{
int i;
if(a[0]==x)
return 1;
else
{
a[0]=x;
for(i=n;!(a[i]==x);--i); //若找到则i大于0
return i;
}
}

//在数组a[1.2...n]中顺序查找x,打印每次比较结果
//找到时返回元素下标，否则返回0
int sqsearch2(elemtype a[],int n,elemtype x) //a[]是数组，n是元素个数，x是要查找的数
{
int i;
a[0]=x;
for(i=n;!(a[i]==x);--i)
if(a[i]>x)
cout<<a[i]<<">"<<x<<endl;
else
cout<<a[i]<<"<"<<x<<endl;
return i;
}

//在数组a[1.2...n]中二分法查找x
//找到时返回元素下标，否则返回0
//前提：a[1.2...n]是非递减有序的
int binsearch(elemtype a[],int n,elemtype x) //二分查找
{
int mid,low=1,high=n;
while(low<=high)
{
mid=(low+high)/2;
if(x==a[mid])
return mid;
else if(x<a[mid])
high=mid-1;
else
low=mid+1;
}
return 0;
}

//在数组a[1.2...n]中二分法查找x，每次打印比较结果
//找到时返回元素下标，否则返回0
//前提：a[1.2...n]是非递减有序的
int binsearch2(elemtype a[],int n,elemtype x) //查找过程
{
int mid,low=1,high=n;
while(low<=high)
{
mid=(low+high)/2;
if(x==a[mid])
{
cout<<a[mid]<<"="<<x<<endl;
return mid;
}
else if(x<a[mid])
{
cout<<a[mid]<<">"<<x<<endl;
high=mid-1;
}
else
{
cout<<a[mid]<<"<"<<x<<endl;
low=mid+1;
}
}
return 0;
}

//打印顺组数据a[1....n]
void printarray(int a[],int n)
{
int i;
cout<<"{";
for(i=0;i<=n;i++)
{
cout<<a[i];
while(i<n)
{
cout<<",";
break;
}
}
cout<<"}"<<endl;
}