這個。。。我隨便亂說幾句啊，說的不對別見笑。
有一個數組 當中存有一些字元串
另外有一個字典文件 我也將它導入一個數組 有50000多個單詞
然後要找出字元串中包含的單詞
由你給的條件可知：
1。數組 應該是從前到後依次順序掃描字元串。
2。50000多個單詞的字典文件一定優化。具體優化要看具體內容吧。
比如你可以按單詞的首字母排序，然後分組。等掃描字元串的時候可以分組比較。但這種方法應該沒省多少時間。
你還可以把50000多個單詞的字典文件按單詞的長度進行分組。比如1個字母的分成一組，二個字母的分成一組。。。。N個字母的分成一組，這樣就分成了N組。然後掃描字元串的時候你可以按後續匹配（好象叫這個演算法吧，名字記不清了）演算法，這樣就可以省很多時間了。
你還可以這樣做，因為你要查的是單詞，單詞一定有意義。那你可以直接把你的字元串數組先進行語法、語義分析並分割，然後再去匹配你的字典。這樣應該是最快的。但這要用到自然語言處理。。。
2. 在Java中，設計一個演算法,判斷一個算術表達式中的括弧是否配對。
演算法：
String str="5+(4-3)）" 表達式
char kuohao[]; 用作括弧堆棧
掃描str中的字元
1如果是（則入棧
2如果是）
a如果戰不空出棧
b如果棧空，不匹配。演算法結束
最後棧空則匹配
下面是我的實現
public class biaodashi {
public static void main(String args[])
{
int top=0;//堆指針
boolean end=true;//不匹配時只輸出一次
char stack[]=new char[100];//存括弧
String biaoda="(((1+(2)-6))";//表達式
char biao[]=biaoda.toCharArray();//將字元串轉化成字元數組
System.out.println("表達式: "+biaoda);
for(int i=0;i<biao.length&&end;i++)//遍歷表達式中所有字元
{
if(biao[i]=='(')//如果是(則入棧
{
stack[top]='(';
top++;
}
else if(biao[i]==')')//如果是)則出戰
{
if(!(top==0))
top--;
else
{
System.out.println("括弧不匹配");
end=false;
}
}
}//除循環兩種可能
if(top==0&&end)
System.out.println("括弧匹配");//出循環stack空
else if(top!=0&&end)
System.out.println("括弧不匹配");//出循環時stack不空
}
}
3. 括弧匹配演算法 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--;
}
}
}
4. 求java全字替換演算法、全字匹配演算法
沒做過，只是想到幾個思路：
如果文本量比較少（幾千或者上萬，具體沒有測試過）並且要查詢和替換的目標在正則中不是很復雜的話，使用正則表達式就可以實現快速的文本的查找和替換，並不需要自己寫演算法。如果文本量很大，就需要自己再想辦法了。
如果文本量比較大，可以將文本存儲到資料庫中，資料庫提供了文本的查找和替換的功能，並 且此功能已經相當完善，調用相應的資料庫函數可以實現查找和替換。
如果你只是想學習文字處理上的一些演算法，而非實現查找和替換的功能的話，就當上面什麼都沒說好了.....
5. Java中indexOf()判斷字元子串位置採用的是什麼演算法
不是KMP 就是暴力查找，先找第一個字元匹配的，然後再一個一個比較是否相等，直到最後一個字元。如果匹配就返回第一個字元的位置。如果不是就重新開始找第一個字元匹配的位置。
6. 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;
}
7. Java編程實現字元串的模式匹配
傳統的字元串模式匹配演算法（也就是BF演算法）就是對於主串和模式串雙雙自左向右，一個一個字元比較，如果不匹配，主串和模式串的位置指針都要回溯。這樣的演算法時間復雜度為O（n＊m），其中n和m分別為串s和串t的長度。
KMP 演算法是由Knuth，Morris和Pratt等人共同提出的，所以成為Knuth－Morris－Pratt演算法，簡稱KMP演算法。KMP演算法是字元串模式匹配中的經典演算法。和BF演算法相比，KMP演算法的不同點是匹配過程中，主串的位置指針不會回溯，這樣的結果使得演算法時間復雜度只為O（n＋m）。
8. 求 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();
}
}
9. java應用bm演算法的字元串匹配
判斷是否是數字字元串用val
要使單精度變數X,Y,Z分別保留一位,兩位,三位小數format在窗體顯示用form.print
^<>^
10. java：我有兩個字元串數組StrA與StrB，我想將這兩個數組進行匹配，並返回StrA中的字元串在StrB中的位置
for(String str:StrA){
for(int i=0;i<StrB.length;i++){
if(str==B[i]){
System.out.println("StrA中元素"+str+"在StrB的位置是"+i);
}
}
}