比对算法
❶ 比较算法优缺点：
1.先来先服务先来先服务（FCFS, First Come First Serve）是最简单的调度算法，按先后顺序进行调度。1. 定义按照作业提交或进程变为就绪状态的先后次序，分派CPU；当前作业或进程占用CPU，直到执行完或阻塞，才出让CPU（非抢占方式）。在作业或进程唤醒后（如I/O完成），并不立即恢复执行，通常等到当前作业或进程出让CPU。2.适用场景比较有利于长作业，而不利于短作业。有利于CPU繁忙的作业，而不利于I/O繁忙的作业。
2. 轮转法轮转法(Round Robin)是让每个进程在就绪队列中的等待时间与享受服务的时间成正比例。1. 定义将系统中所有的就绪进程按照FCFS原则，排成一个队列。每次调度时将CPU分派给队首进程，让其执行一个时间片。时间片的长度从几个ms到几百ms。在一个时间片结束时，发生时钟中断。调度程序据此暂停当前进程的执行，将其送到就绪队列的末尾，并通过上下文切换执行当前的队首进程。进程可以未使用完一个时间片，就出让CPU（如阻塞）。2. 时间片长度的确定时间片长度变化的影响过长－>退化为FCFS算法，进程在一个时间片内都执行完，响应时间长。过短－>用户的一次请求需要多个时间片才能处理完，上下文切换次数增加，响应时间长。对响应时间的要求：T(响应时间)=N(进程数目)*q(时间片)就绪进程的数目：数目越多，时间片越小系统的处理能力：应当使用户输入通常在一个时间片内能处理完，否则使响应时间，平均周转时间和平均带权周转时间延长。
3. 多级反馈队列算法多级反馈队列算法(Round Robin with Multiple Feedback)是轮转算法和优先级算法的综合和发展。1. 定义设置多个就绪队列，分别赋予不同的优先级，如逐级降低，队列1的优先级最高。每个队列执行时间片的长度也不同，规定优先级越低则时间片越长，如逐级加倍。新进程进入内存后，先投入队列1的末尾，按FCFS算法调度；若按队列1一个时间片未能执行完，则降低投入到队列2的末尾，同样按FCFS算法调度；如此下去，降低到最后的队列，则按“时间片轮转”算法调度直到完成。仅当较高优先级的队列为空，才调度较低优先级的队列中的进程执行。如果进程执行时有新进程进入较高优先级的队列，则抢先执行新进程，并把被抢先的进程投入原队列的末尾。2.优点为提高系统吞吐量和缩短平均周转时间而照顾短进程。为获得较好的I/O设备利用率和缩短响应时间而照顾I/O型进程。不必估计进程的执行时间，动态调节3. 几点说明I/O型进程：让其进入最高优先级队列，以及时响应I/O交互。通常执行一个小时间片，要求可处理完一次I/O请求的数据，然后转入到阻塞队列。计算型进程：每次都执行完时间片，进入更低级队列。最终采用最大时间片来执行，减少调度次数。I/O次数不多，而主要是CPU处理的进程。在I/O完成后，放回优先I/O请求时离开的队列，以免每次都回到最高优先级队列后再逐次下降。为适应一个进程在不同时间段的运行特点，I/O完成时，提高优先级；时间片用完时，降低优先级。
4. 优先级法优先级算法（Priority Scheling）是多级队列算法的改进，平衡各进程对响应时间的要求。适用于作业调度和进程调度，可分成抢先式和非抢先式。1. 静态优先级作业调度中的静态优先级大多按以下原则确定：由用户自己根据作业的紧急程度输入一个适当的优先级。由系统或操作员根据作业类型指定优先级。系统根据作业要求资源情况确定优先级。进程的静态优先级的确定原则：按进程的类型给予不同的优先级。将作业的情态优先级作为它所属进程的优先级。2. 动态优先级进程的动态优先级一般根据以下原则确定：根据进程占用有CPU时间的长短来决定。根据就绪进程等待CPU的时间长短来决定。
5．短作业优先法短作业优先（SJF, Shortest Job First）又称为“短进程优先”SPN(Shortest Process Next)；这是对FCFS算法的改进，其目标是减少平均周转时间。1. 定义对预计执行时间短的作业（进程）优先分派处理机。通常后来的短作业不抢先正在执行的作业。2. SJF的特点(1) 优点：比FCFS改善平均周转时间和平均带权周转时间，缩短作业的等待时间；提高系统的吞吐量；(2) 缺点：对长作业非常不利，可能长时间得不到执行；未能依据作业的紧迫程度来划分执行的优先级；难以准确估计作业（进程）的执行时间，从而影响调度性能。3. SJF的变型“最短剩余时间优先”SRT(Shortest Remaining Time)（允许比当前进程剩余时间更短的进程来抢占）“最高响应比优先”HRRN(Highest Response Ratio Next)（响应比R = (等待时间 + 要求执行时间) / 要求执行时间，是FCFS和SJF的折衷）6. 最高响应比优先法最高响应比优先法(HRN，Highest Response_ratio Next)是对FCFS方式和SJF方式的一种综合平衡。FCFS方式只考虑每个作业的等待时间而未考虑执行时间的长短，而SJF方式只考虑执行时间而未考虑等待时间的长短。因此，这两种调度算法在某些极端情况下会带来某些不便。HRN调度策略同时考虑每个作业的等待时间长短和估计需要的执行时间长短，从中选出响应比最高的作业投入执行。响应比R定义如下： R =(W+T)/T = 1+W/T其中T为该作业估计需要的执行时间，W为作业在后备状态队列中的等待时间。每当要进行作业调度时，系统计算每个作业的响应比，选择其中R最大者投入执行。这样，即使是长作业，随着它等待时间的增加，W / T也就随着增加，也就有机会获得调度执行。这种算法是介于FCFS和SJF之间的一种折中算法。由于长作业也有机会投入运行，在同一时间内处理的作业数显然要少于SJF法，从而采用HRN方式时其吞吐量将小于采用SJF 法时的吞吐量。另外，由于每次调度前要计算响应比，系统开销也要相应增加。
❷ 序列比对的算法过程
实际操作中利用计算机程序实现序列比对的基本算法。序列比对不仅需要考虑子序列之间的匹配，而且需要对整个序列进行比较。也就是说，必须考虑两个序列中所有残基的匹配。这就意味着，不可能使所有残基都能严格匹配。在这种情况下，序列比对中确定空位的过程变得十分复杂。
在进行序列两两比对时，有两方面问题直接影响相似性分值：取代矩阵和空位罚分。 空位罚分是为了补偿插入和缺失对序列相似性的影响，由于没有什么合适的理论模型能很好地描述空位 问题，因此空位罚分缺乏理论依据而更多的带有主观特色。一般的处理方法是用两个罚分值，一个对插入的第一个空位罚分，如10－15；另一个对空位的延伸罚分，如1－2。对于具体的比对问题，采用不同的罚分方法会取得不同的效果。
对于比对计算产生的分值，到底多大才能说明两个序列是同源的，对此有统计学方法加以说明，主要的思想是把具有相同长度的随机序列进行比对，把分值与最初的比对分值相比，看看比对结果是否具有显着性。相关的参数E代表随机比对分值不低于实际比对分值的概率。对于严格的比对，必须E值低于一定阈值才能说明比对的结果具有足够的统计学显着性，这样就排除了由于偶然的因素产生高比对得分的可能。
❸ 什么是多序列全局比对的累进算法（三个步骤）
第一，所有的序列之间逐一比对（双重比对）；第二，生成一个系统树图，将序列按相似性大致分组；第三，使用系统树图作为引导，产生出最终的多序列比对结果。
❹ 怎么判断比较各种算法的好坏
首先，这个算法必须是正确的
其次，好的算法应该是友好的，便于人们理解和交流，并且是机器可执行的。
这个算法还需要足够健壮，即当输入的数据非法或不合理时，也能适当的做出正确的反应或进行相应的处理
最后它还必须拥有高效率和低存储量要求。
也就是楼上几位说的时间复杂度和空间复杂度
占的地方越小，算得越快的算法才是好算法。
❺ 图像比对的原理或者算法
有噪声情况下。1、配准；2、两张图的图像块分别计算特征（lbp,sift等）；3、计算特征的距离（欧式距离等）。在matlab或opencv下都可以。
❻ 序列比对的算法有哪些在应用上各有何特点
首先你要明白——Clustalx的多序列比对算法是基于双序列比对的，它先将所有序列两两比对，然后根据两两比对结果构建指导树，再根据指导树依次添加相似度最高的
❼ 文本比较有哪些算法
用java比较两个文本文件的不同
RangeDifferencer
public class RangeDifferencer {
private static final RangeDifference[] EMPTY_RESULT= new RangeDifference[0];
/* (non Javadoc)
* Cannot be instantiated!
*/
private RangeDifferencer() {
// nothing to do
}
/**
* Finds the differences between two <code>IRangeComparator</code>s.
* The differences are returned as an array of <code>RangeDifference</code>s.
* If no differences are detected an empty array is returned.
*
* @param left the left range comparator
* @param right the right range comparator
* @return an array of range differences, or an empty array if no differences were found
*/
public static RangeDifference[] findDifferences(IRangeComparator left, IRangeComparator right) {
int rightSize= right.getRangeCount();
int leftSize= left.getRangeCount();
//
// Differences matrix:
// only the last d of each diagonal is stored, i.e., lastDiagonal[k] = row of d
//
int diagLen= 2 * Math.max(rightSize, leftSize); // bound on the size of edit script
int maxDiagonal= diagLen;
int lastDiagonal[]= new int[diagLen + 1]; // the row containing the last d
// on diagonal k (lastDiagonal[k] = row)
int origin= diagLen / 2; // origin of diagonal 0
// script corresponding to d[k]
LinkedRangeDifference script[]= new LinkedRangeDifference[diagLen + 1];
int row, col;
// find common prefix
for (row= 0; row < rightSize && row < leftSize && rangesEqual(right, row, left, row) == true;)
row++;
lastDiagonal[origin]= row;
script[origin]= null;
int lower= (row == rightSize) ? origin + 1 : origin - 1;
int upper= (row == leftSize) ? origin - 1 : origin + 1;
if (lower > upper)
return EMPTY_RESULT;
//System.out.println("findDifferences: " + maxDiagonal + " " + lower + " " + upper);
// for each value of the edit distance
for (int d= 1; d <= maxDiagonal; ++d) { // d is the current edit distance
if (right.skipRangeComparison(d, maxDiagonal, left))
return EMPTY_RESULT; // should be something we already found
// for each relevant diagonal (-d, -d+2 ..., d-2, d)
for (int k= lower; k <= upper; k += 2) { // k is the current diagonal
LinkedRangeDifference edit;
if (k == origin - d || k != origin + d && lastDiagonal[k + 1] >= lastDiagonal[k - 1]) {
//
// move down
//
row= lastDiagonal[k + 1] + 1;
edit= new LinkedRangeDifference(script[k + 1], LinkedRangeDifference.DELETE);
} else {
//
// move right
//
row= lastDiagonal[k - 1];
edit= new LinkedRangeDifference(script[k - 1], LinkedRangeDifference.INSERT);
}
col= row + k - origin;
edit.fRightStart= row;
edit.fLeftStart= col;
//Assert.isTrue(k >= 0 && k <= maxDiagonal);
script[k]= edit;
// slide down the diagonal as far as possible
while (row < rightSize && col < leftSize && rangesEqual(right, row, left, col) == true) {
++row;
++col;
}
//Assert.isTrue(k >= 0 && k <= maxDiagonal); // Unreasonable value for diagonal index
lastDiagonal[k]= row;
if (row == rightSize && col == leftSize) {
//showScript(script[k], right, left);
return createDifferencesRanges(script[k]);
}
if (row == rightSize)
lower= k + 2;
if (col == leftSize)
upper= k - 2;
}
--lower;
++upper;
}
// too many differences
//Assert.isTrue(false);
return null;
}
/**
* Finds the differences among two <code>IRangeComparator</code>s.
* In contrast to <code>findDifferences</code>, the result
* contains <code>RangeDifference</code> elements for non-differing ranges too.
*
* @param left the left range comparator
* @param right the right range comparator
* @return an array of range differences
*/
public static RangeDifference[] findRanges(IRangeComparator left, IRangeComparator right) {
RangeDifference[] in= findDifferences(left, right);
List out= new ArrayList();
RangeDifference rd;
int mstart= 0;
int ystart= 0;
for (int i= 0; i < in.length; i++) {
RangeDifference es= in[i];
rd= new RangeDifference(RangeDifference.NOCHANGE, mstart, es.rightStart() - mstart, ystart, es.leftStart() - ystart);
if (rd.maxLength() != 0)
out.add(rd);
out.add(es);
mstart= es.rightEnd();
ystart= es.leftEnd();
}
rd= new RangeDifference(RangeDifference.NOCHANGE, mstart, right.getRangeCount() - mstart, ystart, left.getRangeCount() - ystart);
if (rd.maxLength() > 0)
out.add(rd);
return (RangeDifference[]) out.toArray(EMPTY_RESULT);
}
//---- private methods
/*
* Creates a Vector of DifferencesRanges out of the LinkedRangeDifference.
* It coalesces adjacent changes.
* In addition, indices are changed such that the ranges are 1) open, i.e,
* the end of the range is not included, and 2) are zero based.
*/
private static RangeDifference[] createDifferencesRanges(LinkedRangeDifference start) {
LinkedRangeDifference ep= reverseDifferences(start);
ArrayList result= new ArrayList();
RangeDifference es= null;
while (ep != null) {
es= new RangeDifference(RangeDifference.CHANGE);
if (ep.isInsert()) {
es.fRightStart= ep.fRightStart + 1;
es.fLeftStart= ep.fLeftStart;
RangeDifference b= ep;
do {
ep= ep.getNext();
es.fLeftLength++;
} while (ep != null && ep.isInsert() && ep.fRightStart == b.fRightStart);
} else {
es.fRightStart= ep.fRightStart;
es.fLeftStart= ep.fLeftStart;
RangeDifference a= ep;
//
// deleted lines
//
do {
a= ep;
ep= ep.getNext();
es.fRightLength++;
} while (ep != null && ep.isDelete() && ep.fRightStart == a.fRightStart + 1);
boolean change= (ep != null && ep.isInsert() && ep.fRightStart == a.fRightStart);
if (change) {
RangeDifference b= ep;
//
// replacement lines
//
do {
ep= ep.getNext();
es.fLeftLength++;
} while (ep != null && ep.isInsert() && ep.fRightStart == b.fRightStart);
} else {
es.fLeftLength= 0;
}
es.fLeftStart++; // meaning of range changes from "insert after", to "replace with"
}
//
// the script commands are 1 based, subtract one to make them zero based
//
es.fRightStart--;
es.fLeftStart--;
result.add(es);
}
return (RangeDifference[]) result.toArray(EMPTY_RESULT);
}
/*
* Tests if two ranges are equal
*/
private static boolean rangesEqual(IRangeComparator a, int ai, IRangeComparator b, int bi) {
return a.rangesEqual(ai, b, bi);
}
/*
* Tests whether <code>right</code> and <code>left</code> changed in the same way
*/
private static boolean rangeSpansEqual(IRangeComparator right, int rightStart, int rightLen, IRangeComparator left, int leftStart, int leftLen) {
if (rightLen == leftLen) {
int i= 0;
for (i= 0; i < rightLen; i++) {
if (!rangesEqual(right, rightStart + i, left, leftStart + i))
break;
}
if (i == rightLen)
return true;
}
return false;
}
/*
* Reverses the range differences
*/
private static LinkedRangeDifference reverseDifferences(LinkedRangeDifference start) {
LinkedRangeDifference ep, behind, ahead;
ahead= start;
ep= null;
while (ahead != null) {
behind= ep;
ep= ahead;
ahead= ahead.getNext();
ep.setNext(behind);
}
return ep;
}
}
下面是一段关于如何使用这些类的简单的测试代码
public class RangeDifferencerTest extends TestCase {
InputStream left = null;
InputStream right = null;
/**
* @see junit.framework.TestCase#setUp()
*/
protected void setUp() throws Exception {
String file1 = "d:/temp/1.txt";
String file2 = "d:/temp/2.txt";
left = new FileInputStream(new File(file1));
right = new FileInputStream(new File(file2));
super.setUp();
}
/**
* @see junit.framework.TestCase#tearDown()
*/
protected void tearDown() throws Exception {
left.close();
right.close();
super.tearDown();
}
public static void main(String[] args) {
}
/*
* Test method for 'com.greatroad.smbnm.compare.RangeDifferencer.findDifferences(IRangeComparator, IRangeComparator)'
*/
public void testFindDifferences() {
try {
RangeDifference[] rds = RangeDifferencer.findRanges(new LineComparator(left,"GBK"),new LineComparator(right,"GBK"));
if(rds != null ){
for(int i=0; i<rds.length; i++){
RangeDifference rd = rds[i];
int length = rd.leftLength();
System.out.println(
"kind = "+rd.kind()
+",left["+rd.leftStart()+"-"+rd.leftEnd()
+"],right["+rd.rightStart()+"-"+rd.rightEnd()+"]");
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
❽ 如何比较两个算法的好坏，有什么指标
算法是一个良定义的计算过程，以一个或多个值输入，并以一个或多个值输出。
评价算法的好坏的因素：·算法是正确的；
·执行算法的时间；
·执行算法的存储空间（主要是辅助存储空间）；
·算法易于理解、编码、调试。
**************************************************************************************************************
时间复杂度：是某个算法的时间耗费，它是该算法所求解问题规模n的函数。
渐近时间复杂度：是指当问题规模趋向无穷大时，该算法时间复杂度的数量级。
评价一个算法的时间性能时，主要标准就是算法的渐近时间复杂度。
算法中语句的频度不仅与问题规模有关，还与输入实例中各元素的取值相关。
时间复杂度按数量级递增排列依次为：常数阶O(1)、对数阶O(log2n)、线性阶O(n)、线性对数阶O(nlog2n)、平方阶O(n^2)、立方阶O(n^3)、……k次方阶O(n^k)、指数阶O(2^n)。
空间复杂度：是某个算法的空间耗费，它是该算法所求解问题规模n的函数。
算法的时间复杂度和空间复杂度合称算法复杂度。
❾ 数据快速比较算法
你想知道每位相不相同吗？我看你这是二级制数吧，如果是二进制可以用位运算的异或，相同为0，不同为1，这是最快的了，时间复杂度为O(1)，掩码的操作都是用位运算的，不用什么查找。
如果你不知道位运算是啥，还是自己网络一下吧
❿ 详细介绍双序列比对、blast 以及多序列比对的区别,以及均适用于哪些场 景
序列比对是将两个或多个序列排列在一起，标明其相似之处。使用间隔表示未比对上，比对上的相同或相似的符号排列在同一列上。序列比对是生物信息学以及基因组学与进化的基础之一，其基本思想是：在生物学中普遍存在的序列决定结构、结构决定功能的规律，通过将核酸序列或者蛋白质序列的一级结构看成由基本字符构成的字符串，通过序列比对我们可以找到相似的序列并由此发现生物序列中的功能、结构和进化信息。
全局比对：全局比对是指将参与比对的两条序列里面的所有字符进行比对。全局比对在全局范围内对两条序列进行比对打分，找出最佳比对，主要被用来寻找关系密切的序列。其可以用来鉴别或证明新序列与已知序列家族的同源性，是进行分子进化分析的重要前提。其代表是Needleman-Wunsch算法。
局部比对：与全局比对不同，局部比对不必对两个完整的序列进行比对，而是在每个序列中使用某些局部区域片段进行比对。其产生的需求在于、人们发现有的蛋白序列虽然在序列整体上表现出较大的差异性，但是在某些局部区域能独立的发挥相同的功能，序列相当保守。这时候依靠全局比对明显不能得到这些局部相似序列的。其次，在真核生物的基因中，内含子片段表现出了极大变异性，外显子区域却较为保守，这时候全局比对表现出了其局限性，无法找出这些局部相似性序列。其代表是Smith-Waterman局部比对算法。
双重序列比对：双序列比对是指对两条序列M和N进行比对，找到其相似性关系，这种寻找生物序列相似性关系的过程被称为双序列比对。其算法可以主要分成基于全局比对的Needleman-Wunsch算法和基于局部比对的Smith-Waterman局部比对算法
多重序列比对：多序列比对是双序列比对推广，即把两个以上字符序列对齐，逐列比较其字符的异同，使得每一列字符尽可能一致，以发现其共同的结构特征的方法称为多序列比对。多序列比对算法可以分成渐进法和同步法。其可以发现不同的序列之间的相似部分，从而推断它们在结构和功能上的相似关系，主要用于分子进化关系，预测蛋白质的二级结构和三级结构、估计蛋白质折叠类型的总数，基因组序列分析等。
基因组比对：是多序列比对的一种特例，指对基因组范围内的序列信息进行比对的过程。通过对不同亲缘关系物种的基因组序列进行比较，能够鉴定出编码序列、非编码调控序列及给定物种独有的序列。而基因组范围之内的序列比对，可以了解不同物在核苷酸组成、同线性关系和基因顺序方面的异同，进而得到基因分析预测与定位、生物系统发生进化关系等方面的信息。
BLAST：BLAST[1]（Basic Local Alignment Search Tool）是在在1990年由Altschul等人提出的双序列局部比对算法，是一套在蛋白质数据库或DNA数据库中进行相似性比较的分析工具。BLAST是一种启发式算法，用于在大型数据库中寻找比对序列，是一种在局部比对基础上的近似比对算法，可以在保持较高精度的情况下大大减少程序运行的时间。
算法思想描述：
双重序列比对主要分成以Needleman-Wunsch算法为代表的全局比对和以Smith-Waterman局部比对算法为代表的局部比对，BLAST是局部比对的一种推广。多重比对算法可以主要分成动态规划算法、随机算法、迭代法和渐进比对算法。
（1）双重序列比对：
Needleman-Wunsch算法：该算法是基于动态规划思想的全局比对的基本算法，动态规划的比对算法的比对过程可以用一个以序列S为列，T为行的(m+1)×(n+1)的二维矩阵来表示，用
sigma表示置换矩阵。
在计算完矩阵后，从矩阵的右下角单元到左上单元回溯最佳路径（用箭头表示），根据最佳路径给出两序列的比对结果。其中，斜箭头表示2个残基匹配，水平箭头表示在序列S的相应位置插入一个空位，垂直方向的箭头表示在序列T的相应位置插入一个空位。
Smith-Waterman算法：该算法是一种用来寻找并比较具有局部相似性区域的动态规划算法，这种算法适用于亲缘关系较远、整体上不具有相似性而在一些较小的区域上存在局部相似性的两个序列。该算法的基本思想是：使用迭代方法计算出两个序列的相似分值，存在一个得分矩阵M中，然后根据这个得分矩阵，通过动态规划的方法回溯找到最优的比对序列。与全局比对相比，这种算法的改变是把矩阵单元值为负者一律取为0，这是因为分值为负的比对丧失了比对的生物学意义，因此把得分为负值的子序列丢弃。
BLAST: BLAST算法的基本思想是通过产生数量更少的但质量更好的增强点来提高比对的速度。算法的原理主要分为以下五步：（1）过滤：首先过滤掉低复杂度区域，即含有大量重复的序列；（2）Seeding：将Query序列中每k个字组合成一个表，即将一个序列拆分成多个连续的‘seed words’（通常蛋白质k=3，核酸k=11）；（3）比对：列出我们所关心的所有可能的字组，再配合置换矩阵给出高分值的字组并组织成快速搜索树结构或者哈希索引，因此此步骤可以快速搜索出大数据集中的所有匹配序列，找到每个seed words在参考序列中的位置；（4）延伸：当找到seed words的位置后，接下来需要将seed word延伸成长片段，延伸过程中，得分值也在变化，当得分值小于阈值时即停止延伸，最后得到的片段成为高分片段对，HSP（High-scoring segment pair）；（5）显着性分析，最后我们使用如下公式计算E值，E值衡量了在随机情况下，数据库存在的比当前匹配分数更好的比对的数目，因此可以用该值作为指标评价HSP比对序列的可信度。
其中，m是数据库长度，n是query的长度，S是HSP分数，其他两个参数是修正系数。
（2）多重序列比对
动态规划算法：其基本思想是将一个二维的动态规划矩阵扩展到三维或者多维，多序列比对的积分是n个序列中两两进行比对所得积分之和。矩阵的维度反映了参与比对的序列数。这种方法对计算资源要求比较高[6]。
随机算法：主要包括遗传算法和模拟退火算法，遗传算法是一类借鉴生物界进化规律演化来的全局意义上的自适应随机搜索方法。当用遗传算法进行生物序列分析时，每一代包含固定数量的个体，这些个体用他们的适应度来评价。变异则模拟了生物进化过程中的偶然残基突变现象。对产生的新一代群体进行重新评价、选择、交叉、变异，如此循环往复，使群体中最优个体的适应度不断提高，直到达到一个阈值，算法结束。模拟退火的基本思想是用一物质系统的退火过程来模拟优化问题的寻优方法，当物质系统达到最小能量状态时，优化问题的目标函数也相应地达到了全局最优解。这两种方法都是对构造好的目标函数进行最优解搜索，但实际比对效果并不好[6,7]。
迭代法：迭代法的代表是Muscle[8], Muscle是一个新的渐进比对和迭代比对的综合算法，主要由两部分构成，第一部分是迭代渐进比对：第一次渐进比对的目的是快速产生一个多序列比对而不强调准确率，以此为基础再对渐进比对进行改良。经过两次渐进比对，形成一个相对准确的多序列比对；第二部分是迭代比对：该过程类似于Prrp算法[9]，即通过不断的迭代，逐步优化最终比对结果。其主要特点包括：使用kmer counting进行快速的距离测量，使用一个新的图谱比对打分函数进行渐进比对，使用依赖于数的有限分隔进行细化。
渐进比对算法：该算法以Feng和Doolittle提出的最为经典[10]。渐进比对算法的基本思想是迭代地利用两序列动态规划比对算法,先由两个序列的比对开始，逐渐添加新序列，直到所有序列都加入为止。但是不同的添加顺序会产生不同的比对结果。确定合适的比对顺序是渐进比对算法的一个关键问题。通常，整个序列的比对应该从最相似的两个序列开始，由近至远逐步完成。作为全局多序列比对的渐进比对算法有个基本的前提假设:所有要比对的序列是同源的，即由共同的祖先序列经过一系列的突变积累，并经自然选择遗传下来的，分化越晚的序列之间相似程度就越高。因此，在渐进比对过程中，应该对近期的进化事件比远期的进化事件给予更大的关注。由于同源序列是进化相关的，因此可以按着序列的进化顺序，即沿着系统发育树(指导树)的分支，由近至远将序列或已比对序列按双序列比对算法逐步进行比对，重复这一过程直到所有序列都己添加到这个比对中为止[10]。其三个步骤为：（1）利用双序列比对方法对所有的序列进行两两比对，得到相似性分值；（2）利用相似性矩阵（或距离矩阵）产生辅助导向树；（3）根据导向树进行渐进比对。渐进比对算法是最常用、简单又有效的启发式多序列比对方法，它所需时间较短、所占内存较小，其算法很多，主要有CLUSTAL W, T-Coffee和DiAlign等，其中 CLUSTAL W应用最广泛。
应用：
类型+应用
双重序列对比：判断两个序列的同源性和一致性。（1）全局多序列比对可以鉴别或证明新序列与己有序列家族的同源性;帮助预测新蛋白质序列的二级和二级结构，是进行分子进化分析的重要前提。适合序列相似性较高，序列长度近似时的比对；（2）局部比对考虑序列部分区域的相似性。局部多序列比对可以用来刻画蛋白质家族和超家族。适合于未知两个序列相似程度的，可能存在一些片段极其相似而另一些片段相异的序列比对情况。
多重序列比对：多重比对经常用来研究序列间的进化关系，构建进化树；探究序列间的保守性。主要用于分子进化关系，预测蛋白质的二级结构和三级结构、估计蛋白质折叠类型的总数，基因组序列分析等。
基因组比对：通过对不同亲缘关系物种的基因组序列进行比较，能够鉴定出编码序列、非编码调控序列及给定物种独有的序列。而基因组范围之内的序列比对，可以了解不同物在核苷酸组成、同线性关系和基因顺序方面的异同，进而得到基因分析预测与定位、生物系统发生进化关系等方面的信息。
其中，BLAST作为最重要的比对工具，意义特殊，拿出来单独讨论。BLAST可以分成Basic BLAST和 Specialized BLAST, BLAST包括常规的nucleotide blast, Protein blast和Translating blast；Specialize blast可以对特殊生物或特殊研究领域的序列数据库进行检索。