数据I算法
1. 数据结构算法问题
该操作ComareOrderList是比较有序表的大小。
个人见解，仅供参考
A，B都应该是有序表
if(A.elem[i]>B.elem[i]) j=1 如果A中的某个元素大于B中对应位序的元素，那么j＝1.
if(A.elem[i]<B.elem[i]) j=-1 如果A中的某个元素小于B中对应位序的元素，那么j＝－1.
j=1表示有序表A大，－1表示有序表A小，0表示A，B相等。
但是我觉得该算法有问题，修改如下：
Status ComareOrderList(SqList &A,SqList &B)
{//比较两个有序表A，B的大小，如果两表长度相等，且对应位序的元素相等，则两表相等函数返回0；若A表某个元素大于B表中对应位序的元素，则A表大返回1；否则A表小，返回－1.
int i,k,j;
if(A.length>B.length) j=1;
else if(A.length<B.length) j=-1;
else { k=A.length;
for(i=0;i<k;i++) {
if(A.elem[i]>B.elem[i])
{ j=1;break;}
if(A.elem[i]<B.elem[i])
{j=-1;break;}
｝
if(i==k) j=0;
}
return j;
}
2. 数据结构中算法的时间复杂度计算
1、s的增长序列为：1,2,3,4，……，所以循环loop次后s=1+2+3+……+loop，s=n时结束循环。
由:1+2+3+……+loop=n 得到： loop=O(sqrt(n));
2、循环loop次后， i=2^loop, 由i=n，得到： loop=log(n);
就是看循环执行了多少次，看执行多少步后i满足循环退出的条件。
3. 数据结构算法，，
A->next=NULL 单独用是没有意义的。
它的作用有几个：
1，A的值，在代码pa=A; qa=pa;的时候已经保存了。这时的A可以理解成为一个自由的变量。
2，可做为C的第一个结点，初始next的值当然是NULL。
3，结合代码看来（qa->next=A->next; //将当前最小结点插入A表表头）可以看出。
注：看情况，本算法代码还没有全部贴出来!
4. 数据结构算法编程
/**<
数据结构实验编程，要求如下：
1)单链表结点类的定义。
2)单链表类的定义。
3)在单链表的第i个结点前插入一个结点。
4)在单链表的第i个结点前删除一个结点。
5)在单链表中查找第i个结点。
6)更新单链表中第i个结点的值。
7）遍历单链表。
希望给出源程序，让我好好研究一下。前提必须要能运行出正确的结果。谢谢！我用的软件是Devc++，
如果可以运行出正确结果，定采纳！再次感谢！
*/
#include<iostream>
usingnamespacestd;
classNode{
public:
Node(){
id=0;
next=NULL;
}
Node(inti){
id=i;
next=NULL;
}
intid;
Node*next;
};
classChain{
private:
Node*head;
//Node*tail;
intnum;
public:
Chain(){
head=NULL;
//tail=NULL;
num=0;
}
~Chain(){
Node*t=head;
while(t)
{
head=t->next;
deletet;
t=head;
}
cout<<"release"<<endl;
}
voidsetHead(Node*head){
this->head=head;
}
Node*getHead(){
returnhead;
}
voidsetNum(intnum){
this->num=num;
}
intgetNum(){
returnnum;
}
boolinsertIns(Node*ins);
boolinsBefore(Node*ins,inti);
booldelBef(inti);
Node*findI(inti);
boolupdate(inti,intid);
voidChain::travel();
};
boolChain::insertIns(Node*ins){
if(!ins)
returnfalse;
if(NULL==head){
head=ins;
num++;
returntrue;
}
Node*cur=head;
while(NULL!=cur->next)
{
cur=cur->next;
}
cur->next=ins;
num++;
returntrue;
}
boolChain::insBefore(Node*ins,inti)
{
if(i==1){
ins->next=head;
head=ins;
num++;
returntrue;
}
if(i>this->num)
returnfalse;
intpre=i-1;
intcur=1;
Node*curPt=head;
while(curPt&&cur!=pre)
{
curPt=curPt->next;
cur++;
}
if(NULL!=curPt&&cur==pre)
{
cout<<"insBefore:curPt.id="<<curPt->id<<endl;
Node*t=curPt->next;
curPt->next=ins;
ins->next=t;
this->num++;
returntrue;
}
returnfalse;
}
boolChain::delBef(inti)
{
if(i<=1||i>num)
returnfalse;
Node*res=findI(i-2);
if(NULL==res)
{
res=findI(i-1);
if(res==head)
{
head=head->next;
deleteres;
num--;
returntrue;
}
else
returnfalse;//onlyone
}else{
Node*tmp=res->next->next;
Node*tar=res->next;
deletetar;
res->next=tmp;
num--;
returntrue;
}
//if(i<0||i>num)
//returnfalse;
//Node*tmp=NULL;
//if(1==i)
//{
//tmp=head->next;
//deletehead;
//head=tmp;
//num--;
//returntrue;
//}
//Node*p=findI(i-1);
//if(p){
//tmp=p->next->next;
//deletep->next;
//p->next=tmp;
//num--;
//}
//else{
//returnfalse;
//}
//returntrue;
}
Node*Chain::findI(inti)
{
if(i<0||i>num)
returnNULL;
intcur=1;
Node*p=head;
while(cur!=i){
p=p->next;
cur++;
}
returnp;
}
boolChain::update(inti,intid)
{
Node*res=findI(i);
boolflag=false;
if(res)
{
res->id=id;
flag=true;
}
returnflag;
}
voidChain::travel(){
Node*cur=head;
while(cur)
{
cout<<cur->id<<"";
cur=cur->next;
}
cout<<endl;
}
intmain()
{
Node*npt=NULL;
Chain*cpt=newChain;
for(inti=0;i<9;i++){
npt=newNode;
if(npt){
npt->id=i+1;
cpt->insertIns(npt);
}
}
if(NULL==cpt)
return-1;
cpt->travel();
cout<<"here ";
boolres=false;
if(npt)
{
npt=newNode(12);
res=cpt->insBefore(npt,7);
if(res)
cpt->travel();
else
cout<<"insBeforefailed! ";
}
cout<<"here2 ";
//
res=cpt->delBef(1);
cout<<"here2.2 ";
if(res)
{
cout<<"del1"<<endl;
cpt->travel();
}
cout<<"here2.5 ";
res=cpt->delBef(5);
cout<<"here3 ";
if(res)
{
puts("del5[[[[");
cpt->travel();
puts("del5]]]]");
}
///
npt=cpt->findI(5);
printf("findIid=%d ",npt->id);
cpt->travel();
///
cpt->update(5,99);
cpt->travel();
cout<<"------"<<endl;
return0;
}
//简单测试了一下
5. 数据结构中用dijkstra算法 表中的i是什么意思
你好你大哥就似我，你用一个数组 dist 记录最短路径长，用另一个数组 pre 记录直接前驱。关键语句如下：
if (dist[j] > dist[i] + edge[i, j])
{
dist[j] = dist[i] + edge[i, j];
pre[j] = i;
}
这样就行了。
6. 数据结构算法求助
确实是有点小问题，所以达不到要求了
其实这个算法的思想是就是用第一个循环先拷贝第一段到s后面紧挨着，然后将后面的一段拷贝到再后面，只是循环的起点有误，这样改1个字符就可以了：
for(j=m+t-i;j<=s;j++) 改为：for(j=m+t-1;j<=s;j++)
7. 数据拟合算法
解：设一共有n个方程，第i个方程形如aiX1+biX2=ci，其中ai,bi,ci是已知数
设di(x1,x2)=(ci-aix1-bix2)(ci-aix1-bix2)
设D= d1+d2+...dn
原问题就是求D的极小值，分别求D关于x1和x2的偏导数，得
Dx1=2a1(a1x1+b1x2-c1)+2a2(a2x1+b2x2-c2)+...2an(anx1+bnx2-cn)
Dx2=2b1(a1x1+b1x2-c1)+2b2(a2x1+b2x2-c2)+...2bn(anx1+bnx2-cn)
极小值处偏导数等于0，所以令Dx1=0,Dx2=0建立方程组，解得
x1=(F*B-G*E)/(A*B-E*E）
x2=(G*A-F*E)/(A*B-E*E)
其中F=a1c1+a2c2+...+ancn
G=b1c1+b2c2+...+bncn
E=a1b1+a2b2+...+anbn
A=a1a1+a2a2+...+anan
B=b1b1+b2b2+...+bnbn
具体数据这里就不算了，用excel把公式打进去就可以算，另外excel本身就带拟合功能
8. 数据的算法都有哪些……
A*搜寻算法
俗称A星算法。这是一种在图形平面上，有多个节点的路径，求出最低通过成本的算法。常用于游戏中的 NPC的移动计算，或线上游戏的 BOT的移动计算上。该算法像 Dijkstra算法一样，可以找到一条最短路径；也像BFS一样，进行启发式的搜索。
Beam Search
束搜索(beam search)方法是解决优化问题的一种启发式方法，它是在分枝定界方法基础上发展起来的，它使用启发式方法估计k个最好的路径，仅从这k个路径出发向下搜索，即每一层只有满意的结点会被保留，其它的结点则被永久抛弃，从而比分枝定界法能大大节省运行时间。束搜索于20 世纪70年代中期首先被应用于 人工智能领域,1976 年Lowerre在其称为 HARPY的语音识别系统中第一次使用了束搜索方法。他的目标是并行地搜索几个潜在的最优决策路径以减少回溯，并快速地获得一个解。
二分取中查找算法
一种在有序数组中查找某一特定元素的搜索算法。搜素过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜素过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。这种搜索算法每一次比较都使搜索范围缩小一半。
Branch and bound
分支定界算法是一种在问题的解空间树上搜索问题的解的方法。但与回溯算法不同，分支定界算法采用广度优先或最小耗费优先的方法搜索解空间树，并且，在分支定界算法中，每一个活结点只有一次机会成为扩展结点。
数据压缩
数据压缩是通过减少计算机中所存储数据或者通信传播中数据的冗余度，达到增大数据密度，最终使数据的存储空间减少的技术。数据压缩在文件存储和分布式系统领域有着十分广泛的应用。数据压缩也代表着尺寸媒介容量的增大和网络带宽的扩展。
Diffie–Hellman密钥协商
Diffie–Hellman key exchange，简称“D–H”，是一种安全协议。它可以让双方在完全没有对方任何预先信息的条件下通过不安全信道建立起一个密钥。这个密钥可以在后续的通讯中作为对称密钥来加密通讯内容。
Dijkstra’s 算法
迪科斯彻算法（Dijkstra）是由荷兰计算机科学家艾兹格·迪科斯彻发明的。算法解决的是有向图中单个源点到其他顶点的最短路径问题。举例来说，如果图中的顶点表示城市，而边上的权重表示着城市间开车行经的距离，迪科斯彻算法可以用来找到两个城市之间的最短路径。
动态规划
动态规划是一种在 数学和计算机科学中使用的，用于求解包含重叠子问题的最优化问题的方法。其基本思想是，将原问题分解为相似的子问题，在求解的过程中通过子问题的解求出原问题的解。 动态规划的思想是多种算法的基础，被广泛应用于计算机科学和工程领域。比较着名的应用实例有：求解最短路径问题，背包问题，项目管理，网络流优化等。这里也有一篇文章说得比较详细。
欧几里得算法
在 数学中，辗转相除法，又称 欧几里得算法，是求 最大公约数的算法。辗转相除法首次出现于 欧几里得的《几何原本》（第VII卷，命题i和ii）中，而在中国则可以追溯至 东汉出现的《九章算术》。
快速傅里叶变换(FFT)
快速傅里叶变换（Fast Fourier Transform，FFT），是离散傅里叶变换的快速算法，也可用于计算离散傅里叶变换的逆变换。快速傅里叶变换有广泛的应用，如数字信号处理、计算大整数乘法、求解偏微分方程等等。
哈希函数
HashFunction是一种从任何一种数据中创建小的数字“指纹”的方法。该 函数将数据打乱混合，重新创建一个叫做散列值的指纹。散列值通常用来代表一个短的随机字母和数字组成的字符串。好的散列 函数在输入域中很少出现散列冲突。在散列表和数据处理中，不抑制冲突来区别数据，会使得数据库记录更难找到。
堆排序
Heapsort是指利用堆积树（堆）这种 数据结构所设计的一种排序算法。堆积树是一个近似完全二叉树的结构，并同时满足堆积属性：即子结点的键值或索引总是小于（或者大于）它的父结点。
归并排序
Merge sort是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。
RANSAC 算法
RANSAC 是”RANdom SAmpleConsensus”的缩写。该算法是用于从一组观测数据中估计 数学模型参数的迭代方法，由Fischler and Bolles在1981提出，它是一种非确定性算法，因为它只能以一定的概率得到合理的结果，随着迭代次数的增加，这种概率是增加的。该算法的基本假设是观测数据集中存在”inliers”（那些对模型参数估计起到支持作用的点）和”outliers”（不符合模型的点），并且这组观测数据受到噪声影响。RANSAC 假设给定一组”inliers”数据就能够得到最优的符合这组点的模型。
RSA加密算法
这是一个公钥加密算法，也是世界上第一个适合用来做签名的算法。今天的RSA已经 专利失效，其被广泛地用于 电子商务加密，大家都相信，只要密钥足够长，这个算法就会是安全的。
并查集Union-find
并查集是一种树型的 数据结构，用于处理一些不相交集合（Disjoint Sets）的合并及查询问题。常常在使用中以森林来表示。
Viterbi algorithm
寻找最可能的隐藏状态序列
等等这些，算法很多。
9. 数据与结构算法
不是叫做：数据与结构算法，而是应该叫做：《数据结构与算法》，其中：数据结构指的是：顺序表、堆栈、链表、二叉树、图等；而算法一般指的是：各种搜索算法（顺序搜索、二分搜素等）、以及各种排序算法等。
至于说程序中到底是哪一个地方出现 bug，那可不是通过在纸上分析能够分析出来的，而是必须要亲自上机在机器上面调试出来的。
10. 数据结构与算法
int fib(int n)
{
int a,b,sum,i;
a=b=1; i=3; sum=a+b;
if (n==1||n==2) return 1;
while (i<=n)
{
a=b;
b=sum; \递归展开\
sum=a+b;
i++;
}
return sum;
}