1. 数据结构串匹配十大经典算法
1。
int Index(SString S,SString T,int pos)
{
//返回子串T在主串S中第pos个字符之后的位置。若不存在，则函数值为0。
//其中，T非空，1〈=pos<=Stringlength(S).
i=pos;j=1;
while(i<=S[0] && j<=T[0])
{
if (S[i]== T[i]) {++i;++j;}
else { i=i-j+2;j=1;}
}
if(j>T[0]) return i-T[0];
else return 0;
}//Index
2。
int Index-KMP(SString S,SString T,int pos)
{
//利用模式串T的next函数值求T在主串S中第pos 个字符之后的位置的KMP算法。其中，T非空，1<=pos<=Stringlength(S)
i=pos;
j=1;
while(i<=S[0] && j<=T[0])
{
if (j==0 || S[i]==T[j]) {++i; ++j;}
else j=next[j];
}
if (j>T[0]) return i-T[0];
else return 0;
//Index}
下面是next函数：
void next(SString S,ing next[])
{
i=1;
next[1]=0;
j=0;
while (i<T[0])
{
if (j==0 || T[i]==T[j]){ ++i; ++j;
next[j]=i;}
else j=next[j];
}
}//next
我现在只有这两个答案。
2. 求串的模式匹配完整算法实现代码
#include <iostream>
#include <cstring>
using namespace std;
void getNext(const char* pattern,int next[])
{
next[0]= -1;
int k=-1,j=0;
while(pattern[j]!='\0')
{
if(k!=-1 && pattern[k]!=pattern[j])k=next[k];
++j;++k;
next[j]=pattern[k]== pattern[j]?next[k]:k;
}
}
int KMP(const char *Text,const char* Pattern)
{
if(!Text||!Pattern||Pattern[0]=='\0'||Text[0]=='\0' ) return -1;
int len=0;
const char * c=Pattern;
while(*c++!='\0')++len;
int *next=new int[len+1];
getNext(Pattern,next);
int index=0,i=0,j=0;
while(Text[i]!='\0' && Pattern[j]!='\0' )
{
if(Text[i]== Pattern[j]) ++i,++j;
else
{
index += j-next[j];
if(next[j]!=-1) j=next[j];
else j=0,++i;
}
}
delete []next;
return (Pattern[j]=='\0'?index:-1);
}
int main()
{
char* text="";
char* pattern="baaaa";
cout<<KMP(text,pattern)<<endl;
return 0;
}
3. 写一算法 实现串的基本操作Replace（&S,T.V） 谢谢了
VC是许许多多技术的综合，就好像少林72般绝技，一般在应用中学会其中很少一部分就够了。我们现在的目的，其实不过是学一套少林长拳。
4. 计算方法中什么是串行算法与并行算法
如果认为题主所说的并行和串行指的GPU和CPU
CPU核心大量晶体管用于缓存，保证尽快执行每一条指令（不管是什么指令）。
GPU核心大量晶体管用于计算，保证尽量高的指令吞吐量。
可以这样比喻。
CPU=1个理工科博士（没有黑文科博士的意思）
GPU=100个小学生
目前的问题是，要算1万道简单的加减法，肯定是小学生们一起算的快。
但如果要思考相对论，还是让博士来吧。
5. 数据结构关于串的KMP算法的理解高手请进
KMP 算法是一种字符串的模式匹配算法，参看严蔚敏数据结构一书，里面讲的很清楚。
基本的字符串匹配算法是将被匹配的字符串S和模式串T 逐个字符进行比较。例如:S中有10个字符，T中有5个字符。S串初始的匹配位置为3.则从S中的第3个字符与T中的第一个字符匹配，若相同则S的第4个字符与T中的第2个字符匹配。直到匹配成功或者出现失配字符。当出现失配情况下，移动标识S中当前进行比较的字符指针，会退到第4个字符处。然后，重复这一过程。简单说，基本的字符匹配算法是通过移动被匹配的字符串S，进行比较字符的指针位置来完成字符匹配的。
而KMP算法刚好相反，在整个匹配过程中S中当前比较字符的指针并不发生回退现象，当出现S中的字符与T中的字符失配的时候。通过改变T的当前比较字符位置的指针来确定当前S中的字符该与T中哪个字符进行比较。简单说，通过模式字符串T的当前比较字符的指针的回退来完成字符匹配。
当理解了KMP算法通过改变T的当前比较字符位置的指针来完成匹配时，接下来要理清的是模式字符串T中的字符指针在失配的情况下是如何移动的。
以严蔚敏数据结构一书中KMP为例，对于模式字符串T，KMP维护了一个对应于T中每个字符弱发生失配情况下，指针回退到哪一位置的数组。当被匹配串S与模式串T发生失配的情况下，T读取数组中相应记录的位置，讲指针回退。如果回退后仍然失配则S的当前比较字符位置指针+1，T串指针回到第一个字符处。
由此可见获取数组中存储的数据是KMP算法的关键，书中的公式看起来有点抽象。数组中的存储指针的位置是根据，模式串T与自身的匹配过程获取的。
实际上是说，模式串T的第一个字符，如果出现失配则不会回退；当前比较位置的字符向前N-1位的子串恰好与T中从第一个字符起止N-1个字符形成的子串相等，且N小于当前位置，满足这些条件的N的最大值即为T当前位置指针回退的位置，然后迭代此过程，直到T本身匹配或回退到第一个字符位置仍不匹配，则当前位置的对应的回退位置指针指向T中的第一个字符所在位置。
讲的还不是很清楚，主要是对比一下基本的字符匹配算法和KMP的不同。一个是通过移动被匹配字符串比较字符的指针来实现匹配，一个是移动模式字符串的当前比较字符的位置指针来实现匹配。对于匹配串字符回退位置这个计算书中已经很清楚，根据算法单步调试一次自然就理解了。
6. 各种钢管的理论算法公式
钢材理论重量计算
钢材理论重量计算的计量单位为公斤（ kg ）。其基本公式为：
W（重量，kg ）=F(断面积 mm2)×L(长度，m)×ρ(密度，g/cm3)×1/1000
各种钢材理论重量计算公式如下：
名称（单位）
计算公式
符号意义
计算举例
钢管（包括无
缝钢管及焊接
钢管（kg/m）
W= 0.02466 ×S （D – S ）
D= 外径
S= 壁厚
外径为60 mm 壁厚4mm 的无缝钢管，求每m 重量。每m 重量= 0.02466 ×4 ×（60 –4 ）=5.52kg
圆钢 盘条（kg/m）
W= 0.006165 ×d×d
d = 直径mm
直径100 mm 的圆钢，求每m 重量。每m 重量= 0.006165 ×1002=61.65kg
螺纹钢（kg/m）
W= 0.00617 ×d×d
d= 断面直径mm
断面直径为12 mm 的螺纹钢，求每m 重量。每m 重量=0.00617 ×12 2=0.89kg
方钢（kg/m）
W= 0.00785 ×a ×a
a= 边宽mm
边宽20 mm 的方钢，求每m 重量。每m 重量= 0.00785 ×202=3.14kg
扁钢
（kg/m）
W= 0.00785 ×b ×d
b= 边宽mm
d= 厚mm
边宽40 mm ，厚5mm 的扁钢，求每m 重量。每m 重量= 0.00785 ×40 ×5= 1.57kg
六角钢
（kg/m）
W= 0.006798 ×s×s
s= 对边距离mm
对边距离50 mm 的六角钢，求每m 重量。每m 重量= 0.006798 ×502=17kg
八角钢
（kg/m）
W= 0.0065 ×s ×s
s= 对边距离mm
对边距离80 mm 的八角钢，求每m 重量。每m 重量= 0.0065 ×802=41.62kg
等边角钢
（kg/m）
= 0.00785 ×[d （2b – d ）+0.215 （R2 – 2r 2 ）]
b= 边宽
d= 边厚
R= 内弧半径
r= 端弧半径
求20 mm ×4mm 等边角钢的每m 重量。从冶金产品目录中查出4mm ×20 mm 等边角钢的R 为3.5 ，r 为1.2 ，则每m 重量= 0.00785 ×[4 ×（2 ×20 – 4 ）+0.215 ×（3.52 – 2 ×1.2 2 ）]=1.15kg
不等边角钢
（kg/m）
W= 0.00785 ×[d （B+b – d ）+0.215 （R2 – 2 r 2 ）]
B= 长边宽
b= 短边宽
d= 边厚
R= 内弧半径
r= 端弧半径
求30 mm ×20mm ×4mm 不等边角钢的每m 重量。从冶金产品目录中查出30 ×20 ×4 不等边角钢的R 为3.5 ，r 为1.2 ，则每m 重量= 0.00785 ×[4 ×（30+20 – 4 ）+0.215 ×（3.52 – 2 ×1.2 2 ）]=1.46kg
槽钢
（kg/m）
W=0.00785 ×[hd+2t （b – d ）+0.349 （R2 – r 2 ）]
h= 高
b= 腿长
d= 腰厚
t= 平均腿厚
R= 内弧半径
r= 端弧半径
求80 mm ×43mm ×5mm 的槽钢的每m 重量。从冶金产品目录中查出该槽钢t 为8 ，R 为8 ，r 为4 ，则每m 重量=0.00785 ×[80 ×5+2 ×8 ×（43 – 5 ）+0.349 ×（82–4 2 ）]=8.04kg
工字钢（kg/m）
W= 0.00785 ×[hd+2t （b – d ）+0.615 （R2 – r 2 ）]
h= 高
b= 腿长
d= 腰厚
t= 平均腿厚
R= 内弧半径
r= 端弧半径
求250 mm ×118mm ×10mm 的工字钢每m 重量。从金属材料手册中查出该工字钢t 为13 ，R 为10 ，r 为5 ，则每m 重量= 0.00785 ×[250 ×10+2 ×13 ×（118 –10 ）+0.615 ×（102 –5 2 ）]=42.03kg
钢板（kg/m2）
W= 7.85 ×d
d= 厚
厚度 4mm 的钢板，求每m2 重量。每m2 重量=7.85 ×4=31.4kg
7. 《数据结构（C语言版）》之“串的模式匹配算法”
# include <string.h>
# include <stdio.h>
# include <stdlib.h>
# define OK 1
# define ERROR 0
typedef int Status;
//串的定长顺序存储结构
# define MAX_STR_LEN 40
typedef char SString[MAX_STR_LEN + 1];//0号单元存放串的长度
Status StrAssign(SString T,char * chars)//生成一个其值等于chars的串T
{
int i;
if (strlen(chars) > MAX_STR_LEN)
{
return ERROR;
}
else
{
T[0] = strlen(chars);
for (i=1; i<=T[0]; ++i)
{
T[i] = * (chars + i - 1);
}
return OK;
}
}
//返回串S的元素的个数
int StrLength(SString S)
{
return S[0];
}
//用Sub返回串S的自第pos个字符起长度为len的子串
Status SubString(SString Sub,SString S,int pos,int len)
{
int i;
if (pos<1 || pos>S[0] || len<0 || len>S[0]-pos+1)
{
return ERROR;
}
for (i=1; i<=len; ++i)
{
Sub[i] = S[pos+i-1];
}
Sub[0] = len;
return OK;
}
//输出字符串T
void StrPrint(SString T)
{
int i;
for (i=1; i<=T[0]; ++i)
{
printf("%c ",T[i]);
}
printf("\n");
}
//求模式串T的next函数值并存入数组next
void get_next(SString T,int next[])
{
int i = 1,j = 0;
next[1] = 0;
while (i < T[0])
{
if (j==0 || T[i]==T[j])
{
++i;
++j;
next[i] = j;
}
else
{
j = next[j];
}
}
}
//求模式串T的next函数修正值并存入数组nextval
void get_nextval(SString T,int nextval[])
{
int i = 1,j = 0;
nextval[1] = 0;
while (i < T[0])
{
if (j==0 || T[i]==T[j])
{
++i;
++j;
if (T[i] != T[j])
{
nextval[i] = j;
}
else
{
nextval[i] = nextval[j];
}
}
else
{
j = nextval[j];
}
}
}
//利用模式串T的next函数求T在主串S中第pos字符之后的位置的KMP算法
//1=<pos=<StrLength(S)
int Index_KMP(SString S,SString T,int pos,int next[])
{
int i = pos,j = 1;
while (i<=S[0] && j<=T[0])
{
if (j==0 || S[i]==T[j])
{
++i;
++j;
}
else
{
j = next[j];
}
}
if (j > T[0])
{
return i - T[0];
}
else
{
return 0;
}
}
int main(void)
{
int i,* p;
SString s1,s2;
StrAssign(s1,"aaabaaaab");
printf("主串为：");
StrPrint(s1);
StrAssign(s2,"aaaab");
printf("子串为：");
StrPrint(s2);
p = (int *)malloc((StrLength(s2) + 1) * sizeof(int));
get_next(s2,p);
printf("子串的next的数组为：");
for (i=1; i<=StrLength(s2); ++i)
{
printf("%d ",* (p+i));
}
printf("\n");
i = Index_KMP(s1,s2,1,p);
if (i)
{
printf("主串和子串在第%d个字符处首次匹配\n",i);
}
else
{
printf("主串和子串匹配不成功\n");
}
get_nextval(s2,p);
printf("子串的nextval数组为：");
for (i=1; i<=StrLength(s2); ++i)
{
printf("%d ",* (p+i));
}
printf("\n");
printf("主串和子串在第%d个字符处首次匹配\n",Index_KMP(s1,s2,1,p));
printf("求串s1的从第5个字符起长度为5的子串s2:\n");
SubString(s2,s1,5,5);
printf("串s2为:");
StrPrint(s2);
return 0;
}
/*
在vc++6.0中的输出结果：
------------------------
主串为：a a a b a a a a b
子串为：a a a a b
子串的next的数组为：0 1 2 3 4
主串和子串在第5个字符处首次匹配
子串的nextval数组为：0 0 0 0 4
主串和子串在第5个字符处首次匹配
求串s1的从第5个字符起长度为5的子串s2:
串s2为:a a a a b
Press any key to continue
------------------------------
*/
8. 管道相贯线怎么算(详细算法)
我认为我认为我认为我认为我认为我认为 生个可爱的宝宝，是每个准妈妈的心愿，有的人喜欢男孩，有的人喜欢女孩，但是怎么样才能生个如愿以偿的宝宝呢？ 怀孕后很多人对自己生男生女都感到好奇，也并不一定说自己要生男或者生女，这是我在其他地方看到的写的较多的生男生女的特征，拿来玩玩。一、传统说法： 1、清宫表推测男女； 2、尖肚子男，圆肚子女； 3、肚子小男，肚子大女； 4、除了肚子身体其他部位没发胖的男，反之女； 5、脚不肿男，脚肿女； ） 6、反应不重男，反应重女； 7、酸男辣女； 8、变丑男，变漂亮女； 9、皮肤变黑男，皮肤不变女；） 10、胎动感觉拳打脚踢男，整个身体翻动女； 11、比预产期早生男，晚生女； 12、肚脐突出男，不突出女； 13、B超显示宝宝脸朝外的男，面对妈妈的女； 二、国外网站的说法 1、孕期增长的体重主要集中在腹部－男；集中在屁股和大腿－女． 2、肚子形状像西瓜－女；像篮球－男． 3、肚子靠上－女；往下坠－男． 4、孕后乳房迅猛发展－女；反之－男． 5、喜酸和咸食－男；喜甜食和果汁－女． 6、卧室枕头朝北－男；朝南－女． 7、孕后准妈妈变丑－女（他们认为女儿会偷走妈妈的容颜）；无多大变化－男． 8、以针引线悬于腹上，线端作圆周运动－男；作左右摆动－女． 资料来源 三某些网站提到的其他特征： 1、小便清的为男，反之女； 2、按压拇指，左手回血快为男，右手为女； 3、脉搏左边强为男，右边强为女； 4、胎动早为男（16W），晚为女； 5、胎囊长是男，圆为女； 6、胎盘前壁是男，后壁为女； 7、肚肚下怀为男，上怀为女；四、其他说法： 1、肚脐以上妊娠线直、细、直达两乳间男，反之女； 2、妊娠线左男右女； 3、胎动偏左男，偏右女； 4、胎心140左右男，150左右女； 5、怀孕期准妈妈勤劳的男，懒惰的女； 6、鼻子变大的男，不变的女； 7、喜食长条蔬菜水果的男，圆型蔬菜水果的女； 8、尿检偏碱性的男，偏酸性的女；资料来源 五.综合各方意见和民间偏方，我对生男生女的看法是这样的： 1，尖儿圆女，孕妇的肚子，从侧面看，如果是往前显得略尖，一般认定为男孩子，说是小鸡鸡顶在那里的缘故。反之，没有小鸡鸡，一定肚子就显圆形了。据说这个还比较准。还有就是生儿子肚脐会突出。 2，看背影有孕妇特征，是女儿；看不出有孕妇特征，是儿子。从背后看孕妇，明显重心后仰，屁股肥大，膀大腰圆孕妇相十足的，必定是女儿。如果背后看，宛若少女，侧面才看得出是孕妇的，肚中是儿子无疑。 3，脸上起黄褐斑，越长越难看的是儿子，脸上和怀孕前无明显变化的是女儿 4，孕期反应大是女儿，没反应或反应小是儿子。孕期反应大的，吐得一塌糊涂翻天覆地的，大多是女儿；没有反应，欢蹦乱跳的，是生儿子的多。 5，行走中突然无意识回头，向左是儿子，向右是女儿。这个我还是第一次看到。六.那么，到底怎么样才能生如愿以偿的宝宝呢？也就是说怎样生男孩，怎样生女孩？
9. 串模式匹配算法（C语言）100分悬赏
第一个朴素算法:
1.普通的串模式匹配算法:
int index(char s[],char t[],int pos)
/*查找并返回模式串T在S中从POS开始的位置下标,若T不是S的子串.则返回-1.*/
{
int i,j,slen,tlen;
i=pos;j=0; //i,j分别指示主串和模式串的位置.
slen=strlen(s);tlen=strlen(t); //计算主串和模式串的长度.
while(i<slen && j<tlen)
{
if(s[i]==t[j]) {i++;j++;}
else {i=i-j+1;j=0;}
}
if(j>=tlen) return i-tlen;
return -1;
}
第二个KMP算法.该算法支持从主串的任意位置开始搜索.
2.KMP算法:
//求模式串的next函数.
void get_next(char *p,int next[])
{
int i,j,slen;
slen=strlen(p);i=0;
next[0]=-1;j=-1;
while(i<slen)
{
if(j==-1||p[i]==p[j]) {++i;++j;next[i]=j;}
else j=next[j];
}
}
//KMP模式匹配算法
int index_kmp(char *s,char *p,int pos,int next[])
/* 利用模式串P的NEXT函数,求P在主串S中从第POS个字符开始的位置*/
/*若匹配成功.则返回模式串在主串中的位置下标.否则返回-1 */
{
int i,j,slen,plen;
i=pos-1;j=-1;
slen=strlen(s);plen=strlen(p);
while(i<slen && j<plen)
{
if(j==-1||s[i]==p[j]) {++i;++j;}
else j=next[j];
10. 问下2串一的算法怎么算的
大致的思路是 用两个指针变量 分别指向str1 和str2 例如: char *p = str1,*p2 = str2; str1 的第一个字符和str2中的每个字符比对然后str1 的第二个字符和str2中的每个字符比对 ....... ........ 如果在str2中存在的话那么就把这个字符 赋值到一个新的数组中（就是保存连个字符串中公共字符的字符串） ok 我只能帮你到这里~~