1. 求C++的dijkstra算法或者floyd算法的参考源代码
floyd算法看这里:http://www.bigcircleboy.com/0e6f866f-9506-4b61-ad88-0dc9bab9408c6084313157712208.html
2. 求《数据结构》严尉敏版 c语言算法源代码
不好，学习数据结构最重要的就是自己动手实现算法，这样才能深入理解算法的精髓，还是建议自己做，做的过程中有什么问题可以及时提问。
3. 急求：初识A*算法 这个的源代码！！
#include <iostream>
#include <cmath>
using namespace std;
struct tnode{
int gvalue;//以下3个参数是估计函数
int hvalue;
int fvalue;
tnode* parent;//不是父节点，而是指向当前节点
tnode* next;//指向链表的下一个节点
int pass;
int nodevalue;//唯一标示节点
};
tnode table[5][5];//存储地图5*5
int startx,starty,endx,endy;
tnode openlist,closelist;
void computervalue(const int curx,const int cury);
int intsearch(tnode *plist,int value);//C++需要int
void addopenlist(int hx,int hy);
void handlenode(int hx,int hy,int curx,int cury);
void main()
{
tnode *pp;
int x,y;
int i,j;//要定义
for ( i=0;i<=4;i++)//初始化
for ( j=0;j<=4;j++)
{
table[i][j].gvalue=0;
table[i][j].hvalue=0;
table[i][j].fvalue=0;
table[i][j].parent=0;
table[i][j].next=0;
table[i][j].pass=1;
table[i][j].nodevalue=(i+1)*(j+1);
}
cout<<"输入不可以通过的位置，格式为坐标X 坐标Y"<<endl;
for (i=1;i<=3;i++)
{
cin>>x>>y;
table[x][y].pass=0;
}
cout<<"输入起始的位置，格式为坐标X 坐标Y"<<endl;
cin>>startx>>starty;
cout<<"输入结束的位置，格式为坐标X 坐标Y"<<endl;
cin>>endx>>endy;
for (i=0;i<=4;i++)//打印地图结构
{
cout<<endl;
for (int k=0;k<=4;k++)
cout<<table[i][k].pass;
}
computervalue(startx,starty);
pp=&table[endx][endy];
while(pp->parent)
{
pp=pp->next;
cout<<pp->parent->nodevalue<<"=>";
}
system("pause");
}
//遍历链表，判段是否在列表中，找到返回1，否则返回0
int search(tnode *plist,int value)
{
while( (value!=plist->nodevalue) && plist->next)
plist=plist->next;
if(plist==0)
return 0;
else
return 1;
}
//把table[hx][hy]加入openlist有序链表
void addopenlist(int hx,int hy)
{
tnode *plist,*qlist=0;
plist=openlist.next;
while((plist->next!=0) && plist->nodevalue<(hx+1)*(hy+1) )
{
qlist=plist;
plist=plist->next;
}
table[hx][hy].next=qlist->next;
qlist->next=&table[hx][hy];
}
void handlenode(int hx,int hy,int curx,int cury)
{//对每一个相邻节点执行以下操作
/*1.如果该相邻节点不可通行或者该相邻节点已经在封闭列表中,
则什么操作也不执行,继续检验下一个节点;
2如果该相邻节点不在开放列表中,
则将该节点添加到开放列表中, 并将该相邻节点的父节点设为当前节点,
同时保存该相邻节点的G和F值;
3.如果该相邻节点在开放列表中,
则判断若经由当前节点到达该相邻节点的G值是否小于原来保存的G值,
若小于,则将该相邻节点的父节点设为当前节点,并重新设置该相邻节点的G和F值.
*/
if(!search(&openlist,(hx+1)*(hy+1)) && table[hx][hy].pass!=0)
{//不在openlist中
addopenlist(hx,hy);
table[hx][hy].parent=&table[curx][cury];
if(abs(curx-hx)+abs(cury-hy)==2)//计算gvalue值，因为传过来的hx，hy已经做过处理，这里只是处理+1，+2
table[hx][hy].gvalue+=2;
else table[hx][hy].gvalue+=1;
table[hx][hy].hvalue=(curx-hx)+(cury-hy);//计算hvalue
table[hx][hy].fvalue=table[hx][hy].gvalue+table[hx][hy].hvalue;//计算fvalue
}
else if(search(&openlist,(hx+1)*(hy+1)) && table[hx][hy].pass!=0)
{ //在openlist中
int tempx;//存放比较的中间值
if(abs(curx-hx)+abs(cury-hy)==2)
tempx=table[hx][hy].gvalue+2;
else tempx=table[hx][hy].gvalue+1;
if(tempx<table[hx][hy].gvalue)//判断是否更新
table[hx][hy].gvalue=tempx;
table[hx][hy].hvalue=(curx-hx)+(cury-hy);//计算hvalue
table[hx][hy].fvalue=table[hx][hy].gvalue+table[hx][hy].hvalue;//更新fvalue
}
}
void computervalue(int curx,int cury)
{//对每一个当前节点执行以下操作
if(curx==0)
{
if(cury==0)
{
handlenode(curx,cury+1,curx,cury);
handlenode(curx+1,cury,curx,cury);
handlenode(curx+1,cury+1,curx,cury);
}
else if(cury==4)
{
handlenode(curx-1,cury,curx,cury);
handlenode(curx,cury-1,curx,cury);
handlenode(curx-1,cury-1,curx,cury);
}
else
{
handlenode(curx,cury-1,curx,cury);
handlenode(curx,cury+1,curx,cury);
handlenode(curx+1,cury-1,curx,cury);
handlenode(curx+1,cury,curx,cury);
handlenode(curx+1,cury+1,curx,cury);
}
}
else if(curx==4)
{
if(cury==0)
{
handlenode(curx-1,cury,curx,cury);
//table[curx-1][cury].gvalue+=1;
handlenode(curx,cury+1,curx,cury);
handlenode(curx-1,cury+1,curx,cury);
}
else if(cury==4)
{
handlenode(curx-1,cury-1,curx,cury);
handlenode(curx-1,cury,curx,cury);
handlenode(curx,cury-1,curx,cury);
}
else
{
handlenode(curx,cury-1,curx,cury);
handlenode(curx,cury+1,curx,cury);
handlenode(curx-1,cury-1,curx,cury);
handlenode(curx-1,cury,curx,cury);
handlenode(curx-1,cury+1,curx,cury);
}
}
else if(cury==0)
{
handlenode(curx-1,cury,curx,cury);
handlenode(curx+1,cury,curx,cury);
handlenode(curx-1,cury+1,curx,cury);
handlenode(curx,cury+1,curx,cury);
handlenode(curx+1,cury+1,curx,cury);
}
else if(cury==4)
{
handlenode(curx-1,cury-1,curx,cury);
handlenode(curx,cury-1,curx,cury);
handlenode(curx+1,cury-1,curx,cury);
handlenode(curx-1,cury,curx,cury);
handlenode(curx+1,cury,curx,cury);
}
else
{
handlenode(curx,cury+1,curx,cury);
handlenode(curx+1,cury,curx,cury);
handlenode(curx+1,cury+1,curx,cury);
handlenode(curx-1,cury,curx,cury);
handlenode(curx-1,cury-1,curx,cury);
handlenode(curx-1,cury+1,curx,cury);
handlenode(curx,cury-1,curx,cury);
handlenode(curx+1,cury-1,curx,cury);
}
}
4. A*算法C＋＋源程序
A*算法在人工智能中是一种典型的启发式搜索算法，为了说清楚A*算法，我看还是先说说何谓启发式算法。
一、何谓启发式搜索算法
在说它之前先提提状态空间搜索。状态空间搜索，如果按专业点的说法就是将问题求解过程表现为从初始状态到目标状态寻找这个路径的过程。通俗点说，就是在解一个问题时，找到一条解题的过程可以从求解的开始到问题的结果（好象并不通俗哦）。由于求解问题的过程中分枝有很多，主要是求解过程中求解条件的不确定性，不完备性造成的，使得求解的路径很多这就构成了一个图，我们说这个图就是状态空间。问题的求解实际上就是在这个图中找到一条路径可以从开始到结果。这个寻找的过程就是状态空间搜索。
常用的状态空间搜索有深度优先和广度优先。广度优先是从初始状态一层一层向下找，直到找到目标为止。深度优先是按照一定的顺序前查找完一个分支，再查找另一个分支，以至找到目标为止。这两种算法在数据结构书中都有描述，可以参看这些书得到更详细的解释。
前面说的广度和深度优先搜索有一个很大的缺陷就是他们都是在一个给定的状态空间中穷举。这在状态空间不大的情况下是很合适的算法，可是当状态空间十分大，且不预测的情况下就不可取了。他的效率实在太低，甚至不可完成。在这里就要用到启发式搜索了。
启发式搜索就是在状态空间中的搜索对每一个搜索的位置进行评估，得到最好的位置，再从这个位置进行搜索直到目标。这样可以省略大量无畏的搜索路径，提到了效率。在启发式搜索中，对位置的估价是十分重要的。采用了不同的估价可以有不同的效果。我们先看看估价是如何表示的。
启发中的估价是用估价函数表示的，如：
f(n) = g(n) + h(n)
其中f(n)是节点n的估价函数，g(n)实在状态空间中从初始节点到n节点的实际代价，h(n)是从n到目标节点最佳路径的估计代价。在这里主要是h(n)体现了搜索的启发信息，因为g(n)是已知的。如果说详细点，g(n)代表了搜索的广度的优先趋势。但是当h(n)>>g(n)时，可以省略g(n),而提高效率。这些就深了，不懂也不影响啦！我们继续看看何谓A*算法。
二、初识A*算法
启发式搜索其实有很多的算法，比如：局部择优搜索法、最好优先搜索法等等。当然A*也是。这些算法都使用了启发函数，但在具体的选取最佳搜索节点时的策略不同。象局部择优搜索法，就是在搜索的过程中选取“最佳节点”后舍弃其他的兄弟节点，父亲节点，而一直得搜索下去。这种搜索的结果很明显，由于舍弃了其他的节点，可能也把最好的节点都舍弃了，因为求解的最佳节点只是在该阶段的最佳并不一定是全局的最佳。最好优先就聪明多了，他在搜索时，便没有舍弃节点（除非该节点是死节点），在每一步的估价中都把当前的节点和以前的节点的估价值比较得到一个“最佳的节点”。这样可以有效的防止“最佳节点”的丢失。那么A*算法又是一种什么样的算法呢？其实A*算法也是一种最好优先的算法。只不过要加上一些约束条件罢了。由于在一些问题求解时，我们希望能够求解出状态空间搜索的最短路径，也就是用最快的方法求解问题，A*就是干这种事情的！我们先下个定义，如果一个估价函数可以找出最短的路径，我们称之为可采纳性。A*算法是一个可采纳的最好优先算法。A*算法的估价函数可表示为：
f'(n) = g'(n) + h'(n)
这里，f'(n)是估价函数，g'(n)是起点到终点的最短路径值，h'(n)是n到目标的最断路经的启发值。由于这个f'(n)其实是无法预先知道的，所以我们用前面的估价函数f(n)做近似。g(n)代替g'(n)，但g(n)>=g'(n)才可（大多数情况下都是满足的，可以不用考虑），h(n)代替h'(n)，但h(n)<=h'(n)才可（这一点特别的重要）。可以证明应用这样的估价函数是可以找到最短路径的，也就是可采纳的。我们说应用这种估价函数的最好优先算法就是A*算法。哈！你懂了吗？肯定没懂！接着看！
举一个例子，其实广度优先算法就是A*算法的特例。其中g(n)是节点所在的层数，h(n)=0，这种h(n)肯定小于h'(n)，所以由前述可知广度优先算法是一种可采纳的。实际也是。当然它是一种最臭的A*算法。
再说一个问题，就是有关h(n)启发函数的信息性。h(n)的信息性通俗点说其实就是在估计一个节点的值时的约束条件，如果信息越多或约束条件越多则排除的节点就越多，估价函数越好或说这个算法越好。这就是为什么广度优先算法的那么臭的原因了，谁叫它的h(n)=0，一点启发信息都没有。但在游戏开发中由于实时性的问题，h(n)的信息越多，它的计算量就越大，耗费的时间就越多。就应该适当的减小h(n)的信息，即减小约束条件。但算法的准确性就差了，这里就有一个平衡的问题。可难了，这就看你的了！
好了我的话也说得差不多了，我想你肯定是一头的雾水了，其实这是写给懂A*算法的同志看的。哈哈！你还是找一本人工智能的书仔细看看吧！我这几百字是不足以将A*算法讲清楚的。
5. 求LZW算法源代码！！
#include<iostream>
#include<cstdio>
#include<cstring>
#include<ctime>//用来计算压缩的时间
using namespace std;
//定义常数
const int MAX = 1000003;//最大code数，是一个素数，求模是速度比较快
const int ascii = 256; //ascii代码的数量
const int ByteSize = 8; //8个字节
struct Element//hash表中的元素
{
int key;
int code;
Element *next;
}*table[MAX];//hash表
int hashfunction(int key)//hash函数
{
return key%MAX;
}
void hashinit(void)//hash表初始化
{
memset(table,0,sizeof(table));
}
void hashinsert(Element element)//hash表的插入
{
int k = hashfunction(element.key);
if(table[k]!=NULL)
{
Element *e=table[k];
while(e->next!=NULL)
{
e=e->next;
}
e->next=new Element;
e=e->next;
e->key = element.key;
e->code = element.code;
e->next = NULL;
}
else
{
table[k]=new Element;
table[k]->key = element.key;
table[k]->code = element.code;
table[k]->next = NULL;
}
}
bool hashfind(int key,Element &element)//hash表的查找
{
int k = hashfunction(key);
if(table[k]!=NULL)
{
Element *e=table[k];
while(e!=NULL)
{
if(e->key == key)
{
element.key = e->key;
element.code = e->code;
return true;
}
e=e->next;
}
return false;
}
else
{
return false;
}
}
void compress(void)//压缩程序
{
//打开一个流供写入
FILE *fp;
fp = fopen("result.dat", "wb");
Element element;
int used;
char c;
int pcode, k;
for(int i=0;i<ascii;i++)
{
element.key = i;
element.code = i;
hashinsert(element);
}
used = ascii;
c = getchar();
pcode = c;
while((c = getchar()) != EOF)
{
k = (pcode << ByteSize) + c;
if(hashfind(k, element))
pcode = element.code;
else
{
//cout<<pcode<<' ';
fwrite(&pcode, sizeof(pcode), 1, fp);
element.code = used++;
element.key = (pcode << ByteSize) | c;
hashinsert(element);
pcode = c;
}
}
//cout<<pcode<<endl;
fwrite(&pcode, sizeof(pcode), 1, fp);
}
int main(void)
{
int t1,t2;
//欲压缩的文本文件
//freopen("input.txt","r",stdin);
freopen("book5.txt","r",stdin);
t1=time(NULL);
hashinit();
compress();
t2=time(NULL);
cout<<"Compress complete! See result.dat."<<endl;
cout<<endl<<"Total use "<<t2-t1<<" seconds."<<endl;
}
6. 求Dijkstra算法的源代码
Dijkstra算法--c++源代码--
#include<iostream.h>
void main()
{
int infinity=100,j,i,n,k,t,**w,*s,*p,*d;
cout<<"input the value of n:";
cin>>n;
cout<<endl;
d=new int[n];
s=new int[n];
p=new int[n];
w=new int*[n];
for(i=0;i<n;i++) {w[i]=new int[n];}
for(i=0;i<n;i++)
for(j=0;j<n;j++)
cin>>w[i][j];
for(s[0]=1,i=1;i<n;i++)
{
s[i]=0;d[i]=w[0][i];
if(d[i]<infinity) p[i]=0;
else p[i]=-1;
}
for(i=1;i<n;i++)
{
t=infinity;k=1;
for(j=1;j<n;j++)
if((!s[j])&&(d[j]<t)) {t=d[j];k=j;}
s[k]=1;//point k join the S
for (j=1;j<n;j++)
if((!s[j])&&(d[j]>d[k]+w[k][j]))
{d[j]=d[k]+w[k][j];p[j]=k;}
}
cout<<"从源点到其它顶点的最短距离依次如下：";
for(i=1;i<n;i++) cout<<d[i]<<" ";
}
/*********
顶点个数用n表示，这里给出的例子n=6
100 1 12 100 100 100
100 100 9 3 100 100
100 100 100 100 5 100
100 100 4 100 13 15
100 100 100 100 100 4
100 100 100 100 100 100
具体例子见 电子工业出版社 《算法设计技巧与分析》148页
************/
7. 有哪位大牛能分享一下ICP（迭代最近点）算法的源代码
你要什么语言实现的，我有visualc++ ,delphi和matlab实现的
8. 数据挖掘算法源代码
已发送，请查收，如果满意，记得加分
9. 哪位高手有elgamal算法源码
ElGamal方法分为密钥生成、加密过程和解密过程进行描述。假设Alice和Bob分别为通信的双方，则：
密钥生成
通信发起一方的Alice按以下方法生成公钥：
Alice通过生成元g和阶q定义一个乘法循环群G；
Alice在集合R={0, 1, 2, ..., q-1}中随机选择一个整数x；
Alice根据群G的生成元和阶生成群中的一个元素h：；
Alice将{G, q, g, h}作为公钥发布，x作为私钥妥善保存。
加密过程
通讯另一方的Bob在加密过程中通过公钥{G, q, g, h}对明文m进行加密(其中1-3步可以事先完成。)：
Bob在集合R={0, 1, 2, ..., q-1}中随机选择一个整数y；
Bob根据{G, q, g, h}生成群中的一个元素 ；
Bob根据 得到对称密钥；(由于Bob每次接收到消息后都会生成s，因此s也称为临时密钥)
Bob将明文m转换为群G中的一个元素 ；(如将特定信息进行编码)
Bob计算 ；
Bob将 作为密文发送。
解密过程
Alice使用私钥x对密文 进行解密，步骤为：
Alice计算 ；
Alice计算群中的元素 ，并将其还原为明文。(将编码还原为信息)
下述等式保证了Alice计算出的编码与Bob转换的编码相同：
10. 急!!!!!!!!!!!!高分求<数据结构及算法经典> 源代码
这个地址绝对好下的,你看看:
http://download.csdn.net/filedown/YXI=!178854
如果不行,发消息给我,传给你.
已经发到你信箱里了,看一下..