（第一、二章）
各位大哥见笑了，小弟水平实在太低，做了做书上的题结果不会的太多，所以就把它们写了下来，我坚信大哥们一定都会，但是我觉得有点心得就要和大家分享，所以就斗胆贴出来了，如果觉得还是有点用处，希望大家都能给点回应，激励小弟再接再厉。如果觉得简直弱智，也望大家说出来，我也就不再现眼了！

[1-2]
水平垂直奇偶校验，对于1位数据错，必然使该位数据所在的行和列都发生校验错，所以不但能够发现错误，而且可以通过行和列的交叉点来确定出错的位置。
[1-3]
海明码一般为偶校验。
一般来说，以k表示原信息为长度，以n表示经过编码以后的长度，则r=k/n表示一个纠错编码的编码效率。例如：一个（7，4）循环码的编码效率是r=4/7。
[1-10]
分辨率（即一个屏幕上有多少光点）和灰度（即光点亮度的深浅变化）是显示器的两个重要技术指标，他们决定了所显示图像的质量。
彩色图形显示cga（color graphics adapter）、增强图形显示ega（enhanced graphics adapter）、视频图形显示vga（video graphics adapter）、单色图形显示mga（monochrome graphics adapter），cga在字符方式下，每屏可以显示25x80个字符。
[1-11]
在中断处理过程中，中断屏蔽功能可以起改变中断优先级的作用。
每次中断发生后，保护现场必须保护少量工作寄存器，同时选择性保护进程控制块。
中断可分为内部中断（或软件中断）和外部中断（或硬件中断）。前者包括溢出中断，越界中断，中断指令等；后者包括设备运行结束中断、时钟中断、控制台中断等。一般硬件中断的优先级高于软件中断。
[1-25]
存贮器的可寻址单元数n与存储器的地址宽度a的关系式：n=2^a。
问题：假设某计算机具有1m的内存，并且按字节编址，为使4字节组成的字能从存储器中一次读出，要求存放在存储器中的字边界对齐，一个字的地址码应______。
答案：最低两位为00
原因：
address :  0         1          2          3           4 .....
             byte1  byte2   byte3   byte4
address 总能被4整除
所以address的低两位为00  (0x....0,4,8,c)
0x0 = 0000
0x4 = 0100
0x8 = 1000
0xc = 1100
[2-1]
语言的文法分成四种类型，即0型（短语文法）、ⅰ型（上下文有关文法）、ⅱ型（上下文无关）、ⅲ型（正则文法）。与这四类文法对应的自动机分别为图灵机、线性有限自动机、非确定的下推自动机、有限自动机。在这四类文法中，常用ⅱ型文法来描述程序设计语言的语法，ⅲ型文法来描述程序设计语言的词法。由定义可知ⅲ型文法必为ⅱ型文法。ⅲ型文法对应的识别装置为有限自动机，有限自动机分确定的有限自动机和非确定的有限自动机，可证明对任一非确定的有限自动机都存在一个确定的有限自动机与之等价（两个有限自动机等价是说二者是别的语言相同）。
[2-4]
一些程序设计语言可以子程序递归调用，通常使用一个下推栈存放子程序的调用纪录，调用纪录包括：
1、全局量存储区域的开始地址：子程序不仅可用其内部的局部量和临时变量，也可使用全局量；
2、调用点所在子程序的调用纪录首地址；
3、调用点的返回地址；
4、形式参数和实在参数的通讯区域；
5、返回值；
6、本子程序的局部量和临时变量存储区域等。
[2-5]
语法分析方法大体上可分成自上而下和自下而上两种。自下而上分析法，是从输入符号串开始逐步进行归约，直至归约成文法的起始符号。自上而下分析法，则是从文法的起始符号开始反复使用产生式进行推导直至推导出输入符号串。自下而上分析有规范归约分析法、算符优先分析法等，算符优先分析法是不含ε产生式的算符文法。自上而下分析方法有ll(1)分析法，递归子程序法等。自顶而下分析通常要求文法的产生式不含左递归，否则会使分析程序死循环。
[2-8]
在程序设计语言中，一般有两类子程序：过程和函数。一个过程通常有四个要素组成：过程名、一组称为形式参数的名字、过程体和过程中使用的全局量。
[2-12]
许多编译程序采用了一种与“3地址指令”近似的四元式作为中间代码。形式为：
算符   左操作数    右操作数    结果
[2-14]
x+a*(y-b)-z/f的前缀表示为-+x*a-yb/zf，后缀表示为xayb-*+zf/-。
方法：把表达式转化为二叉树，因为先加后减所以可以表示为(x+a*(y-b))-z/f，所以减号应为二叉树的根。在前序遍历这颗树就可得到前缀表示，后序遍历可得后缀表示。
[2-15]
巴克斯范式（dnf）可以用来描述程序设计语言的语法，最早用于算法语言algol60，后进行了扩充。常用符号为：
::= 表示定义为；
<> 表示非终结符；
[] 表示可以出现0或1次；
{} 表示可以出现任意次；
| 表示或者。

（第三章）
[3-4]
内、外存之间交换信息的基本单位有两种：一种是以作业为单位，一个作业在内存中运行一个时间片后，处理机就去运行另一个作业，如果那个作业不在内存，就将它整个调入内存，内存没空，则将内存中的某个作业整个调出，这种技术叫做SWAPPING技术，它要求作业的地址空间要小于等于内存的可用空间。另一种交换技术是在作业内部做部分信息的调入调出，通常将作业地址空间分页（或段），交换以页（段）为单位，我们称这种交换技术为虚拟存储技术。虚拟存储技术有请求页式、段式、段页式等实现方法。虚拟存储技术允许用户运行比实际内存大得多的程序。
虚拟存储技术中采用的淘汰策略的理论基础是程序的局部性原理，据此，操作系统可以根据工作集来改善系统的性能，它是一个进程在定长的执行时间区间内涉及到的页面集合。
[3-7]
在操作系统中，处理机管理部分由作业管理和进程管理两部分组成。作业管理是把作业流分成提交、后备、运行、完成4个状态。进程管理是把进程分成就绪、运行、阻塞3个基本状态。作业由提交状态到后备状态由假脱机（spooling）处理程序完成，由后备状态到运行状态由作业调度程序完成，进程由就绪状态到执行状态由进程调度程序完成，由执行状态到阻塞状态或就绪状态由进程调度程序完成，由运行状态到完成状态由作业调度程序完成。用户进程的祖先进程是由作业调度程序建立的。
[3-11][3-16]
操作系统中，对付死锁有两种策略，一种是在死锁发成前采用的预防和避免策略，另一种是在死锁发成后采用的检查与恢复策略。前者付出的代价大于后者。
产生死锁的基本原因是系统资源不足和进程推进顺序非法。
产生死锁的4个必要条件是互斥条件、请求和保持条件、不剥夺条件，环路等待条件。
[3-14]
存储分配解决多道作业主存的划分问题。为了实现静态和动态存储分配，需要采用地址重定位，即把逻辑地址变换为物理地址。静态重定位由连接装入程序实现，动态重定位由硬件地址变换机构实现。
[3-17]
有结构的记录文件可分为：顺序文件、索引文件、直接文件、索引顺序文件。

（第四章）
[4-1]
关系代数的最基本操作有并、差、笛卡尔积、选择、投影。
视图是从一个或几个基本表（或视图）导出的表。视图所对应的数据不是实际存储在数据库中，在数据库中只存放视图的定义。
在关系模型中，一般有实体完整性规则和引用完整性规则。实体完整性规则是主键值不能是空值。引用完整性规则要求“不允许引用不存在的实体”，若关系R的属性A为外关键字（设为关系S的主关键字），则对于R中每个元组在A上的值或均取空值，或等于S的某个元组的主关键字值。
SQL语言时高度非过程化语言，用户不必了解存取路径，存取路径的选择和SQL语言的操作过程由系统自动完成。
嵌入式的数据库语言构成的应用程序环境包括主语言（如程序设计语言C）和数据子语言（如SQL），后者只能处理表，前者能处理记录和域，游标机制起这两种语言的桥梁作用。
事务（Transaction）是数据库运行的基本工作单位。如果一个事务执行成功，则全部更新提交；如果一个事务执行失败，则所做过的全部更新被恢复原状。这样保持了数据库处于一致性状态。在数据库中，把未提交的随后又被撤消的更新数据称为“脏数据”，用户对“脏数据”的读出是由于并发控制未做好，由操作异常造成的。
在数据库中由于为了实现快速检索某些数据，允许数据有一定的冗余。实际进行数据库设计时，不可能完全消除数据冗余，只能尽量减少数据的冗余度。
[4-2]
规范理论中，分解关系模式主要是消除关系模式中多余的数据相关性。
[4-3]
数据库系统中，数据独立性分为物理数据独立性和逻辑数据独立性。
“封锁“机制是解决并发操作的，“授权”是数据库系统采用的安全措施。
[4-4]
在关系模型中，一个数据库模式是关系模式的集合，对于同一个应用问题，可以选用不同的关系模式集做为数据库模式。为了区分优劣，把关系模式分成不同等级的范式，满足不同范式的关系模式在减少数据冗余度和消除存储异常等方面性能相差很大。
第一范式（1NF）：关系模式R的每个关系r的属性值是不可分解的，则称R是1NF模式。
第二范式（2NF）：若R是1NF模式，且每个非主属性完全函数依赖于各个键，则称R是2NF模式。
第三范式（3NF）：若R是2NF模式，且每个非主属性传递都不依赖于任何键，则称R是3NF模式。
通常，1NF和2NF未消除部分函数依赖和传递依赖关系，其数据冗余度较大，存储异常较多。
[4-6]
网状模型用有向图来表示实体类型及实体间联系，搜索数据时，可以从任意节点开始沿任何路径搜索。
层次模型用树来表示实体类型及实体间联系。
关系模型用二维表来表示实体类型及实体间联系。
[4-8][4-11]
关系型数据库语言SQL基本的使用方式有两种。单独使用，称为交互式语言，供交互环境下的终端用户使用。SQL语句还可用在应用程序中，SQL语句可直接嵌入在程序中使用，这就是嵌入式SQL，这时，相应的高级语言称为宿主语言。
从SQL数据库的体系结构角度来看，用户可以用SQL语言的语句，对视图和基本表进行查询等操作。
关系数据库的数据操作语言主要包括检索和更新操作。检索又称查询，是用SELECT语句；更新包括插入、删除和修改，使用INSERT、DELETE、UPDATE等。
数据库全新组织只是移动或组合而已。因此对数据库重新组织的方法基本上是复制、排序和连接3种。
[4-13]来表示实体类型及实体间联系。
数据库恢复的基本原则就是冗余。实现方法：
1、定期将数据库做备份；
2、在进行事务处理时，对数据更新（插入、删除、修改）的全部有关内容写入日志文件；
3、在系统正常运行时，按一定的时间间隔，设立检查点文件。把内存缓冲区内容还未写入到磁盘中去的有关状态记录到检查点文件中；
4、发生故障时，根据现场数据内容、日志文件的故障前映像和检查点文件来恢复系统的状态。
[4-14]
关系模式是一个关系的属性名序列，也就是一个关系的型。
一个关系数据库系统的逻辑结构是所有有关关系模式的集合。关系数据库模式是数据的型的表示，关系数据库则是数据的值的表示。
[4-15]
数据库系统通常包括数据库、硬件、软件、人员组成。

（第五章）
[5-1]
软件的维护的费用一般占软件生存周期全部费用的60-80%左右。
软件的测试的费用已超过软件开发费用的30%。
[5-2]
软件的测试过程分为单元测试、组装测试、确认测试。单元测试也称模块测试，在编码阶段完成，多采用白盒测试法，其测试计划是在详细设计阶段制定的；组装测试是按照概要设计阶段设计的程序结构图将各个模块装配在一起进行测试，一般采用黑盒法，其测试计划是在概要设计阶段制定的；确认测试是依需求规格说明书为依据，检查软件的功能、性能及其他特征是否与用户的需求一致，通常采用黑盒测试法，其测试计划是在需求分析阶段制定的。
[5-3]
软件测试的目的是尽可能发现软件中的错误，不是证明软件是正确的。
测试用例的设计方法有两种：黑盒测试方法和白盒测试方法。黑盒测试常用的有等价类划分、边值分析、错误猜测、因果图等技术。白盒测试常用的技术是逻辑覆盖，主要的覆盖标准有六种：语句覆盖、判定覆盖、条件覆盖、判定/条件覆盖、条件组合覆盖、路径覆盖。语句覆盖是指选择足够的测试用例，使得运行这些测试用例时，被测程序的每一个语句至少执行一次，其覆盖标准无法发现判定中逻辑运算的错误；判定覆盖是指选择足够的测试用例，使得运行这些测试用例时，每个判定的所有可能结果至少出现一次，但若程序中的判定是有几个条件联合构成时，它未必能发现每个条件的错误；条件覆盖是指选择足够的测试用例，使得运行这些测试用例时，判定中每个条件的所有可能结果至少出现一次，但未必能覆盖全部分支；判定/条件覆盖是使判定中每个条件的所有可能结果至少出现一次，并且每个判定本身的所有可能结果也至少出现一次；条件组合覆盖是使每个判定中条件结果的所有可能组合至少出现一次，因此判定本身的所有可能解说也至少出现一次，同时也是每个条件的所有可能结果至少出现一次；路径覆盖是每条可能执行到的路径至少执行一次；其中语句覆盖是一种最弱的覆盖，判定覆盖和条件覆盖比语句覆盖强，满足判定/条件覆盖标准的测试用例一定也满足判定覆盖、条件覆盖和语句覆盖，条件组合覆盖是除路径覆盖外最强的，路径覆盖也是一种比较强的覆盖，但未必考虑判定条件结果的组合，并不能代替条件覆盖和条件组合覆盖。
[5-4]
在软件工程的设计阶段中，有三种常用的设计方法：结构化设计（SD）、Jackson方法和Parnas方法。SD方法侧重于模块要相对独立，并且功能单一，使块间联系弱，块内联系强；Jackson方法则是由数据结构导出模块结构；Parnas法的主要思想信息隐蔽。
[5-7]
系统定义明确后，应该对系统的可行性进行分析研究。包括：技术可行性、经济可行性和社会可行性等方面。
[5-8]
软件工程技术应该遵循分解、一致性、确定行及抽象和信息隐蔽的原则。
软件工程包括3个要素：方法、工具和过程。
[5-11]
较全面地评价软件质量，应该从易维护性、可靠性、效率和易理解性方面考虑。
[5-12][5-15]
模块独立性要追求低耦合高内聚（耦合是模块间的关系，内聚是模块内的关系）。
下面按它们的耦合度从低到高的顺序一次介绍。
1、非直接耦合。非直接耦合是指两个模块没有直接的联系，它们中的任何一个都不依赖于对方而独立工作。
2、数据耦合。数据耦合是指两个模块借助于参数表传递简单数据。
3、标记耦合。当一个数据结构的一部分（如记录的一部分）借助于模块接口被传递时就发生标记耦合。
4、控制耦合。控制耦合指两个模块间传递的信息中包含用于控制模块命令逻辑的控制信息。
5、外部耦合。当模块与软件以外的环境有关时就发生外部耦合。
6、公共耦合。多个模块引用同一全局数据区的模式称公共耦合。
7、内容耦合。内容耦合指两个模块之间出现的三种之一：一个模块之际访问另一个模块的内部数据；一个模块不通过正常入口转到另一个模块的内部；一个模块有多个入口。
模块的内聚种类通常分为七种，按内聚度从低到高的次序依次为：偶然内聚、逻辑内聚、瞬时内聚、过程内聚、通信内聚、顺序内聚、功能内聚。
[5-16]
OMT是一种对象建模技术，它定义了三种模型，它们分别是对象模型、动态（ER）模型和功能模块。对象模型描述系统中对象的静态结构、对象间的关系、对象的属性和操作；动态模型描述系统中于时间和操作顺序有关的系统特征，表示瞬时的行为上的系统的“控制”特征，通常用状态图表示；功能模型描述与值的变换有关的系统特征----功能、映射、约束和函数依赖，通常用数据流图表示。
[5-17]
DFD就是面向数据流分析方法的描述工具。在画分层DFD时，应该注意保持父图与其子图之间的平衡。DFD中从系统的输入流到系统的输出流的一连串连续变换

形成一种信息流，这种信息流可分为变换流和事务流。

（第六、七章）
[6-3]
Ethernet与Internet连接时要用到地址转化协议ARP。
[6-4]
中继器、集线器（主要用于星型拓扑）属于OSI物理层；
网桥、交换机属于OSI数据链路层；
路由器属于OSI网络层；
网关属于OSI应用层。
[6-6]
计算机网络具有良好的安全性，应当由真实性、可靠性、完整性、实用性和占有性、保密性指标组成。
[6-7]
把若干台计算机合成一个现代计算机网络机，可以实现下列3个基本功能：
1、计算机之间和计算机用户之间的互相通信与交往；
2、共享资源，包括硬件资源、软件资源和数据；
3、计算机之间或计算机用户之间的协同合作。
[6-10]
局域网特征，也就是硬件特性、资源分配策略和用户特性的特征。
[6-12]
在两个实体间控制数据交换的规则的集合称为协议或规程。协议的关键成分是：语法（Syntax），包括数据格式、编码及信号电平等；语义（Semantics），包括用于协调和差错处理的控制信息；定时（Timing），包括速度匹配和排序。
[7-2]
WAV文件的字节数/每秒 = 采样频率（HZ）* 量化位数（位）* 声道数 / 8
MIDI是一种乐器数字接口，它是该领域国际上的一个通信标准。
[7-3]
色彩光是由亮度、对比度和饱和度这3个特征的综合效果，通常把色调和饱和度通称为色度。
颜色光都是可以由红、绿、蓝3种颜色光按照不同比例相配而成。
[7-6]
无闪烁显示动画需要每秒25帧以上，如果640x480的有2^24种彩色的图像占用大约7.4MB，要无闪烁显示10s，需要大概：
7.4 x 25 x 10 = 1850MB的存储空间，还需要有极高通道数据传送率。所以数据压缩技术是多媒体计算机的关键技术之一。
目前公认的关于压缩编码的国际标准是：用于多灰度静止图像的JPEG标准；用于电视电话/会议电视的Px64KB/s标准；用于数字存储媒体运动图像的MPEG标准。
[7-10]
交互式点是最常用的是节目间的交互，即点播电视技术（VOD）系统，典型的VOD系统主要由视频服务器、编码器/路由器、计算机和机顶盒组成。

续（排序）

小弟愚笨，对排序、查找和算法等程序题，不能一眼看穿，不得不敲出来，调试着程序才看的懂，惭愧惭愧，下面是我写的排序程序总结，如果有哪位和小弟水平相当，偏偏又想知道这究竟，下面的程序可供大家调试用。环境：win2000中文+VC++6.0。
如果有不对的地方，还请哥哥们指出，以免贻笑大方。

// store.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

void InsertSort(int *store); //直接插入排序函数
void ShellSort(int *store);  //希尔排序函数
void PopSort(int *store);  //冒泡排序函数
void CallQuickRecursion(int *store);  //调用递归快速排序函数
void QuickRecursion(int *store, int low, int high); //快速排序函数----递归
void CallQuickNoRecursion(int *store); //调用非递归快速排序函数
void QuickNoRecursion(int *current, int n);  //快速排序函数----非递归
void SelectSort(int *store); //简单选择排序函数
void HeapSort(int *store);  //堆排序函数
void HeapAdjust(int *current, int s, int m);

#define N 40

int main(int argc, char* argv[])
{
 int store[11] = {0, 49, 38, 65, 97, 76, 13, 27, 49, 50, 77};//待排数列

//打印待排数列
 printf("从小到大排序\n");
 printf("未排序数列为：\n");
 for (int i=1; i<=10; i++)
  printf(" %d ", store[i]);
 printf("\n");
 //排序方法
 InsertSort(store); //直接插入排序
 ShellSort(store); //希尔排序
 PopSort(store);  //冒泡排序
 CallQuickRecursion(store);//调用递归快速排序
 CallQuickNoRecursion(store);//调用非递归快速排序
 SelectSort(store); //简单选择排序
 HeapSort(store); //堆排序
 return 0;
}

void InsertSort(int *store)
{
 int i=0, j=0; 
 //复制数组
 int current[11];
 for(i=0; i<=10; i++)
  current[i] = store[i];
 printf("直接插入排序:\n");
 //开始排序
 for(i=2; i<=10; i++)
 {
  if(current[i-1] > current[i])
  {
   current[0] = current[i];
   for(j=i-1; current[j]>current[0]; j--)
    current[j+1] = current[j];
   current[j+1] = current[0];
  }
 }
 //打印数组
 for(i=1; i<=10; i++)
  printf(" %d ", current[i]);
 printf("\n");
}

void ShellSort(int *store)
{
 int i=0, j=0, k=0;
 //复制数组
 int current[11];
 for(i=0; i<=10; i++)
  current[i] = store[i];
 printf("希尔排序:\n");
 //定义排序增量数组
 int increase[4] = {0, 1, 3, 5};
 //开始排序
 for(k=3; k>=1; k--)
 {
  int count=increase[k];
  i=0, j=0;
  for(i=count+1; i<=10; i++)
  {
   if(current[i-count] > current[i])
   {
    current[0] = current[i];
    for(j=i-count; j>0&&(current[j]>current[0]); j-=count)
     current[j+count] = current[j];
    current[j+count] = current[0];
   }
  }
 }
 //打印数组
 for(i=1; i<=10; i++)
  printf(" %d ", current[i]);
 printf("\n");
}

void PopSort(int *store)
{
 int i=0;
 //复制数组
 int current[11];
 for(i=0; i<=10; i++)
  current[i] = store[i];
 printf("冒泡排序:\n");
 //开始排序
 int j, p, h;
 for(h=10; h>1; h=p)
 {
  for(p=j=1; j<h; j++)
   if(current[j]>current[j+1])
   {
    current[0] = current[j];
    current[j] = current[j+1];
    current[j+1] = current[0];
    p = j;
   }
 }
 //打印数组
 for(i=1; i<=10; i++)
  printf(" %d ", current[i]);
 printf("\n");
}

void CallQuickRecursion(int *store)
{
 //复制数组
 int current[11];
 for(int i=0; i<=10; i++)
  current[i] = store[i];
 printf("快速排序----递归:\n");
 QuickRecursion(current, 1, 10);//快速排序----递归
 //打印数组
 for(i=1; i<=10; i++)
  printf(" %d ", current[i]);
 printf("\n");
}

void QuickRecursion(int *current, int low, int high)
{
 int i,j;
 if(low<high)
 {
  i=low; j=high; current[0]=current[low];
  while(i<j)
  {
   while(i<j&¤t[j]>current[0]) j--;
   if(i<j) current[i++]=current[j];
   while(i<j&¤t[i]<=current[0]) i++;
   if(i<j) current[j--]=current[i];
  }
  current[i]=current[0];
  QuickRecursion(current, low, i-1);
  QuickRecursion(current, i+1, high);
 }
}

void CallQuickNoRecursion(int *store)
{
 //复制数组
 int current[11];
 for(int i=0; i<=10; i++)
  current[i] = store[i];
 printf("快速排序----非递归:\n");
 QuickNoRecursion(current, 10);//快速排序----非递归
 //打印数组
 for(i=1; i<=10; i++)
  printf(" %d ", current[i]);
 printf("\n");
}

void QuickNoRecursion(int *current, int n)
{
 int i, j, low, high;
 int stack[N][2];
 stack[0][0] = 1;
 stack[0][1] = n;
 int top = 1;
 while(top>0)
 {
  top--;
  low = i = stack[top][0];
  high = j = stack[top][1];
  current[0] = current[low];
  while(i<j)
  {
   while(i<j&¤t[j]>current[0]) j--;
   if(i<j) current[i++] = current[j];
   while(i<j&¤t[i]<current[0]) i++;
   if(i<j) current[j--] = current[i];
  }
  current[i] = current[0];
  if(i-1>low)
  {
   stack[top][0] = low;
   stack[top][1] = i-1;
   top++;
  }
  if(high>i+1)
  {
   stack[top][0] = i+1;
   stack[top][1] = high;
   top++;
  }
 }
}

void SelectSort(int *store)
{
 int i, j, k;
 //复制数组
 int current[11];
 for(i=0; i<=10; i++)
  current[i] = store[i];
 printf("简单选择排序:\n");
 for(i=1; i<=10; i++)
 {
  for(k=i, j=i+1; j<=10; j++)
   if(current[j]<current[k]) k = j;
  if(k!=i)
  {
   current[0] = current[i];
   current[i] = current[k];
   current[k] = current[0];
  }
 }
 //打印数组
 for(i=1; i<=10; i++)
  printf(" %d ", current[i]);
 printf("\n");
}

void HeapSort(int *store)
{
 int i;
 //复制数组
 int current[11];
 for(i=0; i<=10; i++)
  current[i] = store[i];
 printf("堆排序:\n");

for(i=5; i>0; i--)
  HeapAdjust(current, i, 10);
 for(i=10; i>1; i--)
 {
  current[0] = current[1];
  current[1] = current[i];
  current[i] = current[0];
  HeapAdjust(current, 1, i-1);
 }
 //打印数组
 for(i=1; i<=10; i++)
  printf(" %d ", current[i]);
 printf("\n");
}

void HeapAdjust(int *current, int s, int m)
{
 int j;
 int rc = current[s];
 for(j=2*s; j<=m; j*=2)
 {
  if(j<m&¤t[j]<current[j+1]) ++j;
  if(rc>=current[j]) break;
  current[s] = current[j];
  s = j;
 }
 current[s] = rc;
}

结果如下：

从小到大排序
未排序数列为：
 49  38  65  97  76  13  27  49  50  77
直接插入排序:
 13  27  38  49  49  50  65  76  77  97
希尔排序:
 13  27  38  49  49  50  65  76  77  97
冒泡排序:
 13  27  38  49  49  50  65  76  77  97
快速排序----递归:
 13  27  38  49  49  50  65  76  77  97
快速排序----非递归:
 13  27  38  49  49  50  65  76  77  97
简单选择排序:
 13  27  38  49  49  50  65  76  77  97
堆排序:
 13  27  38  49  49  50  65  76  77  97

http://oldchild.nbc.net.cn/jsjsj/spks/ksjy/rrfxzj.htm