网站权重其实是指网络
而网络权重就是指网站获取流量的能力.根据你网站获取流量的能力来划分权重等级.下面给出的就根据流量的多少来划分权重的数据.
网络预计流量1~99 权重1
网络预计流量100~499 权重2
网络预计流量500~999 权重3
网络预计流量1000~4999 权重4
网络预计流量5000~9999 权重5
网络预计流量10000~49999 权重6
网络预计流量50000~199999 权重7
网络预计流量200000~999999 权重8
网络预计流量1000000以上 权重9”
另外要说的 就是网络权重是第三方根据研究网络的出来的结论.网络自身是没有这个说法的.
‘贰’ java kmp算法中的 kmp 是什么意思
kmp算法
一种改进的字符串匹配算法，由D.E.Knuth与V.R.Pratt和J.H.Morris同时发现，因此人们称它为克努特——莫里斯——普拉特操作（简称KMP算法）。
完全掌握KMP算法思想
学过数据结构的人，都对KMP算法印象颇深。尤其是新手，更是难以理解其涵义，搞得一头雾水。今天我们就来面对它，不将它彻底搞懂，誓不罢休。
如今，大伙基本上都用严蔚敏老师的书，那我就以此来讲解KMP算法。(小弟正在备战考研，为了节省时间，很多课本上的话我都在此省略了，以后一定补上。)
严老的《数据结构》79页讲了基本的匹配方法，这是基础。先把这个搞懂了。
80页在讲KMP算法的开始先举了个例子，让我们对KMP的基本思想有了最初的认识。目的在于指出“由此，在整个匹配的过程中，i指针没有回溯，”。
我们继续往下看：
现在讨论一般情况。
假设 主串：s: ‘s(1) s(2) s(3) ……s(n)’ ; 模式串 ：p: ‘p(1) p(2) p(3)…..p(m)’
把课本上的这一段看完后，继续
现在我们假设 主串第i个字符与模式串的第j(j<=m)个字符‘失配’后，主串第i个字符与模式串的第k(k<j)个字符继续比较
此时，s(i)≠p(j), 有
主串： S(1)…… s(i-j+1)…… s(i-1) s(i) ………….
|| (相配) || ≠(失配)
匹配串： P(1) ……. p(j-1) p(j)
由此，我们得到关系式
‘p(1) p(2) p(3)…..p(j-1)’ = ’ s(i-j+1)……s(i-1)’
由于s(i)≠p(j)，接下来s(i)将与p(k)继续比较，则模式串中的前(k-1)个字符的子串必须满足下列关系式，并且不可能存在 k’>k 满足下列关系式：(k<j),
‘p(1) p(2) p(3)…..p(k-1)’ = ’ s(i-k+1)s(i-k+2)……s(i-1)’
即：
主串： S(1)……s(i-k +1) s(i-k +2) ……s(i-1) s(i) ………….
|| (相配) || || ?(有待比较)
匹配串： P(1) p(2) …… p(k-1) p(k)
现在我们把前面总结的关系综合一下
有：
S(1)…s(i-j +1)… s(i-k +1) s(i-k +2) …… s(i-1) s(i) ……
|| (相配) || || || ≠(失配)
P(1) ……p(j-k+1) p(j-k+2) ….... p(j-1) p(j)
|| (相配) || || ?(有待比较)
P(1) p(2) ……. p(k-1) p(k)
由上，我们得到关系：
‘p(1) p(2) p(3)…..p(k-1)’ = ’ s(j-k+1)s(j-k+2)……s(j-1)’
接下来看“反之，若模式串中存在满足式(4-4)。。。。。。。”这一段。看完这一段，如果下面的看不懂就不要看了。直接去看那个next函数的源程序。(伪代码)
K 是和next有关系的，不过在最初看的时候，你不要太追究k到底是多少，至于next值是怎么求出来的，我教你怎么学会。
课本83页不是有个例子吗？就是 图4.6
你照着源程序，看着那个例子慢慢的推出它来。看看你做的是不是和课本上正确的next值一样。
然后找几道练习题好好练练，一定要做熟练了。现在你的脑子里已经有那个next算法的初步思想了，再回去看它是怎么推出来的，如果还看不懂，就继续做练习，做完练习再看。相信自己！！！
附：
KMP算法查找串S中含串P的个数count
#include <iostream>
#include <stdlib.h>
#include <vector>
using namespace std;
inline void NEXT(const string& T,vector<int>& next)
{
//按模式串生成vector,next(T.size())
next[0]=-1;
for(int i=1;i<T.size();i++ ){
int j=next[i-1];
while(T!=T[j+1]&& j>=0 )
j=next[j] ; //递推计算
if(T==T[j+1])next=j+1;
else next=0; //
}
}
inline string::size_type COUNT_KMP(const string& S,
const string& T)
{
//利用模式串T的next函数求T在主串S中的个数count的KMP算法
//其中T非空，
vector<int> next(T.size());
NEXT(T,next);
string::size_type index,count=0;
for(index=0;index<S.size();++index){
int pos=0;
string::size_type iter=index;
while(pos<T.size() && iter<S.size()){
if(S[iter]==T[pos]){
++iter;++pos;
}
else{
if(pos==0)++iter;
else pos=next[pos-1]+1;
}
}//while end
if(pos==T.size()&&(iter-index)==T.size())++count;
} //for end
return count;
}
int main(int argc, char *argv[])
{
string S="";
string T="ab";
string::size_type count=COUNT_KMP(S,T);
cout<<count<<endl;
system("PAUSE");
return 0;
}
补上个Pascal的KMP算法源码
PROGRAM Impl_KMP;
USES
CRT;
CONST
MAX_STRLEN = 255;
VAR
next : array [ 1 .. MAX_STRLEN ] of integer;
str_s, str_t : string;
int_i : integer;
Procere get_nexst( t : string );
Var
j, k : integer;
Begin
j := 1; k := 0;
while j < Length(t) do
begin
if ( k = 0 ) or ( t[j] = t[k] ) then
begin
j := j + 1; k := k + 1;
next[j] := k;
end
else k := next[k];
end;
End;
Function index( s : string; t : string ) : integer;
Var
i, j : integer;
Begin
get_next(t);
index := 0;
i := 1; j := 1;
while ( i <= Length(s) ) and ( j <= Length(t) ) do
begin
if ( j = 0 ) or ( s = t[j] ) then
begin
i := i + 1; j := j + 1;
end
else j := next[j];
if j > Length(t) then index := i - Length(t);
end;
End;
BEGIN
ClrScr;
Write(s = );
Readln(str_s);
Write(t = );
Readln(str_t);
int_i := index( str_s, str_t );
if int_i <> 0 then
begin
Writeln( Found , str_t, in , str_s, at , int_i, . );
end
else
Writeln( Cannot find , str_t, in , str_s, . );
END.
index函数用于模式匹配，t是模式串，s是原串。返回模式串的位置，找不到则返回0
不再赘述算法原理，下面是两个函数，已经通过测试，可以直接用。
private int[] get_nextval(String t) {
int len = t.length();
int i = 0;
int j = -1;
int next[] = new int[len];
while (i < len - 1) {
if (j == -1 || (t.charAt(i) == (t.charAt(j)))) {
i++;
j++;
if (t.charAt(i) != (t.charAt(j))) {
next[i] = (j + 1);
} else {
next[i] = next[j];
}
} else {
j = (next[j] - 1);
}
}
return next;
}
private int index_KMP(String s, String t, int[] next) {
int i = 0;
int j = 0;
while (i < s.length() - 1 && j < t.length() - 1) {
if (j == 0 || (s.charAt(i) == t.charAt(j))) {
i++;
j++;
} else
j = (next[j] - 1);
}
if (j > t.length() - 2) {
return (i - t.length() + 1);
} else
return -1;
}
‘叁’ 求 JAVA 字符串匹配 完美算法
只需要实例化 类Matching 设置参数 并调用m.getIndex()方法就OK 请测试... public class Test18{
public static void main(String[] args){
Matching m = new Matching();
m.setOrgStr("ALSKLSHFKDLLS");
m.setSubStr("LS");
System.out.println(m.getIndex());
}
}
class Matching{
String orgStr ="";
String subStr ="";
public void setOrgStr(String orgStr){
this.orgStr = orgStr;
}
public void setSubStr(String subStr){
this.subStr = subStr;
}
public String getIndex(){
StringBuffer sb = new StringBuffer("{");
//根据关键字subStr来拆分字符串orgStr所得的字符串数组
String[] sub = orgStr.split(subStr);
int keyLength = subStr.length(); //关键字长度
int keySize = 0; //关键字个数
int subSize = sub.length; //子字符串个数
int subLength = 0; //子字符串长度
if(!orgStr.endsWith(subStr)){
keySize = subSize-1;
}else
keySize = subSize; int[] index = new int[keySize];//关键字下标数组
for(int i=0;i<keySize;i++){
subLength = sub[i].length();
if(i==0){
index[i]=subLength;
}else
index[i]=index[i-1]+subLength+keyLength;
}
if(keySize>0){
int l = keySize-1;
for(int i=0;i<l;i++){
sb.append(index[i]+",");
}
sb.append(index[l]);//最后一个关键字下标
}else{
sb.append("NULL");
}
sb.append("}");
return sb.toString();
}
}
‘肆’ Java编程实现字符串的模式匹配
传统的字符串模式匹配算法（也就是BF算法）就是对于主串和模式串双双自左向右，一个一个字符比较，如果不匹配，主串和模式串的位置指针都要回溯。这样的算法时间复杂度为O（n＊m），其中n和m分别为串s和串t的长度。
KMP 算法是由Knuth，Morris和Pratt等人共同提出的，所以成为Knuth－Morris－Pratt算法，简称KMP算法。KMP算法是字符串模式匹配中的经典算法。和BF算法相比，KMP算法的不同点是匹配过程中，主串的位置指针不会回溯，这样的结果使得算法时间复杂度只为O（n＋m）。
‘伍’ 谁有Java写的SURF特征匹配算法啊，急用！！！
要比较好的实现的话去WEKA源码里面找，或者http://www.helsinki.fi/~holler/datamining/algorithms.html也有~
不过其实要把人家写的读懂也挺烦的，Apriori是很基本的，Java也有很多好用的集合类，加把劲一天就能写个能用的出来~
‘陆’ 求java全字替换算法、全字匹配算法
没做过，只是想到几个思路：
如果文本量比较少（几千或者上万，具体没有测试过）并且要查询和替换的目标在正则中不是很复杂的话，使用正则表达式就可以实现快速的文本的查找和替换，并不需要自己写算法。如果文本量很大，就需要自己再想办法了。
如果文本量比较大，可以将文本存储到数据库中，数据库提供了文本的查找和替换的功能，并 且此功能已经相当完善，调用相应的数据库函数可以实现查找和替换。
如果你只是想学习文字处理上的一些算法，而非实现查找和替换的功能的话，就当上面什么都没说好了.....
‘柒’ 多个方法具有同样的名称和相同数目的参数时，java编译器要确定如何匹配的算法步骤
方法同样名字和同样数目参数，需要看参数的类型匹配
如果是一个接口的方法，有不同的实现类，看使用的对象是谁
‘捌’ java中哪种查找算法最有效率
这个问题不能一概而论
如果有一种算法优于其他算法，那么其他算法就不存在了不是？
所以，要看在什么情况下，那么有这么几个方面
背景数量级和匹配数量级，就是说你要在多少数据中查找多少数据。
背景数据差异度，背景数据如果包罗万象，或者都是数字，那么选择的算法区别就大了
背景数据整理程度。很多人在选择查找算法时不考虑这个，但是这在实际应用中很有异议，比如数据都排序过和没有排序过，可想而知算法的选择有很大的不同。
匹配方式，是用“等于” 这种方式匹配，还是用like这种方式匹配，也对算法有很大影响。
‘玖’ java应用bm算法的字符串匹配
判断是否是数字字符串用val
要使单精度变量X,Y,Z分别保留一位,两位,三位小数format在窗体显示用form.print
^<>^
‘拾’ 括号匹配算法 java找出有多少种移除方案
括号匹配算法 java找出有多少种移除方案
mport java.util.Scanner;
import java.util.Stack;
/**
* @author Owner
*
*/
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n= sc.nextInt();//3条测试数据数据
Stack<Character> stack = null;
while(n!=0){
//从控制台读入一个测试字符串[]() [(])
String str = sc.next();
//如果该输入字符串为奇数，说明不匹配
if(str.length() % 2 == 1){
System.out.println("No");
}else{
//说明字符是偶数
stack = new Stack<Character>();
//遍历第一条测试字符串[]() [(])
for(int i=0;i<str.length();i++){
if(stack.isEmpty()){
//如果栈是空的
stack.push(str.charAt(i));
}else if(stack.peek() == '[' && str.charAt(i) == ']' || stack.peek() == '(' && str.charAt(i) == ')'){
//说明此时栈中字符不是空的,并且符合，
stack.pop();
}else{
stack.push(str.charAt(i));
}
}
if(stack.isEmpty()){
//如果栈是空的，说明括号匹配
System.out.println("Yes");
}else{
//说明栈不为空，括号不匹配
System.out.println("No");
}
}
n--;
}
}
}