工程问题典型题目总结

一、           基本工程问题

1、甲、乙两人共同加工一批零件，8小时可以完成任务．如果甲单独加工，便需要12小时完成．现在甲、乙两人共同生产了小时后，甲被调出做其他工作，由乙继续生产了420个零件才完成任务．问乙一共加工零件多少个?

【解析】乙单独加工，每小时加工  甲调出后，剩下工作乙需做时所以乙每小时加工零件(个)，则小时加工(个)，所以乙一共加工零件420+60＝480(个)．

【答案】480

2、一项工程，甲单独完成需要天，乙单独完成需要天．若甲先做若干天后乙接着做，共用天完成，问甲做了几天？

【解析】 根据题意可知，甲的工作效率为，乙的工作效率为，采用鸡兔同笼问题的假设法，可知甲做了天．

【答案】天

3、一些工人做一项工程，如果能调来16人，那么10天可以完成；如果只调来4人，就要20天才能完成，那么调走2人后，完成这项工程需要        天．

【解析】 设1个人做1天的量为1，设原来有人在做这项工程，得：，解得：．如果调走2人，需要(天)．

【答案】天

4、一池水，甲、乙两管同时开，5小时灌满；乙、丙两管同时开，4小时灌满．现在先开乙管6小时，还需甲、丙两管同时开2小时才能灌满．乙单独开几小时可以灌满？

【解析】 由于甲、乙和乙、丙的工作效率之和都知道了，根据“现在先开乙管6小时，还需甲、丙两管同时开2小时灌满”，我们可以把乙管的6小时分成3个2小时，第一个2小时和甲同时开，第二个2小时和丙同时开，第三个2小时乙管单独开．这样就变成了甲、乙同时开2小时，乙、丙同时开2小时，乙单独开2小时，正好灌满一池水．可以计算出乙单独灌水的工作量为，所以乙的工作效率为：，所以整池水由乙管单独灌水，需要（小时）．

【答案】小时

二、           变速工程

1、甲、乙合作一件工程，由于配合得好，甲的工作效率比单独做时提高，乙的工作效率比单独做时提高．甲、乙两人合作小时，完成全部工作的，第二天乙又单独做了小时，还留下这件工作的尚未完成，如果这件工作始终由甲一人单独来做，需要多少小时？

【解析】乙的工作效率是：，甲的工作效率是：，所以，单独由甲做需要：(小时)．

【答案】小时

2、甲、乙两人同时加工同样多的零件，甲每小时加工40个，当甲完成任务的时，乙完成了任务的还差40个．这时乙开始提高工作效率，又用了小时完成了全部加工任务．这时甲还剩下20个零件没完成．求乙提高工效后每小时加工零件多少个？

【解析】 当甲完成任务的时，乙完成了任务的还差40个，这时乙比甲少完成40个；

当乙完成全部任务时，甲还剩下20个零件没完成，这时乙比甲多完成20个；

所以在后来的小时内，乙比甲多完成了个，那么乙比甲每小时多完成个．所以提高工效后乙每小时完成个．

【答案】个

3、甲、乙两项工程分别由一、二队来完成．在晴天，一队完成甲工作要12天，二队完成乙工程要15天；在雨天，一队的工作效率要下降，二队的工作效率要下降．结果两队同时完成工作，问工作时间内下了多少天雨？

【解析】 在晴天，一队、二队的工作效率分别为和，一队比二队的工作效率高；在雨天，一队、二队的工作效率分别为和，二队的工作效率比一队高．由知，3个晴天5个雨天，两个队的工作进程相同，此时完成了工程的，所以在施工期间，共有6个晴天10个雨天．

方法二：本题可以用方程的方法，在方程解应用题中会继续出现。

【答案】10个雨天

三、           交替工程

1、一项工程，乙单独做要天完成．如果第一天甲做，第二天乙做，这样交替轮流做，那么恰好用整天数完成；如果第一天乙做，第二天甲做，这样交替轮流做，那么比上次轮流的做法多用半天完工．问：甲单独做需要几天？

【解析】甲、乙轮流做，如果是偶数天完成，那么乙、甲轮流做必然也是偶数天完成，且等于甲、乙轮流做的天数，与题意不符；所以甲、乙轮流做是奇数天完成，最后一天是甲做的．那么乙、甲轮流做比甲、乙轮流做多用半天，这半天是甲做的．如果设甲、乙工作效率分别为和，那么，所以，乙单独做要用天，甲的工作效率是乙的倍，所以甲单独做需要天．

【答案】天

2、一项工程，甲单独做要12小时完成，乙单独做要18小时完成．若甲先做1小时，然后乙接替甲做1小时，再由甲接替乙做1小时，……，两人如此交替工作，请问：完成任务时，共用了多少小时？

【解析】 ① 若甲、乙两人合作共需多少小时？

   （小时）．

 ②甲、乙两人各单独做7小时后，还剩多少？

   ．

 ③余下的由甲独做需要多少小时？

   （小时）．

 ④共用了多少小时？

   （小时）．

在工程问题中，转换条件是常用手法．本题中，甲做1小时，乙做1小时，相当于他们合作1小时，也就是每2小时，相当于两人合做1小时．这样先算一下一共进行了多少个这样的2小时，余下部分问题就好解决了．

【答案】小时

3、公园水池每周需换一次水．水池有甲、乙、丙三根进水管．第一周小李按甲、乙、丙、甲、乙、丙、……的顺序轮流打开1小时，恰好在打开水管整数小时后灌满空水池．第二周他按乙、丙、甲、乙、丙、甲……的顺序轮流打开1小时，灌满一池水比第一周少用了15分钟；第三周他按丙、乙、甲、丙、乙、甲……的顺序轮流打开1小时，比第一周多用了15分钟．第四周他三个管同时打开，灌满一池水用了2小时20分，第五周他只打开甲管，那么灌满一池水需用________小时．

【考点】工程问题          【难度】4星          【题型】解答

【关键词】20##年，迎春杯，高年级，初赛

【解析】 考虑水池减去甲乙丙两小时总和后的容积，则此部分按照甲乙丙的顺序灌刚好在整数小时后灌满，按照乙丙甲的顺序灌少用15分钟，按照丙乙甲的顺序灌多用15分钟，三个一起灌用20分钟．所以速度应该是乙最快，甲居中，丙最慢．也就是说，此部分是甲灌1个小时后灌满．甲灌1个小时的水=乙灌45分钟的水=丙灌1个小时的水+乙灌15分钟的水．所以灌水速度甲乙丙，也就是甲刚好是平均数．所以只用甲管灌满需要7小时．

【答案】7小时

4、蓄水池有甲、丙两条进水管和乙、丁两条排水管，要灌满一池水，单开甲管需小时，单开丙管需要小时，要排光一池水，单开乙管需要小时，单开丁管需要小时，现在池内有的水，若按甲、乙、丙、丁、甲、乙、丙、丁……的顺序轮流打开小时，问多少时间后水开始溢出水池？

【解析】 甲乙丙丁顺序循环各开小时可进水：，循环次后水池还空：，的工作量由甲管注水需要：(小时)，所以经过小时后水开始溢出水池．

【答案】

四、           工程问题常用方法技巧

（1）       等量代换法

1、一项工程，甲、乙、丙三人合作需要13天完成.如果丙休息2天，乙就要多做4天，或者由甲、乙两人合作1天.问这项工程由甲独做需要多少天？

【解析】丙2天的工作量，相当乙4天的工作量.丙的工作效率是乙的工作效率的4÷2=2（倍），甲、乙合作1天，与乙做4天一样.也就是甲做1天，相当于乙做3天，甲的工作效率是乙的工作效率的3倍.乙做13天，甲只要天，丙做13天，乙要26天，而甲只要天他们共同做13天的工作量，由甲单独完成，甲需要天

【答案】天

2、抄一份书稿，甲每天的工作效率等于乙、丙二人每天的工作效率的和；丙的工作效率相当甲、乙每天工作效率和的．如果3人合抄只需8天就完成了，那么乙一人单独抄需要多少天才能完成？

【解析】 已知甲、乙、丙合抄一天完成书稿的，又已知甲每天抄写量等于乙、丙两人每天抄写量之和，因此甲两天抄写书稿的，即甲每天抄写书稿的；由于丙抄写5天相当于甲乙合抄一天，从而丙6天抄写书稿的，即丙每天抄写书稿的；于是可知乙每天抄写书稿的--＝.所以乙一人单独抄写需要1÷=24天才能完成．

【答案】24天

3、一项工程，甲先做若干天后由乙继续做，丙在工程完成时前来帮忙，待工程完成时离去，结果恰按计划完成任务，其中乙做了工程总量的一半．如果没有丙的参与，仅由乙接替甲后一直做下去，将比计划推迟天完成；如果全由甲单独做，则可比计划提前天完成．还知道乙的工作效率是丙的倍，问：计划规定的工期是多少天？

【解析】 丙在工程完成一半时前来帮忙，待工程完成时离去，所以乙、丙合做了全部工程的；如果丙不来帮忙，这的工程由乙独做，那么乙完成这的工程时间将比乙、丙合做多用天．由于乙的工效是丙的工效的3倍，乙、丙合做的工效之和为乙独做的倍，那么乙独做所用的时间为乙、丙合做所用时间的倍，所以乙、丙合做这的工程所用的时间为天．那么乙的工效为．由于在丙来帮忙的情况下乙共做了工程总量的一半，所以乙工作的天数为天，其中有10天是乙、丙在合做，另外10天(被分成了前后两段)乙一个人独做．那么乙、丙共完成了全部工程的，根据题意，这的工程如果由甲独做，只需要天，那么甲的工效为．甲完成全部工程需要24天．由于全部由甲独做可比计划提前6天完成，所以原计划工期是天．

【答案】天

（2）       比例法

1、甲、乙、丙三村准备合作修筑一条公路，他们原计划按派工，后因丙村不出工，将他承担的任务由甲、乙两村分担，由丙村出工资360元，结果甲村共派出45人，乙村共派出35人，完成了修路任务，问甲、乙两村各应分得丙村所付工资的多少元？

【解析】丙村出的元钱是不是应该按照甲乙两村派出的人数比即来进行分配呢？我们仔细思考一下，发现丙村所出的钱应该是其他两个村帮他完成的工作量，换句话说，我们应该考虑的是甲乙两村各帮丙村出了多少人，然后再计算如何分配。

甲、乙两村共派出了人，而这80人，按照原计划应是甲村派出人，乙村派出32人，丙村派出12人，所以，实际上甲村帮丙村派出了人，乙村帮丙村派出了人，所以丙村拿出的360元钱，也应该按来分配给甲、乙两村，所以，甲村应分得：元，乙村应分得：元．

【答案】元

2、放满一个水池，如果同时打开1，2号阀门，则12分钟可以完成；如果同时打开1，3号阀门，则15分钟可以完成；如果单独打开1号阀门，则20分钟可以完成；那么，如果同时打开1，2，3号阀门，       分钟可以完成。

【解析】 单独打开1号门，20分钟可以完成，说明1号门每分钟完成，而同时打开1、2号闸门12分钟可以完成，说明2号闸门每分钟完成，而现在同时打开1、3号闸门，15分钟可以完成，说明3号闸门每分钟完成，则同时打开1、2、3号闸门，需要分钟。

【答案】分钟

（3）       列表法

1、放满一个水池，如果同时打开1，2，3号阀门，则20分钟可以完成；如果同时打开2，3，4阀门，则21分钟可以完成；如果同时打开1，3，4号阀门，则28分钟可以完成；如果同时打开1，2，4号阀门，则30分钟可以完成．问：如果同时打开1，2，3，4号阀门，那么多少分钟可以完成？

【解析】根据条件，列表如下（画○表示阀门打开，画×表示阀门关闭）：

从表中可以看出，每个阀门都打开了三次，所以这4个阀门的工作效率之和为：

，那么同时打开这4个阀门，需要（分钟）．

【答案】分钟

2、一项工程，如果由甲、乙、丙共同工作，天可以完成，需付工程款元；如果由甲、乙、丁共同工作，天可以完成，需付工程款元；如果由乙、丙、丁共同工作，天可以完成，需付工程款元；如果由甲、丙、丁共同工作，天可以完成，需付工程款元．现决定将工程承包给某一工程队，确保工程要在天以内完成，且支付的工程款尽量的少，那么应该将工程交给哪一个工程队，支付的工程款是多少元？

【解析】 ⑴ 甲、乙、丙、丁的工效和是：；

           甲的工效是：；乙的工效是：；

           丙的工效是：；丁的工效是：．

 可见甲、乙、丙、丁完成工程需要的时间分别为120天、360天、90天和72天．要确保工程在100天以内完成，只能选择丙队或丁队．然后比较选择丙队或丁队应支付的工款．

⑵ 甲、乙、丙每天需要的工程款元；

   甲、乙、丁每天需要的工程款元；

   乙、丙、丁每天需要的工程款元；

   甲、丙、丁每天需要的工程款元．

   甲、乙、丙、丁每天需要的工程款的总和为元．

   甲、乙、丙、丁每天需要的工程款分别是元，元，元， 元．如果由丙队独自完成整项工程，那么需要支付元；如果由丁队来完成，需要支付元．将两者进行比较，丙队的总工程款更少，所以工程应该交给丙。

【答案】丙

 

第二篇：C&C++典型题目总结

目录

1、static 在C语言里面主要有什么用途？... 2

2、引用与指针有什么区别？... 3

3、全局变量和局部变量在内存中是否有区别？... 4

4、什么是平衡二叉树？... 6

5、堆栈溢出一般是由什么原因导致的？... 6

6、什么函数不能声明为虚函数？... 6

7、写出float x 与“零值”比较的if语句... 7

8、Internet采用哪种网络协议？该协议的主要层次结构？... 7

9、Internet物理地址和IP 地址转换采用什么协议？... 7

10、IP 地址的编码分为哪俩部分？... 8

11、用户输入M,N值，从1 至N 开始顺序循环数数，每数到M 输出该数值，直至全部输出。写出C 程序。     8

12、不能做switch()的参数类型是？... 9

13、用两个栈实现一个队列的功能？要求给出算法和思路... 10

14、在c 语言库函数中将一个字符转换成整型的函数是atol()吗，这个函数的原型是什么？... 14

15、软件测试都有那些种类?. 14

16、指针步长问题？... 15

17、已知一个单向链表的头，请写出删除其某一个结点的算法，要求，先找到此结点，然后删除。     15

1、static 在C语言里面主要有什么用途？

答：（1）当它用于函数定义时，或用于代码块之外的变量声明时，static关键字用于修改标识符的连接属性，从external改为internal，但标识符的存储类型和作用域不受影响。用这种方式声明的函数或变量只能在声明它们的源文件中访问。

（2）当它用于代码块内部的变量声明时，static关键字用于修改变量的存储类型，从自动变量修改为静态变量，但变量的连接属性和作用域不受影响。用这种方式声明的变量在程序执行之前创建，并在程序的整个执行期间一直存在，而不是每次在代码块开始执行时创建，在代码块执行完毕后销毁。

以上为<<C和指针>>一书的解答

注解1：static关键字是C, C++中都存在的关键字, 它主要有三种使用方式, 其中前两种在C/C++语言中使用, 第三种只在C++中使用：

(1)局部静态变量（与auto变量的区别）：

1．1存储空间分配不同

auto类型分配在栈上, 属于动态存储类别, 占用动态存储空间, 函数调用结束后自动释放, 而static分配在静态存储区, 在程序整个运行期间都不释放. 两者之间的作用域相同, 但生存期不同.

1.2 static局部变量在所处模块初次运行时进行初始化工作, 且只初始化一次

1.3. 对于局部静态变量, 如果不赋初值, 编译期会自动赋初值0或空字符, 而auto类型的初值是不确定的. (对于C++中的class例外, class的对象实例如果不初始化, 则会自动调用默认构造函数, 不管是否是static类型

(2)外部静态变量/函数

为了限制全局变量/函数的作用域, 函数或变量前加static，但此处“static”的含义不是指存储方式，而是指对函数的作用域仅局限于本文件(所以又称内部函数)。此时的static只是起作用域限制作用, 限定作用域在本模块(文件)内部。

使用内部函数的好处是：不同的人编写不同的函数时，不用担心自己定义的函数，是否会与其它文件中的函数同名。

(3)静态数据成员/成员函数

表示属于一个类而不是属于此类的任何特定对象的变量和函数， 这是与普通成员函数的最大区别。

2、引用与指针有什么区别？

答：(1) 引用必须被初始化，指针不必；

(2) 引用初始化以后不能被改变，指针可以改变所指的对象；(3) 不存在指向空值的引用，但是存在指向空值的指针。

(4) 由于没有所谓的空引用所以在使用前不需要进行测试其是否有值,而使用指针则需要测试其的有效性。

注释：引用和指针的使用场所

一是你考虑到存在不指向任何对象的可能（在这种情况下，你能够设置指针为空），二是你需要能够在不同的时刻指向不同的对象（在这种情况下，你能改变指针的指向）。如果总是指向一个对象并且一旦指向一个对象后就不会改变指向，那么你应该使用引用。还有一种情况，就是当你重载某个操作符时，你应该使用引用。最普通的例子是操作符[]。

总之：当你知道你必须指向一个对象并且不想改变其指向时，或者在重载操作符并为防止不必要的语义误解时，你不应该使用指针。而在除此之外的其他情况下，则应使用指针。

3、全局变量和局部变量在内存中是否有区别？

答：全局变量储存在静态数据区，局部变量在堆栈。一般来说，程序的局部变量存在于堆栈中，全局变量存在于静态区中，动态申请数据存在于堆中。

注释：

（1）程序的内存分配（一个由C/C++编译的程序占用的内存分为以下几个部分）：

1、栈区（stack）— 由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。

2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。

3、全局区（静态区）（static）—全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区(.data)，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域(.bss)。 - 程序结束后由系统释放。

4、文字常量区 —常量字符串就是放在这里的(.rodata)。 程序结束后由系统释放。

5、程序代码区—存放函数体的二进制代码(.text)。

（2）例子程序

//main.cpp

int a = 0;          // 全局初始化区

char *p1;           // 全局未初始化区

main()

{

  int b;            // 栈区

  char s[] = "abc"; // 栈区

  char *p2;         // 栈区

  char *p3 = "123456"; // "123456\0" 在常量区，p3在栈区

  static int c =0;         // 全局（静态）初始化区

  p1 = (char *)malloc(10);

  p2 = (char *)malloc(20); //分配得来的10和20字节的区域就在堆区

  strcpy(p1, "123456");// "123456\0" 放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。

}

4、什么是平衡二叉树？

答：左右子树都是平衡二叉树且左右子树的深度差值的绝对值不大于1

5、堆栈溢出一般是由什么原因导致的？

答：堆栈溢出一般是由循环的递归调用导致的，如果使用大数据结构的局部变量，也可能导致堆栈溢出。

没有回收垃圾资源导致的是内存泄露最后内存耗尽。

注释：堆栈溢出就是不顾堆栈中分配的局部数据块大小，向该数据块写入了过多的数据，导致数据越界，结果覆盖了老的堆栈数据。

6、什么函数不能声明为虚函数？

答：常见的不能声明为虚函数的有：普通函数（非成员函数）；静态成员函数；内联成员函数；构造函数；友元函数。

(1)普通函数（非成员函数）只能被overload，不能被override，因此编译器会在编译时邦定函数。

(2)构造函数不能被继承，因而不能声明为virtual函数；构造函数一般是用来初始化对象，只有在一个对象生成之后，才能发挥多态作用，如果将构造函数声明为virtual函数，则表现为在对象还没有生成的情况下就使用了多态机制，因而是行不通的

(3)内联函数是为了在代码中直接展开，减少函数调用花费的代价，虚函数是为了在继承对象能够准确的执行自己的动作。（再说了，inline函数在编译时被展开，虚函数在运行时动态绑定）

(4)静态成员函数不能被继承，只属于该类

(5)因为C++不支持友元函数的继承，对于没有继承特性的函数没有虚函数的说法。

7、写出float x 与“零值”比较的if语句

答：const float EPSINON = 0.000001;

if ((x <= - EPSINON) && (x >= EPSINON)

   return true;

else

   return false;

不可将浮点变量用“==”或“！=”与数字比较，应该设法转化成“>=”或“<=”此类形式。

如下是错误的写法：

if (x == 0.0)

if (x != 0.0)

8、Internet采用哪种网络协议？该协议的主要层次结构？

答：tcp/ip 应用层/传输层/网络层/数据链路层/物理层

9、Internet物理地址和IP 地址转换采用什么协议？

答：RARP协议（Reverse Address Resolution Protocol），反向地址转换协议：将局域网中某个主机的物理地址转换为IP地址；ARP（Address Resolution Protocol）地址解析协议用于将计算机的网络地址（IP地址32位）转化为物理地址（MAC地址48位）[RFC826]。ARP协议是属于链路层的协议，在以太网中的数据帧从一个主机到达网内的另一台主机是根据48位的以太网地址（硬件地址）来确定接口的，而不是根据32位的IP地址。内核（如驱动）必须知道目的端的硬件地址才能发送数据。当然，点对点的连接是不需要ARP协议的。

10、IP 地址的编码分为哪俩部分？

答:IP地址由两部分组成，网络号和主机号。不过是要和“子网掩码”按位与上之后才能区分哪些是网络位哪些是主机位。

11、用户输入M,N值，从1 至N 开始顺序循环数数，每数到M 输出该数值，直至全部输出。写出C 程序。

循环链表，用取余操作做

#include <stdio.h>

#include<memory>

#include<conio.h>

#define LEN sizeof (struct stu)

struct stu

{

int data;

struct stu *next;

};

stu *line(int n)

{

int sum=1;

stu *head,*pf,*pb;

int i;

for(i=0;i<n;i++)

{

pb=( stu *) malloc(LEN);

pb->data=sum;

if (i==0)

pf=head=pb;

else

pf->next=pb;

if (i==(n-1))

pb->next=head;

else

 pb->next=NULL;

pf=pb;

sum++;

}

return(head);

}

main()

{

int M,N,x,i;

stu *p,*q;

printf("please scanf M and N (M<N)");

scanf("%d %d",&M,&N);

p=line(N);

x=N;

while(x)

{

for(i=1;i<M-1;i++)

{

p=p->next;

}

q=p->next;

printf("%d\n",q->data) ;

p->next = p->next->next;

p=p->next;

free(q) ;

x--;

}

getch();

return 0;

}

12、不能做switch()的参数类型是？

答：switch(expression)中的expression必需是整型的或者是能准确转化为整型的类型。

eg: byte,char,short,int 或者枚举类型。

13、用两个栈实现一个队列的功能？要求给出算法和思路

思路：

假设两个栈 InStack 和OutStack，且都为空。

可以认为栈 InStack为提供入队列的功能，栈 OutStack提供出队列的功能。

入队列： 入栈 InStack

出队列：

1 如果栈OutStack不为空，直接弹出栈 OutStack的数据。

2 如果栈 OutStack为空

2.1 若InStack不为空，则依次弹出栈 InStack的数据，放入栈 OutStack中，再弹出栈 OutStack的数据。

2.2若InStack为空，则队列为空。

C++代码：

#include <stack>

using std::stack;

#include <iostream>

using std::cout;

using std::endl;

template <typename T>

class Queue {

public:

    bool empty( ) const { return m_stack1.empty() && m_stack2.empty();}

    size_t size( ) const { return m_stack1.size()+ m_stack2.size(); }

    void push( const T& x );//append a element to tail

    void pop( );//remove a element from head

private:

    stack<T> InStack;

    stack<T> OutStack;

};

//入队列

template <typename T>

void Queue<T>::push( const T& x )

{

    //入栈InStack

    InStack.push(x);

}

//出队列

template <typename T>

void Queue<T>::pop( )

{ 

    T OutData;

   //如果栈 OutStack 为空：若InStack不为空，则依次弹出栈 InStack 的数据，

    //放入栈 OutStack 中，再弹出栈 OutSatck 的数据；若InStack为空，则队列

    //为空

    if(OutStack.empty())

    {

           while(!InStack.empty())

           {

                  OutStack.push(InStack.top());

                  InStack.pop();

           }

           OutData=OutStack.top();

           cout<<OutData<<endl;//测试出队列

           OutStack.pop();

    }

    //如果栈OutStack 不为空，直接弹出栈 OutStack 的数据。

    else

    {

           OutData=OutStack.top();

           cout<<OutData<<endl;//测试出队列

           OutStack.pop();

    }

}

int main( )

{

    Queue<int> q;

    for( int i = 1; i <= 5; ++i )

        q.push( i );

    q.pop( );

    q.push( 6 );

    q.pop( );

    q.pop( );

    q.push( 7 );

    q.pop( );

    q.pop( );

    q.pop( );

    q.pop( );

      system("pause");

    return 0;

}

--                                                                             

注释：用两个队列实现一个栈的功能

思路：

假设有两个队列m_queue1和m_queue2，且都为空。

入栈：入队列 m_queue1。

1、如果m_queue1不为空，则把m_queue1中的元素依次出队列并存入队列m_queue2中；然后入队元素x进入队列m_queue1中；判断m_queue2是否为空，不为空，则把m_queue2中的元素依次出队列并入队列m_queue1中。这样既可以实现最后进来的元素能够放在对首，从而出队列时最先出队。

出栈：将m_queue1的队头元素出队列即可。

示例代码如下

#include <iostream>

#include <queue>

#include <cassert>

using namespace std;

template <class T>

class Stack {

public:

    bool empty( ) const { return m_queue1.empty() && m_queue2.empty(); }

    size_t size( ) const { return m_queue1.size() + m_queue2.size(); }

    T& top( );

    const T& top( ) const;

    void push( const T& x );

    void pop( );

private:

    queue<T> m_queue1;

    queue<T> m_queue2;

};

template <class T>

T& Stack<T>::top( )

{

    assert( !m_queue1.empty() );

    return m_queue1.front( );

}

template <class T>

const T& Stack<T>::top( ) const 

{

    assert( !m_queue1.empty() );

    return m_queue1.front( );

}

/*

*用队列实现栈的进栈操作：队列m_queue1非空时，把其元素依次出队列

*并压入到队列m_queue2中，将进栈元素加入队列m_queue1中，然后判断

*m_queue2是否为空，不空的话把其元素依次出队列加入到队列m_queue2中

*，这样就可以实现后加入的元素总位于队首，也即后加入的元素总能够先出队列

*，即可成为栈顶元素！

*/

template <class T>

void Stack<T>::push( const T& x )

{

    while( !m_queue1.empty() ) {

           const T& val = m_queue1.front( );

           m_queue1.pop( );

           m_queue2.push( val );

    }

    m_queue1.push( x );

    while( !m_queue2.empty() ) {

           const T& val = m_queue2.front( );

           m_queue2.pop( );

           m_queue1.push( val );

    }

}

template <class T>

void Stack<T>::pop( )

{

    assert( !m_queue1.empty() );

    m_queue1.pop( );

}

int main( )

{

    Stack<int> s;

    for( int i = 1; i <= 5; ++i )

    s.push( i );

    cout << s.top( ) << endl;

    s.pop( );

    s.push( 6 );

    cout << s.top( ) << endl;

    s.pop( );

    cout << s.top( ) << endl;

    s.pop( );

    cout << s.top( ) << endl;

    s.pop( );

    s.push( 7 );

    cout << s.top( ) << endl;

    s.pop( );

    cout << s.top( ) << endl;

    s.pop( );

    cout << s.top( ) << endl;

    s.pop( );

    system("pause");

    return 0;

}

14、在c 语言库函数中将一个字符转换成整型的函数是atol()吗，这个函数的原型是什么？

答：函数名: atol

功能: 把字符串转换成长整型数

用 法: long atol(const char *nptr);

15、软件测试都有那些种类?

答：黑盒：针对系统功能的测试；白合：测试函数功能，各函数接口。

16、指针步长问题？

Eg：unsigned char *p1;//p1是一个指向无符号字符型的指针

unsigned long *p2;//p2是一个指向无符号长整形的指针

p1=(unsigned char *)0x801 000;//把0x80100作为指针的初值

p2=(unsigned long *)0x810 000;//把0x81000作为指针的初值

请问p1+5=？;

p2+5=？;

答：代码分析见注释；

则：p1+5=0x801 000+5*sizeof(unsigned char);

  :  p2+5=0x810 000=5*sizeof(unsigned long);

Eg:如果机器中unsigned char为1字节，unsigned long为4字节；则，p1+5=0x801 005；p2+5=0x810 014；因为前者加1表示指针后移1个字节，后则加1表示后移4个字节。

17、已知一个单向链表的头，请写出删除其某一个结点的算法，要求，先找到此结点，然后删除。

解析：删除运算是指删除单链表的第 i 个结点，即将第 i-1 个元素结点的指针域指向第 i+1 个元素结点。要实现删除，首先要找到第 i 个元素结点前驱结点。

具体算法如下：

Int ListDelete(SLNode *head,int I,DataType *x)

//删除带头结点单链表head的第i(0<=i<=size-1)个结点被删除结//点的数据域值由x带回，删除成功则返回1，失败则返回0

{

SLNode *p,*s;

int  j=-1;

p=head;

while(p->next!=NULL&&p->next->next!=NULL&&j<i-1)

//循环结束时指针p指向第i-1个结点

{

p=p->next;

j++;

}

if(j!=i-1)

{printf(“删除位置出错！”)；return  0；}

s=p->next;

*x=s->data;

p->next=p->next->next;//删除

free(s);//释放指针s所指结点的内存空间

return 1;

}