基因表达式编程算法原理与应用

A. 正则表达式原理

首先先讲解下正则表达式的基础知识：

1.字符串的组成

对于字符串”123“而言，包括三个字符四个位置。如下图所示：

2.占有字符和零宽度

正则表达式匹配过程中，如果子表达式匹配到东西，而并非是一个位置，并最终保存到匹配的结果当中。这样的就称为占有字符，而只匹配一个位置，或者是匹配的内容并不保存到匹配结果中，这种就称作零宽度，后续会讲到的零宽度断言等。占有字符是互斥的，零宽度是非互斥的。也就是一个字符，同一时间只能由一个子表达式匹配，而一个位置，却可以同时由多个零宽度的子表达式匹配。

3.控制权和传动

正则表达式由左到右依次进行匹配，通常情况下是由一个表达式取得控制权，从字符串的的某个位置进行匹配，一个子表达式开始尝试匹配的位置，是从前一子表达匹配成功的结束位置开始的（例如：（表达式一）（表达式二）意思就是表达式一匹配完成后才能匹配表达式二，而匹配表达式二的位置是从表达式一的位置匹配结束后的位置开始）。如果表达式一是零宽度，那表达式一匹配完成后，表达式二匹配的位置还是原来表达式以匹配的位置。也就是说它匹配开始和结束的位置是同一个。

举一个简单的例子进行说明：正则表达式：123

源数据：123

讲解：首先正则表达式是从最左侧开始进行匹配，也就是位置0处进行匹配，首先得到控制权的是正则表达式中的“1”，而不是源数据中的“1”，匹配源数据中的“1”，匹配成功，将源数据的“1”进行保存到匹配的结果当中，这就表明它占有了一个字符，接下来就将控制权传给正则表达式中的“2”，匹配的位置变成了位置1，匹配源数据中的“2”，匹配成功，将控制权又传动给了正则表达式的“3”，这时候匹配的位置变成了位置2，这时候就会将源数据中的“3”进行匹配。又有正则表达式“3”进行传动控制权，发现已经到了正则表达式的末尾，正则表达式结束。

B. 高分求遗传算法程序

遗传算法作为一种快速有效的寻优算法，在工业控制、经济决策和交通规划等居多领域得到广泛应用。其特点就是其不同于传统的搜索寻优方式而是模拟自然界生物进化过程，通过基因的变异交叉重组使整体得到进化，不断的进化最终得到最优的组群，即最优解。
下面是一个具体实例，是小可在别人程序的基础上改写优化而成。这里首先要建立数学模型，即问题的数学公式描述，数学建模是一门对数学能力有相当要求的课程，一个人的数学能力往往决定其从事工作的层次。下面的程序是求多项式y=x^6-10x^5-26x^4+344x^3+193x^2-1846x-1680在区间[-8,8]的最小值，误差不超过0.001。对于这个复杂的多项式，可先用matlab绘制函数的大概曲线，确认函数的最小值大概处于[-8,8]之间，再用本程序求出精确解。
程序已在Dev-c++下运行通过，结果正确。
如有什么疑问，给我消息。

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

#define SUM 20 /* 总共的染色体数量 */
#define MAXloop 1200 /* 最大循环次数 */
#define error 0.01 /* 若两次最优值之差小于此数则认为结果没有改变 */
#define crossp 0.7 /* 交叉概率 */
#define mp 0.04 /* 变异概率 */

struct gen /* 定义染色体结构 */
{
int info;
double suitability;
};
struct gen gen_group[SUM];/* 定义一个含有20个染色体的组 */
struct gen gen_new[SUM];

struct gen gen_result; /* 记录最优的染色体 */
int result_unchange_time; /* 记录在error前提下最优值未改变的循环次数 */

struct log /* 形成链表，记录每次循环所产生的最优的适应度 */
{
double suitability;
struct log *next;
}llog,*head,*end;
int log_num; /* 链表长度 */

void initiate(); /*初始化函数*/
void evaluation(int flag); /*适应度评估和排序函数*/
void cross(); /*交叉函数*/
void selection(); /*选择函数*/
int record(); /*记录每次最优解和判断循环是否终止*/
void mutation(); /*变异函数*/
void showresult(int); /*显示结果*/

int randsign(double p); /*按概率p产生0,1随机数，p表示产生值1的概率*/
int randbit(int i,int j);/*产生i,j间的随机整数*/
int randnum(); /*随机产生14个位(基因)组成的染色体*/
int convertionD2B(double x); /*编码*/
double convertionB2D(int x); /*解码*/
int createmask(int a); /*交叉操作*/

int main()
{
int i,flag;
flag=0;
initiate();
evaluation( 0 );
for( i = 0 ; i < MAXloop ; i++ )
{
cross();
evaluation( 1 );
selection();
if( record() == 1 )
{
flag = 1;
break;
}
mutation();
}
showresult( flag );
system("pause");
return 0
}

void initiate()
{
int i , stime;
long ltime;
ltime=time(NULL);
stime=(unsigned)ltime/2;
srand(stime);
for( i = 0 ; i < SUM ; i++ )
{
gen_group[i].info = randnum();
}
gen_result.suitability=1000;
result_unchange_time=0;
head=end=(struct log *)malloc(sizeof(llog));
if(head==NULL)
{
printf("\n内存不够！\n");
exit(0);
}
end->next = NULL;
log_num = 1;
}

void evaluation(int flag)
{
int i,j,k;
struct gen *genp;
int gentinfo;
double gentsuitability;
double x;
if( flag == 0 )
genp = gen_group;
else genp = gen_new;
for(i = 0 ; i < SUM ; i++)/* 计算各染色体对应的表达式值 */
{
x = convertionB2D( genp[i].info );
genp[i].suitability = x*(x*(x*(x*(x*(x-10)-26)+344)+193)-1846)-1680;
}
for(i = 0 ; i < SUM - 1 ; i++)/* 按表达式的值进行排序 */
{ k=i;
for(j = i + 1 ; j < SUM ; j++)
if( genp[i].suitability > genp[j].suitability ) k=j;
if( k!=i )
{
gentinfo = genp[i].info;
genp[i].info = genp[k].info;
genp[k].info = gentinfo;

gentsuitability = genp[i].suitability;
genp[i].suitability = genp[k].suitability;
genp[k].suitability = gentsuitability;
}
}
}

void cross()
{
int i , j , k ;
int mask1 , mask2;
int a[SUM];
for(i = 0 ; i < SUM ; i++) a[i] = 0;
k = 0;
for(i = 0 ; i < SUM ; i++)
{
if( a[i] == 0)
{
for( ; ; )/* 随机找到一组未进行过交叉的染色体与a[i]交叉 */
{
j = randbit(i + 1 , SUM - 1);
if( a[j] == 0) break;
}
if(randsign(crossp) == 1)
{
mask1 = createmask(randbit(0 , 14-1));
mask2 = ~mask1;
gen_new[k].info = (gen_group[i].info) & mask1 + (gen_group[j].info) & mask2;
gen_new[k+1].info=(gen_group[i].info) & mask2 + (gen_group[j].info) & mask1;
k = k + 2;
}
else
{
gen_new[k].info=gen_group[i].info;
gen_new[k+1].info=gen_group[j].info;
k=k+2;
}
a[i] = a[j] = 1;
}
}
}

void selection()
{
int i , j , k;
j = 0;
i = SUM/2-1;
if(gen_group[i].suitability < gen_new[i].suitability)
{
for(j = 1 ; j < SUM / 2 ; j++)
{
if(gen_group[i+j].suitability > gen_new[i-j].suitability)
break;
}
}
else
if(gen_group[i].suitability>gen_new[i].suitability)
{
for(j=-1;j>-SUM/2;j--)
{
if(gen_group[i+j].suitability<=gen_new[i-j].suitability)
break;
}
}
for(k=j;k<SUM/2+1;k++)
{
gen_group[i+k].info = gen_new[i-k].info;
gen_group[i+k].suitability = gen_new[i-k].suitability;
}
}

int record()
{
double x;
struct log *r;
r=(struct log *)malloc(sizeof(llog));
if(r==NULL)
{
printf("\n内存不够！\n");
exit(0);
}
r->next = NULL;
end->suitability = gen_group[0].suitability;
end->next = r;
end = r;
log_num++;

x = gen_result.suitability - gen_group[0].suitability;
if(x < 0)x = -x;
if(x < error)
{
result_unchange_time++;
if(result_unchange_time >= 20)return 1;
}
else
{
gen_result.info = gen_group[0].info;
gen_result.suitability = gen_group[0].suitability;
result_unchange_time=0;
}
return 0;
}

void mutation()
{
int i , j , k, m;
double x;
double gmp;
int gentinfo;
double gentsuitability;
gmp = 1 - pow(1 - mp , 11);/* 在基因变异概率为mp时整条染色体的变异概率 */
for(i = 0 ; i < SUM ; i++)
{
if(randsign(gmp) == 1)
{
j = randbit(0 , 14);
m = 1 << j;
gen_group[i].info = gen_group[i].info^m;
x = convertionB2D(gen_group[i].info);
gen_group[i].suitability = x*(x*(x*(x*(x*(x-10)-26)+344)+193)-1846)-1680;
}
}
for(i = 0 ; i < SUM - 1 ; i++)
{ k=i;
for(j = i + 1 ; j < SUM ; j++)
if(gen_group[i].suitability > gen_group[j].suitability) k=j;
if(k!=i)
{
gentinfo = gen_group[i].info;
gen_group[i].info = gen_group[k].info;
gen_group[k].info = gentinfo;

gentsuitability = gen_group[i].suitability;
gen_group[i].suitability = gen_group[k].suitability;
gen_group[k].suitability = gentsuitability;
}
}
}

void showresult(int flag)/* 显示搜索结果并释放内存 */
{
int i , j;
struct log *logprint,*logfree;
FILE *logf;
if(flag == 0)
printf("已到最大搜索次数，搜索失败！");
else
{
printf("当取值%f时表达式达到最小值为%f\n",convertionB2D(gen_result.info),gen_result.suitability);
printf("收敛过程记录于文件log.txt");
if((logf = fopen("log.txt" , "w+")) == NULL)
{
printf("Cannot create/open file");
exit(1);
}
logprint=head;
for(i = 0 ; i < log_num ; i = i + 5)/* 对收敛过程进行显示 */
{
for(j = 0 ; (j < 5) & ((i + j) < log_num-1) ; j++)
{
fprintf(logf , "%20f" , logprint->suitability);
logprint=logprint->next;
}
fprintf(logf,"\n\n");
}
}
for(i = 0 ; i< log_num ; i++)/* 释放内存 */
{
logfree=head;
head=head->next;
free(logfree);
}
fclose(logf);
getch();
}

int randsign(double p)/* 按概率p返回1 */
{
if(rand() > (p * 32768))
return 0;
else return 1;
}
int randbit(int i, int j)/* 产生在i与j之间的一个随机数 */
{
int a , l;
l = j - i + 1;
a = i + rand() * l / 32768;
return a;
}
int randnum()
{
int x;
x = rand() / 2;
return x;
}
double convertionB2D(int x)
{
double y;
y = x;
y = (y - 8192) / 1000;
return y;

}
int convertionD2B(double x)
{
int g;
g = (x * 1000) + 8192;
return g;
}
int createmask(int a)
{
int mask;
mask=(1 << a) - 1;
return mask;
}

C. 基因表达式序列排序

基因表达式的顺式作用元件包括以下成分:
启动子 结构基因 RNA聚合酶 转录因子

用传统基因表达式编程(GEP)适应度机制挖掘函数关系容易受到噪声干扰,导致结果失真 为此做了如下探索:①借鉴生物具有的“趋利避害”天性,提出了GEP的“弱适应模型”,以实现在含噪声的数据集上挖掘函数关系;②提出新概念“带内集”、“带外集”并用于划分训练数据集;③设计了在弱适应模型下基于相对误差计算适应度的算法RE FA ;④用详尽的实验验证了REFA的有效性,当测量数据的噪声率为3 33%时,与传统方法相比,REFA方法的成功率提高了3倍,产生结果的平均相对误差从7 899%降低到2 32 0 %

D. 求基因表达式算法C语言或C++的源程序代码

基因表达式的顺式作用元件包括以下成分:
启动子 结构基因 RNA聚合酶 转录因子

用传统基因表达式编程(GEP)适应度机制挖掘函数关系容易受到噪声干扰,导致结果失真 为此做了如下探索:①借鉴生物具有的“趋利避害”天性,提出了GEP的“弱适应模型”,以实现在含噪声的数据集上挖掘函数关系;②提出新概念“带内集”、“带外集”并用于划分训练数据集;③设计了在弱适应模型下基于相对误差计算适应度的算法RE FA ;④用详尽的实验验证了REFA的有效性,当测量数据的噪声率为3 33%时,与传统方法相比,REFA方法的成功率提高了3倍,产生结果的平均相对误差从7 899%降低到2 32 0 %

E. 如何才能学好编程算法呢

难学。其实，按照我们现在的教学大纲和教学要求，只要同学们掌握一些方法，克服心理上畏难、不轻言放弃，是完全可以学好的。
《C程序设计》的内容很丰富，按照我们现在的教学大纲，教学的主要内容是基础知识、四种结构的的程序设计、函数与数组的应用和一些简单的算法。在学习时，同学们应该把主要精力放在这些部分，通过实践（练习和上机调试等熟练掌握。当然，在初学C语言时，可能会遇到有些问题理解不透，或者表达方式与以往数学学习中不同（如运算符等），这就要求不气馁，不明白的地方多问多想，鼓足勇气进行学习，待学完后面的章节知识，前面的问题也就迎刃而解了，这一方面我感觉是我们同学最欠缺，大多学不好的就是因为一开始遇到困难就放弃，曾经和好多同学谈他的问题，回答是听不懂、不想听、放弃这样三个过程，我反问，这节课你听过课吗？回答又是没有，根本就没听过课，怎么说自己听不懂呢？相应的根本就没学习，又谈何学的好？
学习C语言始终要记住“曙光在前头”和“千金难买回头看”，“千金难买回头看”是学习知识的重要方法，就是说，学习后面的知识，不要忘了回头弄清遗留下的问题和加深理解前面的知识，这是我们学生最不易做到的，然而却又是最重要的。比如：在C语言中最典型的是关于结构化程序设计构思，不管是那种教材，一开始就强调这种方法，这时也许你不能充分体会，但是学到函数时，再回头来仔细体会，温故知新，理解它就没有那么难了。学习C语言就是要经过几个反复，才能前后贯穿，积累应该掌握的C知识。
那么，我们如何学好《C程序设计》呢？
一．学好C语言的运算符和运算顺序
这是学好《C程序设计》的基础，C语言的运算非常灵活，功能十分丰富，运算种类远多于其它程序设计语言。在表达式方面较其它程序语言更为简洁，如自加、自减、逗号运算和三目运算使表达式更为简单，但初学者往往会觉的这种表达式难读，关键原因就是对运算符和运算顺序理解不透不全。当多种不同运算组成一个运算表达式，即一个运算式中出现多种运算符时，运算的优先顺序和结合规则显得十分重要。在学习中，只要我们对此合理进行分类，找出它们与我们在数学中所学到运算之间的不同点之后，记住这些运算也就不困难了，有些运算符在理解后更会牢记心中，将来用起来得心应手，而有些可暂时放弃不记，等用到时再记不迟。
先要明确运算符按优先级不同分类，《C程序设计》运算符可分为15种优先级，从高到低，优先级为1 ~ 15，除第2、3级和第14级为从右至左结合外，其它都是从左至右结合，它决定同级运算符的运算顺序。下面我们通过几个例子来说明：
（1） 5*8/4%10 这个表达式中出现3种运算符，是同级运算符，运算顺序按从左至右结合，因此先计算5 *8=40，然后被4除，结果为10，最后是%（求余数）运算，所以表达式的最终结果为10%10 = 0；
（2）a = 3;b = 5;c =++ a* b ；d =a + +* b；
对于c=++a*b来说，按表中所列顺序，+ +先执行，*后执行，所以+ + a执行后，a的值为4，由于+ +为前置运算，所以a的值4参与运算，C的值计算式为4*5=20而不是3*5=15了；而对于d=a++*b来说，由于a + +为后置运算，所以a值为4参与运算，使得d的值仍为20，而a参与运算后其值加1，值为5。 这个例子执行后，a的值为5，b的值为5，c的值为20，d的值也是20；
（3）（a = 3，b = 5，b+ = a，c = b* 5）
例子中的“，”是逗号结合运算，上式称为逗号表达式，自左向右结合，最后一个表达式的结果值就是逗号表达式的结果，所以上面的逗号表达式结果为40，a的值为3，b的值为8，c的值为40。
（4）a=5;b=6;c=a>b?a:b;
例中的a>b?a:b是一个三目运算，它的功能是先做关系运算a>b部分，若结果为真，则取问号后a的值，否则取冒号后b的值，因此c的值应该为6，这个运算可以用来代替if…else…语句的简单应用。
二．学好C语言的四种程序结构
（1）顺序结构
顺序结构的程序设计是最简单的，只要按照解决问题的顺序写出相应的语句就行，它的执行顺序是自上而下，依次执行。
例如；a = 3，b = 5，现交换a，b的值，这个问题就好象交换两个杯子水，这当然要用到第三个杯子，假如第三个杯子是c，那么正确的程序为： c = a； a = b； b = c； 执行结果是a = 5，b = c = 3如果改变其顺序，写成：a = b； c = a； b = c； 则执行结果就变成a = b = c = 5，不能达到预期的目的，初学者最容易犯这种错误。 顺序结构可以独立使用构成一个简单的完整程序，常见的输入、计算，输出三步曲的程序就是顺序结构，例如计算圆的面积，其程序的语句顺序就是输入圆的半径r，计算s = 3.14159*r*r,输出圆的面积s。不过大多数情况下顺序结构都是作为程序的一部分，与其它结构一起构成一个复杂的程序，例如分支结构中的复合语句、循环结构中的循环体等。
（2） 分支结构
顺序结构的程序虽然能解决计算、输出等问题，但不能做判断再选择。对于要先做判断再选择的问题就要使用分支结构。分支结构的执行是依据一定的条件选择执行路径，而不是严格按照语句出现的物理顺序。分支结构的程序设计方法的关键在于构造合适的分支条件和分析程序流程，根据不同的程序流程选择适当的分支语句。分支结构适合于带有逻辑或关系比较等条件判断的计算，设计这类程序时往往都要先绘制其程序流程图，然后根据程序流程写出源程序，这样做把程序设计分析与语言分开，使得问题简单化，易于理解。程序流程图是根据解题分析所绘制的程序执行流程图。
学习分支结构不要被分支嵌套所迷惑，只要正确绘制出流程图，弄清各分支所要执行的功能，嵌套结构也就不难了。嵌套只不过是分支中又包括分支语句而已，不是新知识，只要对双分支的理解清楚，分支嵌套是不难的。下面我介绍几种基本的分支结构。
①if(条件)
{
分支体
}
这种分支结构中的分支体可以是一条语句，此时“”可以省略，也可以是多条语句即复合语句。它有两条分支路径可选，一是当条件为真，执行分支体，否则跳过分支体，这时分支体就不会执行。如：要计算x的绝对值，根据绝对值定义，我们知道，当x>=0时，其绝对值不变，而x<0时其绝对值是为x的反号，因此程序段为：if(x<0) x=-x;
②if(条件)

else

这是典型的分支结构，如果条件成立，执行分支1，否则执行分支2，分支1和分支2都可以是1条或若干条语句构成。如：求ax^2+bx+c=0的根
分析：因为当b^2-4ac>=0时,方程有两个实根，否则（b^2-4ac<0）有两个共轭复根。其程序段如下：

d=b*b-4*a*c;
if(d>=0)
{x1=(-b+sqrt(d))/2a;
x1=(-b-sqrt(d))/2a;
printf(“x1=%8.4f,x2=%8.4f\n”,x1,x2);
}
else
{r=-b/(2*a);
i =sqrt(-d)/(2*a);
printf(“x1=%8.4f+%8.4fi\n”r, i);
printf(“x2=%8.4f-%8.4fi\n”r,i)
}
③嵌套分支语句：其语句格式为：
if(条件1) ；
else if（条件2）
else if（条件3）
……
else if（条件n）
else
嵌套分支语句虽可解决多个入口和出口的问题，但超过3重嵌套后，语句结构变得非常复杂，对于程序的阅读和理解都极为不便，建议嵌套在3重以内，超过3重可以用下面的语句。
④switch开关语句：该语句也是多分支选择语句，到底执行哪一块，取决于开关设置，也就是表达式的值与常量表达式相匹配的那一路，它不同if…else 语句，它的所有分支都是并列的，程序执行时，由第一分支开始查找，如果相匹配，执行其后的块，接着执行第2分支，第3分支……的块，直到遇到break语句；如果不匹配，查找下一个分支是否匹配。这个语句在应用时要特别注意开关条件的合理设置以及break语句的合理应用。
（3）循环结构：
循环结构可以减少源程序重复书写的工作量，用来描述重复执行某段算法的问题，这是程序设计中最能发挥计算机特长的程序结构，C语言中提供四种循环，即goto循环、while循环、do –while循环和for循环。四种循环可以用来处理同一问题，一般情况下它们可以互相代替换，但一般不提倡用goto循环，因为强制改变程序的顺序经常会给程序的运行带来不可预料的错误，在学习中我们主要学习while、do…while、for三种循环。常用的三种循环结构学习的重点在于弄清它们相同与不同之处，以便在不同场合下使用，这就要清楚三种循环的格式和执行顺序，将每种循环的流程图理解透彻后就会明白如何替换使用，如把while循环的例题，用for语句重新编写一个程序，这样能更好地理解它们的作用。特别要注意在循环体内应包含趋于结束的语句（即循环变量值的改变），否则就可能成了一个死循环，这是初学者的一个常见错误。
在学完这三个循环后，应明确它们的异同点：用while和do…while循环时，循环变量的初始化的操作应在循环体之前，而for循环一般在语句1中进行的；while 循环和for循环都是先判断表达式，后执行循环体，而do…while循环是先执行循环体后判断表达式，也就是说do…while的循环体最少被执行一次，而while 循环和for就可能一次都不执行。另外还要注意的是这三种循环都可以用break语句跳出循环，用continue语句结束本次循环，而goto语句与if构成的循环，是不能用break和 continue语句进行控制的。
顺序结构、分支结构和循环结构并不彼此孤立的，在循环中可以有分支、顺序结构，分支中也可以有循环、顺序结构，其实不管哪种结构，我们均可广义的把它们看成一个语句。在实际编程过程中常将这三种结构相互结合以实现各种算法，设计出相应程序，但是要编程的问题较大，编写出的程序就往往很长、结构重复多，造成可读性差，难以理解，解决这个问题的方法是将C程序设计成模块化结构。
(4)模块化程序结构
C语言的模块化程序结构用函数来实现，即将复杂的C程序分为若干模块，每个模块都编写成一个C函数，然后通过主函数调用函数及函数调用函数来实现一大型问题的C程序编写，因此常说：C程序=主函数+子函数。 因些，对函数的定义、调用、值的返回等中要尤其注重理解和应用，并通过上机调试加以巩固。
三．掌握一些简单的算法
编程其实一大部分工作就是分析问题，找到解决问题的方法，再以相应的编程语言写出代码。这就要求掌握算法，根据我们的《C程序设计》教学大纲中，只要求我们掌握一些简单的算法，在掌握这些基本算法后，要完成对问题的分析就容易了。如两个数的交换、三个数的比较、选择法排序和冒泡法排序，这就要求我们要清楚这些算法的内在含义，其中选择法排序和冒泡法排序稍难，但只要明白排序的具体过程，对代码的理解就不难了。如用选择法对10个不同整数排序（从小到大），选择法排序思路：设有10个元素a[1]~a[10],将a[1]与a[2]~a[10]比较，若a[1]比a[2]~a[10]都小，则不进行交换，即无任何操作；若a[2]~a[10] 中有一个比a[1]小，则将其中最大的一个（假设为a）与a[1]交换，此时a[1]中存放了10个中最小的数。第二轮将a[2]与a[3]~a[10]比较，将剩下9个数中的最小者a与a[2]交换，此时a[2] 中存放的10个数中第2小的数；依此类推，共进行9轮比较，a[1]到a[10]就已按从小到大的顺序存放。即每一轮都找出剩下数中的最小一个，代码如下：
for(i=1;i<=9;i++)
for(j=i+1;j<=10;j++)
if(a>a[j]
{temp=a;
a=a[j];
a[j]=temp;
}
结语：当我们把握好上述几方面后，只要同学们能克服畏难、厌学、上课能专心听讲，做好练习与上机调试，其实C语言并不难学。
参考资料：;f=15;t=000968

F. 计算机科学技术前沿选讲的图书目录

第一部分 计算机硬件
第1讲 电子计算机发明准备
1.1 机械计算机
1.2 电子计算机发明的理论准备
背景材料
参考文献
第2讲 电子计算机发展简史
2.1 国外电子计算机发展简史
2.2 中国电子计算机发展简史
背景材料
参考文献
第3讲 计算机发展趋势
3.1 计算机小型化
3.2 计算机网络化
3.3 计算机多样化
背景材料
参考文献
第4讲 “巨磁电阻”效应与硬盘
4.1 “巨磁电阻”效应概述
4.2 2007年诺贝尔物理学奖
4.3 硬盘介质存储原理
4.4 大硬盘中的应用
4.5 研究历史与热点
4.6 量子化磁盘
背景材料
参考文献
第5讲 光盘与有机光存储材料
5.1 光盘与有机光存储材料简介
5.2 光盘的种类
5.3 光盘读写机理
5.4 光存储的发展历史
5.5 光存储技术的发展趋势
5.6 我国光存储的发展
背景材料
参考文献
第6讲 集成电路、芯片及其发展历史
6.1 集成电路与芯片
6.2 CPU的结构
6.3 集成电路发展历史
6.4 我国集成电路发展史
背景材料
参考文献
第7讲 芯片设计与制造
7.1 SoC
7.2 CMOS
7.3 芯片的封装技术
7.4 国内芯片设计制造的研究现状
背景材料
参考文献
第8讲 超级计算机
8.1 超级计算机概述
8.2 超级计算机的结构
8.3 顶级超级计算机
8.4 国外大/巨型机的发展
8.5 国内大/巨型机的发展
背景材料
参考文献
第9讲 量子计算机
9.1 量子计算机概述
9.2 量子计算机原理
9.3 量子计算机发展现状与趋势
9.4 量子技术的应用
9.5 国内量子计算机发展
背景材料
参考文献
第10讲 纳米器件
10.1 纳米器件概述
10.2 纳米器件的技术原理
10.3 纳米器件的现状与发展
10.4 纳米器件的典型应用
10.5 纳米器件的展望
10.6 国内纳米器件的研究
背景材料
参考文献
第11讲 机器人
11.1 机器人简介
11.2 机器人的发展阶段
11.3 机器人分类
11.4 各国的机器人发展
11.5 中国的机器人发展
11.6 现代机器人发展
背景材料
参考文献
第二部分 计算机软件
第12讲 CMM与敏捷软件设计
12.1 软件危机与软件工程方法学
12.2 软件过程管理与CMM
12.3 敏捷软件设计
12.4 我国的敏捷开发
背景材料
参考文献
第13讲 软件产品线与网构软件
13.1 软件产品线的历史
13.2 软件产品线的结构与框架
13.3 国内网构软件研究
背景材料
参考文献
第14讲 可信计算
14.1 可信计算的事故
14.2 可信计算的重要概念
14.3 可信计算的发展历程
14.4 国外可信计算的研究进展
14.5 我国的可信计算
背景材料
参考文献
第15讲 演化计算与软件基因编程
15.1 演化计算
15.2 遗传算法
15.3 遗传程序设计
15.4 基因表达式程序设计
15.5 软件基因编程方式
背景材料
参考文献
第16讲 软件进化论
16.1 软件进化论研究
16.2 软件的大小进化
16.3 软件生态系统
16.4 软件分子与细胞
16.5 软件器官与软件脑
背景材料
参考文献
第17讲 4GL与软件开发工具酶
17.1 4GL
17.2 生物酶与开发工具
背景材料
……
第18讲 知见与智换体
第三部分 网络与安全
第19讲 光通信与其他应用
第20讲 全球卫星通信
第21讲 超高速网络
第22讲 网络生态与青少年上网
第23讲 网格计算
第24讲 人工免疫与计算机病毒
第25讲 信息对抗
第四部分 生物与智能
第26讲 分子机器
第27讲 生物芯片
第28讲 生物信息学
第29讲 生物计算机
第30讲 人工生命
第31讲 人工智能
第32讲 人机接口与一体化
第33讲 “合成人”计划
第五部分 计算机应用
第34讲 计算可视化与虚拟现实
第35讲 核磁共振成像与CT
第36讲 电子成像技术
第37讲 普适计算
第38讲 虚拟仪器与数字制造
第39讲 数字地球与数字城市
第40讲 智能交通
全书思考题
……

G. 单片机原理及应用求数组中最大元素时常采用“打擂台”算法,其编程原理是什么

电机原理及其他的应用，它的除数的它的最大颜色，我们市场还是可以用打擂台的算法了，并且他的编程原理我觉得能够给大家带来一种更好的是。

H. 遗传算法原理与应用实例的目录

第1章 绪论
1.1 从生物进化到遗传算法
1.2 遗传算法的描述
1.3 表示方案的实例
1.3.1 工程设计的最优化
1.3.2 人工蚁问题
1.4 遗传算法的特点
1.5 遗传算法的发展简史
1.6 遗传算法的研究内容及前景
1.7 遗传算法的应用
第2章 遗传算法的基本原理
2.1 复杂系统的适应过程
2.1.1 复杂系统的适应性
2.1.2 适应过程的数学模型
2.2 遗传算法的基本描述
2.2.1 整体优化问题
2.2.2 遗传算法的基本流程
2.2.3 遗传编码
2.2.4 适应函数（评价函数）
2.2.5 遗传算子
2.2.6 群体设定
2.2.7 初始化群体
2.2.8 终止循环的条件
2.2.9 标准遗传算法的流程
2.2.10 控制参数和选择
2.2.11 遗传算法的性能评估
2.3 遗传算法的模式理论
2.3.1 模式与模式空间
2.3.2 模式生存模型
2.3.3 双臂赌机分析
2.3.4 基因模块假设
2.3.5 模式处理与隐含并行性
2.3.6 模式处理与遗传算子的性能
2.4 遗传算法与其他搜索技术的比较
2.4.1 启发式随机搜索技术的基本功能
2.4.2 局域搜索技术
2.4.3 模拟退火算法
2.4.4 遗传算法搜索
2.4.5 启发式搜索技术比较
2.5 遗传算法计算实例
2.5.1 单调连续函数
2.5.2 One-Max函数
2.5.3 皇家大道问题
2.6 遗传算法杂交率与变异率关系的研究
2.6.1 研究方法简述
2.6.2 算例
2.6.3 应用
2.6.4 结论
第3章 遗传算法数学机理分析
3.1 遗传算法的基本定理
3.2 隐含并行性
3.3 Walsh模式变换
3.3.1 Walsh函数
3.3.2 用Walsh函数表示模式平均适应度
3.3.3 Walsh系数与异位显性（epistasis）
3.4 非均匀Walsh模式变换
3.5 最小欺骗问题
3.6 遗传算法欺骗问题的分析与设计
……
第4章 解连续优化问题的遗传算法
第5章 分布式遗传算法研究
第6章 遗传算法的实现技术
第7章 遗传算法应用实例
参考文献

I. 遗传算法原理与应用实例的介绍

《遗传算法原理与应用实例》主要结合应用实例系统讨论、介绍遗传算法原理及其应用，主要内容包括：遗传算法的基本原理和数学机理、解决连续问题优化的遗传算法和分布式遗传算法、遗传算法的实现技术、遗传算法应用实例，并给出了两个典型的遗传算法源程序。《遗传算法原理与应用实例》在详细介绍遗传算法理论与方法的同时，还给_出了基于遗传算法的费托合成反应动力学模型参数优化的详细设计应用。