圖包演算法源程序

㈠ C++實現D演算法F演算法求最短路徑具體程序

/* 用鄰接矩陣表示的圖的Dijkstra演算法的源程序*/

#include<stdio.h>
#define MAXVEX 100

typedef char VexType;

typedef float AdjType;

typedef struct

{ VexType vexs[MAXVEX]; /* 頂點信息 */

AdjType arcs[MAXVEX][MAXVEX]; /* 邊信息 */

int n; /* 圖的頂點個數 */

}GraphMatrix;

GraphMatrix graph;

typedef struct {

VexType vertex; /* 頂點信息 */

AdjType length; /* 最短路徑長度 */

int prevex; /* 從v0到達vi(i=1,2,…n-1)的最短路徑上vi的前趨頂點 */

}Path;

Path dist[6]; /* n為圖中頂點個數*/

#define MAX 1e+8

void init(GraphMatrix* pgraph, Path dist[])

{
int i; dist[0].length=0; dist[0].prevex=0;
dist[0].vertex=pgraph->vexs[0];

pgraph->arcs[0][0]=1; /* 表示頂點v0在集合U中 */

for(i=1; i<pgraph->n; i++) /* 初始化集合V-U中頂點的距離值 */

{ dist[i].length=pgraph->arcs[0][i];

dist[i].vertex=pgraph->vexs[i];

if(dist[i].length!=MAX)

dist[i].prevex=0;

else dist[i].prevex= -1;

}

}

void dijkstra(GraphMatrix graph, Path dist[])
{ int i,j,minvex; AdjType min;
init(&graph,dist); /* 初始化，此時集合U中只有頂點v0*/
for(i=1; i<graph.n; i++)
{ min=MAX; minvex=0;
for(j=1; j<graph.n; j++)
if( (graph.arcs[j][j]==0) && (dist[j].length<min) ) /*在V-U中選出距離值最小頂點*/

if(minvex==0) break; /* 從v0沒有路徑可以通往集合V-U中的頂點 */
graph.arcs[minvex][minvex]=1; /* 集合V-U中路徑最小的頂點為minvex */
for(j=1; j<graph.n; j++) /* 調整集合V-U中的頂點的最短路徑 */
{ if(graph.arcs[j][j]==1) continue;
if(dist[j].length>dist[minvex].length+graph.arcs[minvex][j])
{ dist[j].length=dist[minvex].length+graph.arcs[minvex][j];
dist[j].prevex=minvex;
}
}
}
}

void initgraph()
{
int i,j;
graph.n=6;
for(i=0;i<graph.n;i++)
for(j=0;j<graph.n;j++)
graph.arcs[i][j]=(i==j?0:MAX);
graph.arcs[0][1]=50;
graph.arcs[0][2]=10;
graph.arcs[1][2]=15;
graph.arcs[1][4]=5;
graph.arcs[2][0]=20;
graph.arcs[2][3]=15;
graph.arcs[3][1]=20;
graph.arcs[3][4]=35;
graph.arcs[4][3]=30;
graph.arcs[5][3]=3;
graph.arcs[0][4]=45;
}

int main()
{
int i;
initgraph();
dijkstra(graph,dist);
for(i=0;i<graph.n;i++)
printf("(%.0f %d)",dist[i].length,dist[i].prevex);
return 0;
}
}
}
}

void initgraph()
{
int i,j;
graph.n=6;
for(i=0;i<graph.n;i++)
for(j=0;j<graph.n;j++)
graph.arcs[i][j]=(i==j?0:MAX);
graph.arcs[0][1]=50;
graph.arcs[0][2]=10;
graph.arcs[1][2]=15;
graph.arcs[1][4]=5;
graph.arcs[2][0]=20;
graph.arcs[2][3]=15;
graph.arcs[3][1]=20;
graph.arcs[3][4]=35;
graph.arcs[4][3]=30;
graph.arcs[5][3]=3;
graph.arcs[0][4]=45;
}

int main()
{
int i;
initgraph();
dijkstra(graph,dist);
for(i=0;i<graph.n;i++)
printf("(%.0f %d)",dist[i].length,dist[i].prevex);
return 0;
}
這個稍作改動就可以了。

㈡ 跪求md5演算法的可執行程序，最好帶上流程圖和源代碼，謝了～

1. java版MD5

MD5Util.java

[java] view plain
package com.cncounter.util.common;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/**
* Java消息摘要演算法 MD5 工具類,其實其他摘要演算法的實現也類似
*/
public class MD5Util {
/**
* 對文本執行 md5 摘要加密, 此演算法與 mysql,JavaScript生成的md5摘要進行過一致性對比.
* @param plainText
* @return 返回值中的字母為小寫
*/
public static String md5(String plainText) {
if (null == plainText) {
plainText = "";
}
String MD5Str = "";
try {
// JDK 6 支持以下6種消息摘要演算法，不區分大小寫
// md5,sha(sha-1),md2,sha-256,sha-384,sha-512
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(plainText.getBytes());
byte b[] = md.digest();

int i;

StringBuilder builder = new StringBuilder(32);
for (int offset = 0; offset < b.length; offset++) {
i = b[offset];
if (i < 0)
i += 256;
if (i < 16)
builder.append("0");
builder.append(Integer.toHexString(i));
}
MD5Str = builder.toString();
// LogUtil.println("result: " + buf.toString());// 32位的加密
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return MD5Str;
}
// 一個簡版測試
public static void main(String[] args) {
String m1 = md5("1");
String m2 = md5(m1);
/* 輸出為
* m1=
* m2=
*/
System.out.println("m1="+m1);
System.out.println("m2="+m2);
}
}

2. MySQL版MD5

MySQL直接支持 md5函數調用
[sql] view plain
select md5('1') as m1, md5(md5('1')) as m2;

執行結果為:

[plain] view plain
MariaDB [(none)]> select md5('1') as m1, md5(md5('1')) as m2;
+----------------------------------+----------------------------------+
| m1 | m2 |
+----------------------------------+----------------------------------+
| | |
+----------------------------------+----------------------------------+
1 row in set (0.00 sec)

3. JavaScript 版MD5函數

md5.js 代碼如下:

[javascript] view plain
/*! JavaScript 的 MD5 實現 */

// 括弧表達式, (xxxxx) 是用來將內部的語句、表達式的結果作為一個結果.
// 常見的是將json字元串用 eval 解析時,需要 eval("(" +jsonstr+ ")");
// () 內部定義了一個空間, 裡面定義的變數不會污染到全局空間,很適合做lib
// (function UMD(對象/函數名name, 上下文this, 函數/對象的定義)) 返回一個匿名函數
// 因為第一個括弧內 的結果是一個函數,而函數可以這樣調用: (function(形參){})(實參);
// 這種匿名函數被瀏覽器解析後會自動執行一次.
(function UMD(name, context, definition) {
if ( typeof mole !== "undefined" && mole.exports) {
// 如果 mole 存在,並且mole.exports存在,則將賦值結果賦給 它
// 可以不用管
mole.exports = definition();
} else if ( typeof define === "function" && define.amd) {
// 如果 define 這個函數存在,應該是另一個基礎類庫，則使用define
// 可以不用管
define(definition);
} else {
// 簡單一點,可以看成: 調用傳入的definition函數，將返回的對象綁定到全局空間
// 當然,根據傳入的上下文不同,也可以綁定到其他對象下面,成為一個屬性方法.
context[name] = definition(name, context);
}
}
)("md5", this, function DEF(name, context) {"use strict";
// 上面的 use strict 表示嚴格語法模式,有錯誤就拒絕執行.
// 而普通的JS,是解釋執行,不執行的地方,有些錯誤也不影響其他代碼的執行
// 作為類庫,使用嚴格模式是很有必要的.嚴格模式聲明必須放到一個namespace空間的最起始處.

//
var old_public_api = (context || {})[name];
// 最後要返回的對象/函數.
function md5_func(text) {
return hex_md5(text);
};
// 下面一堆是具體的演算法... 可以先不用管
/////////////////////////////////////////////////////

//計算MD5
var hexcase = 0;
function hex_md5(a) {
if (a == "")
return a;
return rstr2hex(rstr_md5(str2rstr_utf8(a)))
};
function hex_hmac_md5(a, b) {
return rstr2hex(rstr_hmac_md5(str2rstr_utf8(a), str2rstr_utf8(b)))
};
function md5_vm_test() {
return hex_md5("abc").toLowerCase() == ""
};
function rstr_md5(a) {
return binl2rstr(binl_md5(rstr2binl(a), a.length * 8))
};
function rstr_hmac_md5(c, f) {
var e = rstr2binl(c);
if (e.length > 16) {
e = binl_md5(e, c.length * 8)
}
var a = Array(16), d = Array(16);
for (var b = 0; b < 16; b++) {
a[b] = e[b] ^ 909522486;
d[b] = e[b] ^ 1549556828
}
var g = binl_md5(a.concat(rstr2binl(f)), 512 + f.length * 8);
return binl2rstr(binl_md5(d.concat(g), 512 + 128))
};
function rstr2hex(c) {
try { hexcase
} catch(g) {
hexcase = 0
}
var f = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
var b = "";
var a;
for (var d = 0; d < c.length; d++) {
a = c.charCodeAt(d);
b += f.charAt((a >>> 4) & 15) + f.charAt(a & 15)
}
return b
};
function str2rstr_utf8(c) {
var b = "";
var d = -1;
var a, e;
while (++d < c.length) {
a = c.charCodeAt(d);
e = d + 1 < c.length ? c.charCodeAt(d + 1) : 0;
if (55296 <= a && a <= 56319 && 56320 <= e && e <= 57343) {
a = 65536 + ((a & 1023) << 10) + (e & 1023);
d++
}
if (a <= 127) {
b += String.fromCharCode(a)
} else {
if (a <= 2047) {
b += String.fromCharCode(192 | ((a >>> 6) & 31), 128 | (a & 63))
} else {
if (a <= 65535) {
b += String.fromCharCode(224 | ((a >>> 12) & 15), 128 | ((a >>> 6) & 63), 128 | (a & 63))
} else {
if (a <= 2097151) {
b += String.fromCharCode(240 | ((a >>> 18) & 7), 128 | ((a >>> 12) & 63), 128 | ((a >>> 6) & 63), 128 | (a & 63))
}
}
}
}
}
return b
};
function rstr2binl(b) {
var a = Array(b.length >> 2);
for (var c = 0; c < a.length; c++) {
a[c] = 0
}
for (var c = 0; c < b.length * 8; c += 8) {
a[c >> 5] |= (b.charCodeAt(c / 8) & 255) << (c % 32)
}
return a
};
function binl2rstr(b) {
var a = "";
for (var c = 0; c < b.length * 32; c += 8) {
a += String.fromCharCode((b[c >> 5] >>> (c % 32)) & 255)
}
return a
};
function binl_md5(p, k) {
p[k >> 5] |= 128 << ((k) % 32);
p[(((k + 64) >>> 9) << 4) + 14] = k;
var o = 1732584193;
var n = -271733879;
var m = -1732584194;
var l = 271733878;
for (var g = 0; g < p.length; g += 16) {
var j = o;
var h = n;
var f = m;
var e = l;
o = md5_ff(o, n, m, l, p[g + 0], 7, -680876936);
l = md5_ff(l, o, n, m, p[g + 1], 12, -389564586);
m = md5_ff(m, l, o, n, p[g + 2], 17, 606105819);
n = md5_ff(n, m, l, o, p[g + 3], 22, -1044525330);
o = md5_ff(o, n, m, l, p[g + 4], 7, -176418897);
l = md5_ff(l, o, n, m, p[g + 5], 12, 1200080426);
m = md5_ff(m, l, o, n, p[g + 6], 17, -1473231341);
n = md5_ff(n, m, l, o, p[g + 7], 22, -45705983);
o = md5_ff(o, n, m, l, p[g + 8], 7, 1770035416);
l = md5_ff(l, o, n, m, p[g + 9], 12, -1958414417);
m = md5_ff(m, l, o, n, p[g + 10], 17, -42063);
n = md5_ff(n, m, l, o, p[g + 11], 22, -1990404162);
o = md5_ff(o, n, m, l, p[g + 12], 7, 1804603682);
l = md5_ff(l, o, n, m, p[g + 13], 12, -40341101);
m = md5_ff(m, l, o, n, p[g + 14], 17, -1502002290);
n = md5_ff(n, m, l, o, p[g + 15], 22, 1236535329);
o = md5_gg(o, n, m, l, p[g + 1], 5, -165796510);
l = md5_gg(l, o, n, m, p[g + 6], 9, -1069501632);
m = md5_gg(m, l, o, n, p[g + 11], 14, 643717713);
n = md5_gg(n, m, l, o, p[g + 0], 20, -373897302);
o = md5_gg(o, n, m, l, p[g + 5], 5, -701558691);
l = md5_gg(l, o, n, m, p[g + 10], 9, 38016083);
m = md5_gg(m, l, o, n, p[g + 15], 14, -660478335);
n = md5_gg(n, m, l, o, p[g + 4], 20, -405537848);
o = md5_gg(o, n, m, l, p[g + 9], 5, 568446438);
l = md5_gg(l, o, n, m, p[g + 14], 9, -1019803690);
m = md5_gg(m, l, o, n, p[g + 3], 14, -187363961);
n = md5_gg(n, m, l, o, p[g + 8], 20, 1163531501);
o = md5_gg(o, n, m, l, p[g + 13], 5, -1444681467);
l = md5_gg(l, o, n, m, p[g + 2], 9, -51403784);
m = md5_gg(m, l, o, n, p[g + 7], 14, 1735328473);
n = md5_gg(n, m, l, o, p[g + 12], 20, -1926607734);
o = md5_hh(o, n, m, l, p[g + 5], 4, -378558);
l = md5_hh(l, o, n, m, p[g + 8], 11, -2022574463);
m = md5_hh(m, l, o, n, p[g + 11], 16, 1839030562);
n = md5_hh(n, m, l, o, p[g + 14], 23, -35309556);
o = md5_hh(o, n, m, l, p[g + 1], 4, -1530992060);
l = md5_hh(l, o, n, m, p[g + 4], 11, 1272893353);
m = md5_hh(m, l, o, n, p[g + 7], 16, -155497632);
n = md5_hh(n, m, l, o, p[g + 10], 23, -1094730640);
o = md5_hh(o, n, m, l, p[g + 13], 4, 681279174);
l = md5_hh(l, o, n, m, p[g + 0], 11, -358537222);
m = md5_hh(m, l, o, n, p[g + 3], 16, -722521979);
n = md5_hh(n, m, l, o, p[g + 6], 23, 76029189);

㈢ 1+2+3+...100之和,用傳統流程圖描述演算法,轉為C語言源程序

一.1+2+3+...100之和,用傳統流程圖描述演算法是：
1.輸入S=1,n=1
2.n=n+1,S=S+n
3.判斷n是否=100,如果是,那麼,go
to
4
如果不是,那麼：go
to
2
4.輸出結果S
二.轉為C語言源程序
#include
void
main()
{
int
sum
=
0;
int
i
=
1;
while(i
<=
100)
{
sum
+=
i++;
}
printf("Result:
%d",sum);
}

㈣ MATLAB編遺傳演算法源程序

遺傳演算法實例:

也是自己找來的，原代碼有少許錯誤，本人都已更正了，調試運行都通過了的。
對於初學者，尤其是還沒有編程經驗的非常有用的一個文件
遺傳演算法實例

% 下面舉例說明遺傳演算法 %
% 求下列函數的最大值 %
% f(x)=10*sin(5x)+7*cos(4x) x∈[0,10] %
% 將 x 的值用一個10位的二值形式表示為二值問題，一個10位的二值數提供的解析度是每為 (10-0)/(2^10-1)≈0.01 。 %
% 將變數域 [0,10] 離散化為二值域 [0,1023], x=0+10*b/1023, 其中 b 是 [0,1023] 中的一個二值數。 %
% %
%--------------------------------------------------------------------------------------------------------------%
%--------------------------------------------------------------------------------------------------------------%

% 編程
%-----------------------------------------------
% 2.1初始化(編碼)
% initpop.m函數的功能是實現群體的初始化，popsize表示群體的大小，chromlength表示染色體的長度(二值數的長度)，
% 長度大小取決於變數的二進制編碼的長度(在本例中取10位)。
%遺傳演算法子程序
%Name: initpop.m
%初始化
function pop=initpop(popsize,chromlength)
pop=round(rand(popsize,chromlength)); % rand隨機產生每個單元為 {0,1} 行數為popsize，列數為chromlength的矩陣，
% roud對矩陣的每個單元進行圓整。這樣產生的初始種群。

% 2.2 計算目標函數值
% 2.2.1 將二進制數轉化為十進制數(1)
%遺傳演算法子程序
%Name: decodebinary.m
%產生 [2^n 2^(n-1) ... 1] 的行向量，然後求和，將二進制轉化為十進制
function pop2=decodebinary(pop)
[px,py]=size(pop); %求pop行和列數
for i=1:py
pop1(:,i)=2.^(py-i).*pop(:,i);
end
pop2=sum(pop1,2); %求pop1的每行之和

% 2.2.2 將二進制編碼轉化為十進制數(2)
% decodechrom.m函數的功能是將染色體(或二進制編碼)轉換為十進制，參數spoint表示待解碼的二進制串的起始位置
% (對於多個變數而言，如有兩個變數，採用20為表示，每個變數10為，則第一個變數從1開始，另一個變數從11開始。本例為1)，
% 參數1ength表示所截取的長度（本例為10）。
%遺傳演算法子程序
%Name: decodechrom.m
%將二進制編碼轉換成十進制
function pop2=decodechrom(pop,spoint,length)
pop1=pop(:,spoint:spoint+length-1);
pop2=decodebinary(pop1);

% 2.2.3 計算目標函數值
% calobjvalue.m函數的功能是實現目標函數的計算，其公式採用本文示例模擬，可根據不同優化問題予以修改。
%遺傳演算法子程序
%Name: calobjvalue.m
%實現目標函數的計算
function [objvalue]=calobjvalue(pop)
temp1=decodechrom(pop,1,10); %將pop每行轉化成十進制數
x=temp1*10/1023; %將二值域 中的數轉化為變數域 的數
objvalue=10*sin(5*x)+7*cos(4*x); %計算目標函數值

% 2.3 計算個體的適應值
%遺傳演算法子程序
%Name:calfitvalue.m
%計算個體的適應值
function fitvalue=calfitvalue(objvalue)
global Cmin;
Cmin=0;
[px,py]=size(objvalue);
for i=1:px
if objvalue(i)+Cmin>0
temp=Cmin+objvalue(i);
else
temp=0.0;
end
fitvalue(i)=temp;
end
fitvalue=fitvalue';

% 2.4 選擇復制
% 選擇或復制操作是決定哪些個體可以進入下一代。程序中採用賭輪盤選擇法選擇，這種方法較易實現。
% 根據方程 pi=fi/∑fi=fi/fsum ，選擇步驟：
% 1） 在第 t 代，由（1）式計算 fsum 和 pi
% 2） 產生 {0,1} 的隨機數 rand( .)，求 s=rand( .)*fsum
% 3） 求 ∑fi≥s 中最小的 k ，則第 k 個個體被選中
% 4） 進行 N 次2）、3）操作，得到 N 個個體，成為第 t=t+1 代種群
%遺傳演算法子程序
%Name: selection.m
%選擇復制
function [newpop]=selection(pop,fitvalue)
totalfit=sum(fitvalue); %求適應值之和
fitvalue=fitvalue/totalfit; %單個個體被選擇的概率
fitvalue=cumsum(fitvalue); %如 fitvalue=[1 2 3 4]，則 cumsum(fitvalue)=[1 3 6 10]
[px,py]=size(pop);
ms=sort(rand(px,1)); %從小到大排列
fitin=1;
newin=1;
while newin<=px
if(ms(newin))<fitvalue(fitin)
newpop(newin)=pop(fitin);
newin=newin+1;
else
fitin=fitin+1;
end
end

% 2.5 交叉
% 交叉(crossover)，群體中的每個個體之間都以一定的概率 pc 交叉，即兩個個體從各自字元串的某一位置
% （一般是隨機確定）開始互相交換，這類似生物進化過程中的基因分裂與重組。例如，假設2個父代個體x1，x2為：
% x1=0100110
% x2=1010001
% 從每個個體的第3位開始交叉，交又後得到2個新的子代個體y1，y2分別為：
% y1＝0100001
% y2＝1010110
% 這樣2個子代個體就分別具有了2個父代個體的某些特徵。利用交又我們有可能由父代個體在子代組合成具有更高適合度的個體。
% 事實上交又是遺傳演算法區別於其它傳統優化方法的主要特點之一。
%遺傳演算法子程序
%Name: crossover.m
%交叉
function [newpop]=crossover(pop,pc)
[px,py]=size(pop);
newpop=ones(size(pop));
for i=1:2:px-1
if(rand<pc)
cpoint=round(rand*py);
newpop(i,:)=[pop(i,1:cpoint),pop(i+1,cpoint+1:py)];
newpop(i+1,:)=[pop(i+1,1:cpoint),pop(i,cpoint+1:py)];
else
newpop(i,:)=pop(i);
newpop(i+1,:)=pop(i+1);
end
end

% 2.6 變異
% 變異(mutation)，基因的突變普遍存在於生物的進化過程中。變異是指父代中的每個個體的每一位都以概率 pm 翻轉，即由「1」變為「0」，
% 或由「0」變為「1」。遺傳演算法的變異特性可以使求解過程隨機地搜索到解可能存在的整個空間，因此可以在一定程度上求得全局最優解。
%遺傳演算法子程序
%Name: mutation.m
%變異
function [newpop]=mutation(pop,pm)
[px,py]=size(pop);
newpop=ones(size(pop));
for i=1:px
if(rand<pm)
mpoint=round(rand*py);
if mpoint<=0
mpoint=1;
end
newpop(i)=pop(i);
if any(newpop(i,mpoint))==0
newpop(i,mpoint)=1;
else
newpop(i,mpoint)=0;
end
else
newpop(i)=pop(i);
end
end

% 2.7 求出群體中最大得適應值及其個體
%遺傳演算法子程序
%Name: best.m
%求出群體中適應值最大的值
function [bestindivial,bestfit]=best(pop,fitvalue)
[px,py]=size(pop);
bestindivial=pop(1,:);
bestfit=fitvalue(1);
for i=2:px
if fitvalue(i)>bestfit
bestindivial=pop(i,:);
bestfit=fitvalue(i);
end
end

% 2.8 主程序
%遺傳演算法主程序
%Name:genmain05.m
clear
clf
popsize=20; %群體大小
chromlength=10; %字元串長度（個體長度）
pc=0.6; %交叉概率
pm=0.001; %變異概率

pop=initpop(popsize,chromlength); %隨機產生初始群體
for i=1:20 %20為迭代次數
[objvalue]=calobjvalue(pop); %計算目標函數
fitvalue=calfitvalue(objvalue); %計算群體中每個個體的適應度
[newpop]=selection(pop,fitvalue); %復制
[newpop]=crossover(pop,pc); %交叉
[newpop]=mutation(pop,pc); %變異
[bestindivial,bestfit]=best(pop,fitvalue); %求出群體中適應值最大的個體及其適應值
y(i)=max(bestfit);
n(i)=i;
pop5=bestindivial;
x(i)=decodechrom(pop5,1,chromlength)*10/1023;
pop=newpop;
end

fplot('10*sin(5*x)+7*cos(4*x)',[0 10])
hold on
plot(x,y,'r*')
hold off

[z index]=max(y); %計算最大值及其位置
x5=x(index)%計算最大值對應的x值
y=z

【問題】求f(x)=x 10*sin(5x) 7*cos(4x)的最大值，其中0<=x<=9
【分析】選擇二進制編碼，種群中的個體數目為10，二進制編碼長度為20，交叉概率為0.95,變異概率為0.08
【程序清單】
%編寫目標函數
function[sol,eval]=fitness(sol,options)
x=sol(1);
eval=x 10*sin(5*x) 7*cos(4*x);
%把上述函數存儲為fitness.m文件並放在工作目錄下
initPop=initializega(10,[0 9],'fitness');%生成初始種群，大小為10
[x endPop,bPop,trace]=ga([0 9],'fitness',[],initPop,[1e-6 1 1],'maxGenTerm',25,'normGeomSelect',...
[0.08],['arithXover'],[2],'nonUnifMutation',[2 25 3]) %25次遺傳迭代
運算借過為：x =
7.8562 24.8553(當x為7.8562時，f（x）取最大值24.8553)
註：遺傳演算法一般用來取得近似最優解，而不是最優解。
遺傳演算法實例2
【問題】在－5<=Xi<=5,i=1,2區間內，求解
f(x1,x2)=-20*exp(-0.2*sqrt(0.5*(x1.^2 x2.^2)))-exp(0.5*(cos(2*pi*x1) cos(2*pi*x2))) 22.71282的最小值。
【分析】種群大小10，最大代數1000，變異率0.1,交叉率0.3
【程序清單】
％源函數的matlab代碼
function [eval]=f(sol)
numv=size(sol,2);
x=sol(1:numv);
eval=-20*exp(-0.2*sqrt(sum(x.^2)/numv)))-exp(sum(cos(2*pi*x))/numv) 22.71282;
%適應度函數的matlab代碼
function [sol,eval]=fitness(sol,options)
numv=size(sol,2)-1;
x=sol(1:numv);
eval=f(x);
eval=-eval;
%遺傳演算法的matlab代碼
bounds=ones(2,1)*[-5 5];
[p,endPop,bestSols,trace]=ga(bounds,'fitness')
註：前兩個文件存儲為m文件並放在工作目錄下，運行結果為
p =
0.0000 -0.0000 0.0055
大家可以直接繪出f(x)的圖形來大概看看f（x）的最值是多少，也可是使用優化函數來驗證。matlab命令行執行命令：
fplot('x 10*sin(5*x) 7*cos(4*x)',[0,9])
evalops是傳遞給適應度函數的參數，opts是二進制編碼的精度，termops是選擇maxGenTerm結束函數時傳遞個maxGenTerm的參數，即遺傳代數。xoverops是傳遞給交叉函數的參數。mutops是傳遞給變異函數的參數。

【問題】求f(x)=x+10*sin(5x)+7*cos(4x)的最大值，其中0<=x<=9
【分析】選擇二進制編碼，種群中的個體數目為10，二進制編碼長度為20，交叉概率為0.95,變異概率為0.08
【程序清單】
%編寫目標函數
function[sol,eval]=fitness(sol,options)
x=sol(1);
eval=x+10*sin(5*x)+7*cos(4*x);
%把上述函數存儲為fitness.m文件並放在工作目錄下
initPop=initializega(10,[0 9],'fitness');%生成初始種群，大小為10
[x endPop,bPop,trace]=ga([0 9],'fitness',[],initPop,[1e-6 1 1],'maxGenTerm',25,'normGeomSelect',...
[0.08],['arithXover'],[2],'nonUnifMutation',[2 25 3]) %25次遺傳迭代
運算借過為：x =
7.8562 24.8553(當x為7.8562時，f（x）取最大值24.8553)
註：遺傳演算法一般用來取得近似最優解，而不是最優解。
遺傳演算法實例2
【問題】在－5<=Xi<=5,i=1,2區間內，求解
f(x1,x2)=-20*exp(-0.2*sqrt(0.5*(x1.^2+x2.^2)))-exp(0.5*(cos(2*pi*x1)+cos(2*pi*x2)))+22.71282的最小值。
【分析】種群大小10，最大代數1000，變異率0.1,交叉率0.3
【程序清單】
％源函數的matlab代碼
function [eval]=f(sol)
numv=size(sol,2);
x=sol(1:numv);
eval=-20*exp(-0.2*sqrt(sum(x.^2)/numv)))-exp(sum(cos(2*pi*x))/numv)+22.71282;
%適應度函數的matlab代碼
function [sol,eval]=fitness(sol,options)
numv=size(sol,2)-1;
x=sol(1:numv);
eval=f(x);
eval=-eval;
%遺傳演算法的matlab代碼
bounds=ones(2,1)*[-5 5];
[p,endPop,bestSols,trace]=ga(bounds,'fitness')
註：前兩個文件存儲為m文件並放在工作目錄下，運行結果為
p =
0.0000 -0.0000 0.0055
大家可以直接繪出f(x)的圖形來大概看看f（x）的最值是多少，也可是使用優化函數來驗證。matlab命令行執行命令：
fplot('x+10*sin(5*x)+7*cos(4*x)',[0,9])
evalops是傳遞給適應度函數的參數，opts是二進制編碼的精度，termops是選擇maxGenTerm結束函數時傳遞個maxGenTerm的參數，即遺傳代數。xoverops是傳遞給交叉函數的參數。mutops是傳遞給變異函數的參數。

㈤ 求一個c++的用lzw（字典）演算法來壓縮bmp圖片的代碼

參見gif壓縮演算法源代碼。

1.LZW的全稱是什麼?
Lempel-Ziv-Welch (LZW).
2. LZW的簡介和壓縮原理是什麼？
LZW壓縮演算法是一種新穎的壓縮方法，由Lemple-Ziv-Welch 三人共同創造，用他們的名字命名。它採用了一種先進的串表壓縮，將每個第一次出現的串放在一個串表中，用一個數字來表示串，壓縮文件只存貯數字，則不存貯串，從而使圖象文件的壓縮效率得到較大的提高。奇妙的是，不管是在壓縮還是在解壓縮的過程中都能正確的建立這個串表，壓縮或解壓縮完成後，這個串表又被丟棄。
LZW演算法中，首先建立一個字元串表，把每一個第一次出現的字元串放入串表中，並用一個數字來表示，這個數字與此字元串在串表中的位置有關，並將這個數字存入壓縮文件中，如果這個字元串再次出現時，即可用表示它的數字來代替，並將這個數字存入文件中。壓縮完成後將串表丟棄。如"print" 字元串，如果在壓縮時用266表示，只要再次出現，均用266表示，並將"print"字元串存入串表中，在圖象解碼時遇到數字266，即可從串表中查出266所代表的字元串"print"，在解壓縮時，串表可以根據壓縮數據重新生成。
3.在詳細介紹演算法之前，先列出一些與該演算法相關的概念和詞彙
1)'Character': 字元，一種基礎數據元素，在普通文本文件中，它佔用1個單獨的byte，而在圖像中，它卻是 一種代表給定像素顏色的索引值。
2)'CharStream'：數據文件中的字元流。
3)'Prefix':前綴。如這個單詞的含義一樣，代表著在一個字元最直接的前一個字元。一個前綴字元長度可以為0,一個prefix和一個character可以組成一個字元串(string),
4)'Suffix': 後綴，是一個字元，一個字元串可以由(A,B)來組成，A是前綴,B是後綴,當A長度為0的時候，代表Root，根
5)'Code:碼,用於代表一個字元串的位置編碼
6)'Entry'，一個Code和它所代表的字元串(string)
4.壓縮演算法的簡單示例，不是完全實現LZW演算法，只是從最直觀的角度看lzw演算法的思想
對原始數據ABCCAABCDDAACCDB進行LZW壓縮
原始數據中，只包括4個字元(Character),A,B,C,D,四個字元可以用一個2bit的數表示，0-A,1-B,2-C,3-D,從最直觀的角度看，原始字元串存在重復字元：ABCCAABCDDAACCDB，用4代表AB,5代表CC，上面的字元串可以替代表示為:45A4CDDAA5DB,這樣是不是就比原數據短了一些呢！
5.LZW演算法的適用范圍
為了區別代表串的值(Code)和原來的單個的數據值(String)，需要使它們的數值域不重合，上面用0-3來代表A-D,那麼AB就必須用大於3的數值來代替，再舉另外一個例子，原來的數值范圍可以用8bit來表示，那麼就認為原始的數的范圍是0～255，壓縮程序生成的標號的范圍就不能為0～255（如果是0-255，就重復了）。只能從256開始，但是這樣一來就超過了8位的表示範圍了，所以必須要擴展數據的位數，至少擴展一位，但是這樣不是增加了1個字元佔用的空間了么？但是卻可以用一個字元代表幾個字元，比如原來255是8bit,但是現在用256來表示254，255兩個數，還是劃得來的。從這個原理可以看出LZW演算法的適用范圍是原始數據串最好是有大量的子串多次重復出現，重復的越多，壓縮效果越好。反之則越差，可能真的不減反增了。
6.LZW演算法中特殊標記
隨著新的串(string)不斷被發現，標號也會不斷地增長，如果原數據過大，生成的標號集（string table)會越來越大，這時候操作這個集合就會產生效率問題。如何避免這個問題呢?Gif在採用lzw演算法的做法是當標號集足夠大的時候，就不能增大了，乾脆從頭開始再來，在這個位置要插入一個標號，就是清除標志CLEAR，表示從這里我重新開始構造字典，以前的所有標記作廢，開始使用新的標記。
這時候又有一個問題出現，足夠大是多大？這個標號集的大小為比較合適呢？理論上是標號集大小越大，則壓縮比率就越高，但開銷也越高。 一般根據處理速度和內存空間連個因素來選定。GIF規范規定的是12位，超過12位的表達范圍就推倒重來，並且GIF為了提高壓縮率，採用的是變長的字長。比如說原始數據是8位，那麼一開始，先加上一位再說，開始的字長就成了9位，然後開始加標號，當標號加到512時，也就是超過9為所能表達的最大數據時，也就意味著後面的標號要用10位字長才能表示了，那麼從這里開始，後面的字長就是10位了。依此類推，到了2^12也就是4096時，在這里插一個清除標志，從後面開始，從9位再來。
GIF規定的清除標志CLEAR的數值是原始數據字長表示的最大值加1，如果原始數據字長是8，那麼清除標志就是256，如果原始數據字長為4那麼就是16。另外GIF還規定了一個結束標志END，它的值是清除標志CLEAR再加1。由於GIF規定的位數有1位（單色圖），4位（16色）和8位（256色），而1位的情況下如果只擴展1位，只能表示4種狀態，那麼加上一個清除標志和結束標志就用完了，所以1位的情況下就必須擴充到3位。其它兩種情況初始的字長就為5位和9位。此處參照了http://blog.csdn.net/whycadi/
7.用lzw演算法壓縮原始數據的示例分析
輸入流，也就是原始的數據為:255,24,54,255,24,255,255,24,5,123,45,255,24,5,24,54..................
這個正好可以看到是gif文件中像素數組的一部分，如何對它進行壓縮
因為原始數據可以用8bit來表示，故清除標志Clear=255+1 =256,結束標志為End=256+1=257，目前標號集為
0 1 2 3 .................................................................................255 CLEAR END
第一步,讀取第一個字元為255,在標記表裡面查找，255已經存在，我們已經認識255了，不做處理
第二步,取第二個字元，此時前綴為A,形成當前的Entry為(255,24),在標記集合不存在，我們並不認識255,24好，這次你小子來了，我就記住你，把它在標記集合中標記為258,然後輸出前綴A,保留後綴24，並作為下一次的前綴（後綴變前綴)
第三步，取第三個字元為54，當前Entry(24,54),不認識，記錄(24,54)為標號259,並輸出24,後綴變前綴
第四部：取第四個字元255,Entry=(54,255),不認識，記錄(54,255)為標號260,輸出54,後綴變前綴
第五步 取第5個字元24，entry=(255,24),啊，認識你，這不是老258么，於是把字元串規約為258，並作為前綴
第六步 取第六個字元255,entry=(258,255)，不認識，記錄(258,255)為261,輸出258,後綴變前綴
.......
一直處理到最後一個字元,
用一個表記錄處理過程
CLEAR=256,END=257
第幾步 前綴 後綴 Entry 認識(Y/N) 輸出 標號
1 255 （，255）
2 255 24 (255,24) N 255 258
3 24 54 (24,54) N 24 259
4 54 255 (54,255) N 54 260
5 255 24 (255,24) Y
6 258 255 (258,255) N 258 261
7 255 255 (255,255) N 255 262
.....
上面這個示例有些不能完整體現，另外一個例子是
原輸入數據為:A B A B A B A B B B A B A B A A C D A C D A D C A B A A A B A B .....
採用LZW演算法對其進行壓縮，壓縮過程用一個表來表述為:
注意原數據中只包含4個character,A,B,C,D
用兩bit即可表述，根據lzw演算法，首先擴展一位變為3為,Clear=2的2次方+1=4; End=4+1=5;
初始標號集因該為

0 1 2 3 4 5
A B C D Clear End

而壓縮過程為:

第幾步 前綴 後綴 Entry 認識(Y/N) 輸出 標號
1 A （，A）
2 A B (A,B) N A 6
3 B A (B,A) N B 7
4 A B (A,B) Y
5 6 A (6,A) N 6 8
6 A B (A,B) Y
7 6 A (6,A) Y
8 8 B (8,B) N 8 9
9 B B (B,B) N B 10
10 B B (B,B) Y
11 10 A (10,A) N 10 11
12 A B (A,B) Y

.....
當進行到第12步的時候，標號集應該為

0 1 2 3 4 5 6 7 8 9 10 11
A B C D Clear End AB BA 6A 8B BB 10A

8.LZW演算法的偽代碼實現

1STRING = get input character
2WHILE there are still input characters DO
3 CHARACTER = get input character
4 IF STRING+CHARACTER is in the string table then
5 STRING = STRING+character
6 ELSE
7 output the code for STRING
8 add STRING+CHARACTER to the string table
9 STRING = CHARACTER
10 END of IF
11END of WHILE
12output the code for STRING
13

㈥ 用鄰接表表示的圖的輸出(PrintGraph)的演算法(C語言)

單鏈表類中的輸出流函數重載，輸出鏈表
圖類中再次重載輸出流函數。
一次頂點表的循環，輸出。
結果：<<start,dest,weight>,<。。。>>

㈦ 數據結構與演算法演示系統完整簡單的c++源代碼，包哈內容有：線性表、二叉樹、圖、排序，急用！謝謝！

我有表和二叉樹的，圖和排序沒有！那玩意不能簡單的，一個就得100多行！而且只是。h文件。先給你2個吧！
#ifndef SQLIST_H
#define SQLIST_H
using namespace std;
template<class elemtype>
class sqlist
{
public:
sqlist(){head=NULL; n=0;}
virtual ~sqlist(){head=NULL;}
bool insert(const elemtype& ,int);
elemtype find(int );
void clear();
int length()const {return n;}
bool Delete(int );
protected:
int n;
struct node{
node *next;
elemtype data;
};
node *head;
};
template<class elemtype>
void sqlist<elemtype>::clear()
{
node *p,*q;
int i=1;
p=head;
while(i!=n)
{
q=p;
delete q;
p=p->next;
i++;
}
}
template<class elemtype>
bool sqlist<elemtype>::insert(const elemtype &e,int i)
{
node *p,*q;
int j=1;
if(head==NULL)
head=new node;
p=head;
if(i==1&&i>n)//表頭賦值
{head->data=e;
n++;
return true;}
else if(i==1&&i<=n)//表頭插入
{
head=new node;
head->data=e;
head->next=p;
n++;
return true;
}
else if(i<=n) //表中插入
{
q=new node;
q->data=e;
while(j<i-1){
p=p->next;
j++;
}
q->next=p->next;
p->next=q;
n++;
return true;}
else if(i==n+1&&i!=1)//表尾插入
{
q=new node;
q->data=e;
while (j<n)
{
p=p->next;
j++;
}
p->next=q;
q->next=NULL;
n++;
return true;}
else
return false;
}
template<class elemtype>
elemtype sqlist<elemtype>::find(int i)
{
int j=1;
node *p;
p=head;
while(j<i){
p=p->next;
j++;
}
return p->data;
}
template<class elemtype>
bool sqlist<elemtype>::Delete(int i)
{
int j=1;
node *p,*q;
p=head;
if(i!=1)//表中及表尾刪除
{
while(j<i)
{
q=p;
p=p->next;
j++;
}
q->next=p->next;
delete p;
n--;
return true;}
else//表頭刪除
head=p->next;
delete p;
n--;
return true;
}
#endif // SQLIST_H
#ifndef binarytree_H
#define binarytree_H
#include"stack.h"
#include"queue.h"
using namespace std;
template<class elemtype>
class binarytree{
public:
binarytree(){root=NULL;}
~binarytree(){}
int height(){return height(root);}
int size(){return size(root);}
void createtree(elemtype flag);
void preorder() const ;
void midorder() const ;
void postorder() const ;
bool isempty(){return root==NULL;}
void clear(){if (root!=NULL) clear(root);}
void delleft(){ clear(root->left);}
int height()const{return height(root );}
void delright(){return clear(root->right);}
private:
struct node{
node *left,*right;
elemtype data;
node():left(NULL),right(NULL){}
node(elemtype it,node*l=NULL,node*r=NULL):data(it),left(l),right(r){}
};
node *root;
struct stnode{
node *t;
int step;
stnode(node *tc=NULL):t(tc),step(0){}
};
void clear(node *);
int size(node* );
int height(node*);
};
template<class elemtype>
void binarytree<elemtype>:: clear(node *t)
{
queue<node> la;
node *tem,*q,*p;
la.append(t);
while(!la.empty()){
tem=la.putelem();
if(tem->left!=NULL)
{ p=t->left;
la.append(p);}
if(tem->right!=NULL)
{ q=tem->right;
la.append(q);}
delete tem;
}
}
template<class elemtype>
void binarytree<elemtype>::createtree(elemtype flag)
{
queue<node*> la;
node *tem;
elemtype x,ldata,rdata;
cout<<"根節點：";
cin>>x;
root=new node(x);
la.append(root);
while(!la.isempty()){
tem=la.putelem();
cout<<"輸入"<<tem->data<<"的兩節點值：";
cin>>ldata>>rdata;
if(ldata!=flag) la.append(tem->left=new node(ldata));
if(rdata!=flag) la.append(tem->right=new node(rdata));
}
}
template<class elemtype>
void binarytree<elemtype>::preorder( )const
{
stack<node*> la;
node *tem;
cout<<"前序遍歷為：";
la.push(root);
while(!la.empty()){
tem=la.pop();
cout<<tem->data<<" ";
if(tem->right!=NULL)
la.push(tem->right);
if(tem->left!=NULL)
la.push(tem->left);
}
}
template<class elemtype>
void binarytree<elemtype>::midorder() const
{
stack<stnode> la;
stnode tem(root);
cout<<"中序遍歷：";
la.push(tem);
while(!la.empty()){
tem=la.pop();
if(++tem.step==2){
cout<<tem.t->data<<" ";
if(tem.t->right!=NULL)
la.push(stnode(tem.t->right));}
else{
la.push(tem);
if(tem.t->left!=NULL)
la.push(stnode(tem.t->left));
}
}
}
template<class elemtype>
void binarytree<elemtype>::postorder() const
{
stack<stnode> la;
stnode tem(root);
cout<<"後序遍歷：";
la.push(tem);
while(!la.empty()){
tem=la.pop();
if(++tem.step==3)
{cout<<tem.t->data<<" ";continue;}
la.push(tem);
if(tem.step==1)
{
if(tem.t->left!=NULL)
la.push(stnode(tem.t->left));
}
else{
if(tem.t->right!=NULL)
la.push(stnode(tem.t->right));
}
}
}
template<class elemtype>
int binarytree<elemtype>::size(node *t)
{
queue<node*> la;
node *tem;
int a=0;
la.append(t);
while(!la.isempty()){
tem=la.putelem();
a++;
if(tem->left!=NULL)
la.append(tem->left);
if(tem->right!=NULL)
la.append(tem->right);
}
return a;
}
template<class elemtype>
int binarytree<elemtype>::height(node* t)const
{
queue<node*> la;
atack<node*> lb;
node *tmp;
la.append(t);
while(!la.isempty())
{
tmp=la.putelem();
if(tmp->left)
}
/*if(t==NULL) return 0;
else
{
int l=height(t->left),r=height(t->right);
return 1+((l>r)?l:r);
}*/
}
｝
你還不如用stl！而且你要這玩意干什麼？c++書里都有的，實在不行自己抄書不也行嗎？c++的表分單鏈表，循環單鏈表，循環雙鏈表（我給的只是單鏈表）。二叉樹我自己用的非遞歸實現，除了求高度。但要用到棧和隊列，你自己寫吧，太多了！發著麻煩。

㈧ 演算法與源程序的區別

演算法與源程序的區別如下：

一、形式不同

1、演算法：演算法在描述上一般使用半形式化的語言。

2、程序：程序是用形式化的計算機語言描述的。

二、性質不同

1、演算法：演算法是解決問題的步驟。

2、程序：程序是演算法的代碼實現。

三、特點不同

1、演算法：演算法要依靠程序來完成功能。

2、程序：程序需要演算法作為靈魂。

演算法（解題方案的准確而完整的描述）：

演算法（Algorithm）是指解題方案的准確而完整的描述，是一系列解決問題的清晰指令，演算法代表著用系統的方法描述解決問題的策略機制。也就是說，能夠對一定規范的輸入，在有限時間內獲得所要求的輸出。

如果一個演算法有缺陷，或不適合於某個問題，執行這個演算法將不會解決這個問題。不同的演算法可能用不同的時間、空間或效率來完成同樣的任務。一個演算法的優劣可以用空間復雜度與時間復雜度來衡量。

演算法中的指令描述的是一個計算，當其運行時能從一個初始狀態和（可能為空的）初始輸入開始，經過一系列有限而清晰定義的狀態，最終產生輸出並停止於一個終態。一個狀態到另一個狀態的轉移不一定是確定的。隨機化演算法在內的一些演算法，包含了一些隨機輸入。

形式化演算法的概念部分源自嘗試解決希爾伯特提出的判定問題，並在其後嘗試定義有效計算性或者有效方法中成形。