Dieser Artikel beschreibt den von Java implementierten bidirektionalen Anpassungswort -Segmentierungsalgorithmus. Teilen Sie es für Ihre Referenz wie folgt weiter:
Mehrere beliebte Word -Segmentierungsalgorithmen sind: Word -Segmentierungsmethode basierend auf String -Matching, Wortsegmentierungsmethode basierend auf Verständnis und Wortsegmentierungsmethode basierend auf Statistiken. Dieser Artikel verwendet die String Matching -Methode.
Leiten Sie das maximale passende Partizip vorwärts:
Dieser Algorithmus wird basierend auf dem Wortpartizip -Wörterbuch implementiert, das eine Segmentierungsübereinstimmung von der linken Seite der Zeichenfolge durchführt. Wenn das Wörterbuch vorhanden ist, wird das geteilte Wort zurückgegeben und das Wort aus der vorherigen Zeichenfolge ausgeschnitten, und Schleifen, bis die Saitengröße 0 ist.
Zum Beispiel: Str = "Wir sind alle Schüler der School of Information Engineering, Northwest A & F University." (Angenommen, wir definieren die maximale Schneidlänge max = 8, dh acht chinesische Zeichen)
1. Definieren Sie das Wort Partizip Länge Len = max, nehmen Sie die Len -Zeichen aus dem linken Wort = "Wir sind alle nordwestliche Landwirtschaft und Forstwirtschaft" und stimmen Sie das Wort im Wörterbuch an.
2. Wenn es kein solches Wort im Wörterbuch gibt, entfernen Sie das letzte Zeichen und weisen Sie es dem Wort zu, und der Len -Wert wird um 1 reduziert.
3. Wiederholen Sie Schritt 2, bis das Wort im Wörterbuch oder im Len = 1 gefunden wird. Beenden Sie die Schleife.
4. Schneiden Sie die geteilten Wörter von STR ab und wiederholen Sie die Schritte 1, 2 und 3, bis str zersetzt wird.
Umgekehrt das maximale passende Partizip umgekehrt:
Wie der Vorwärtswort -Segmentierungsalgorithmus beginnt er einfach von der rechten Seite der Zeichenfolge, bis die Länge der Zeichenfolge 0 beträgt. Ich werde hier nicht in Details eingehen.
Zwei-Wege-Matching Partizip:
Diese Methode besteht darin, Unklarheit Partizip für die Segmentierung von Mehrdeutigkeiten auf der Grundlage von Vorwärtswirtschaft und umgekehrtem Partizip zu machen. Schlagen Sie die Implementierung des "schlangen Algorithmus" vor. Die Zeichenfolge zur Durchführung von Wortsegmentierung ist Lebensmittel. Es gibt 2 unglaubliche Schlangen, einer isst von links nach rechts; Der andere isst von rechts nach links. Solange die Ergebnisse des linken und rechten Partizips mehrdeutig sind, beißen die beiden Schlangen es. Die Schnur, die die Schlange isst, wird Partizip. Wenn es immer Unklarheiten zwischen linken und rechten Partizipien gibt, werden die beiden Schlangen weiter essen. Wenn zwei Schlangen den Schnittpunkt zwischen den Saiten essen, wird es definitiv keine Unklarheit geben. Zu dieser Zeit gibt es das Partizip in der gierigen Schlangenbauch links, es gibt keine Unklarheit in der Mitte und das Partizip in dem gierigen Schlangenbauch rechts, von denen drei das letzte Partizip sind.
Dieser Artikel soll den gesamten Absatz in Wörter einteilen. Zuerst ist der Absatz in Sätze unterteilt, die auf den Interpunktionsmarken basieren, und dann wird jeder Satz ausgegeben, um das Wort zu teilen.
Paket cn.nwsuaf.spilt; import Java.io.buffenedReader; Import Java.io.Filereader; Import Java.io.ioException; Import Java.util.ArrayList; Import Java.util.hashmap; Vorwärts- und umgekehrte bidirektionale maximale Übereinstimmungswort -Segmentierungsalgorithmus* @Author Liu Yonglang***/public class WordSpilt {/*** Speicherwort -Segmentierung Dictionary*/private map <String, Integer> map = new Hashmap <String, Integer> (); / *** Die maximale Länge der Wortzuteilung beträgt fünf chinesische Zeichen*/ privat int max_length = 5; /** * Lesen Sie das Wort Partizip -Wörterbuch in der Konstruktionsmethode und speichern Sie es in der Karte. String line = null; while ((line = br.readline ())! = null) {line = line.trim (); map.put (Zeile, 0); } br.close (); } / *** Setzen Sie die maximale Länge des Wortes Schnittlänge** @param max* Maximale Word -Schnittlänge* / public void setMaxLength (int max) {this.max_length = max; } / ** * Die aktuelle maximale Wortausschnittlänge abrufen. Standard ist 5 (5 chinesische Zeichen) * * @return aktuelles maximales Wortschnittlänge * / public int getmaxLength () {return this.max_length; } / ** * Maximal Matching Word Cut -Algorithmus * * @param spiltstr * String aufgeteilt werden * @param linksToright * Die Slicing -Richtung ist von links nach rechts, false ist die Zeichenfolge, die von rechts nach links geteilt ist Null; // Speichern Sie die positive Matching -Split -String -Liste <string> links = new ArrayList <string> (); // Speichern Sie die negative Matching -Split -String -Liste <string> rechte Wörter = new ArrayList <string> (); // String zum Schneiden von String word = null; // Nehmen Sie die Länge des Wortes, initialisieren Sie den Maximalwert int WordLength = max_length; // befindet sich in der aktuellen Position der String int Position = 0; // Die Länge der Zeichenfolge wurde verarbeitet intlänge = 0; // Entfernen Sie die zusätzlichen Leerzeichen in der Zeichenfolge spiltstr = spiltstr.trim (). Ersatz ("// s+", ""); // Wenn die angeschnittene Zeichenfolge nicht in Scheiben geschnitten wird, ist die Schleifensegmentierung während (Länge <spiltstr.length ()) {// Wenn die Länge der String, die nicht geschnitten wurde, geringer ist als der maximale Wert, lassen Sie die Wortlänge gleich der Länge des Wortes selbst if (Spilgstr.Length () - Länge <max_Length) Wortlänge = spiltstr. // Ansonsten nehmen Sie den Standardwert anwind WordLength = max_length; // Wenn es sich um ein maximales Vorwärts -Match handelt, schneiden Sie von der Position von Spiltstr, wenn (links) {Position = Länge; word = spiltstr.substring (Position, Position + WordLength); } // Wenn es sich um eine inverse maximale Übereinstimmung handelt, schneiden Sie am Ende von Spiltstr sonst {Position = spiltstr.length () - Länge; word = spiltstr.substring (Position - Wortlänge, Position); } // Schneiden Sie die Zeichenfolge der angegebenen Länge aus der aktuellen Position // Word = spiltstr.substring (Position, Position + WordLength); // Wenn es keine Zeichenfolge im Wort Partizip-Wörterbuch gibt, verwerfen Sie ein Zeichen while (! Map.containsKey)) {// Wenn es sich um ein einzelnes Wort handelt, beenden Sie die Schleife, wenn (Word.length () == 1) {// Wenn es sich um einen Brief oder eine Nummer handelt, teilen Sie die kontinuierlichen Briefe oder Zahlen zusammen (Word. Um die nachfolgenden kontinuierlichen Zeichen zu addieren, wenn (links) {für (int i = spiltstr.indexof (Wort, Position)+1; i <spiltstr .Length (); i ++) {if ((Spiltstr.charat (i)) | <= 'Z') ||. } sonst brechen; }} else {// Wenn es sich um eine umgekehrte Übereinstimmung handelt, addieren und drehen Sie die kontinuierlichen Zahlen und alphabetischen Zeichen vor der aktuellen Position für (int i = spiltstr.indexof (Wort, Position - 1) - 1; i> = 0; i--) {if (Spiltstr.Charat (i)> = '0' && spiltstr.charat (i) (i) | 'A' && spiltstr.charat (i) <= 'z') || if (i == 0) {stringBuffer sb = new StringBuffer (Word); word = sb.reverse (). toString (); }} else {// Flip -Operation StringBuffer sb = new StringBuffer (Word); word = sb.reverse (). toString (); brechen; } } } } brechen; } // Wenn es sich um ein maximales Vorwärts -Übereinstimmung handelt, verwerfen Sie das letzte Zeichen, wenn (links) Word = Word.substring (0, Word.length () - 1); // sonst das erste Zeichen sonst Word = Word.substring (1) verwerfen; } // die geteilte Zeichenfolge in der angegebenen Tabelle speichern, wenn (links) linke Words.add (Word); sonst rightwords.add (Wort); // verarbeitete Zeichenfolgen addieren Länge += Word.length (); } // Wenn es sich um eine inverse maximale Übereinstimmung handelt, passen Sie die Zeichenfolge in der Tabelle an, um zu leiten, wenn (! LinksToright) {für (int i = rightwords.size ()-1; i> = 0; i--) {linke Words.add (rightwords.get (i)); }} // Rückgabe des Slicing -Ergebniss geben linke Wörter zurück; } / ** * Bestimmen Sie, ob die beiden Sätze gleich sind if (list1.size ()! = list2.size ()) return false; für (int i = 0; i <list1.size (); i ++) {if (! list1.get (i) .equals (list2.get (i))) return false; } Return true; } / *** diskriminante Partizip -Mehrdeutigkeitsfunktion** @param inputStr* String zu teilen // "Linksschlange" Partizipergebnisliste <string> resultLeft = new ArrayList <string> (); // "mittlere Schlange" (divergierer Teil) Partizipergebnisliste <string> resultMiddle = new ArrayList <string> (); // "Right Snake" Partizipergebnisliste <string> resultright = new ArrayList <string> (); // LISTE MAXIMAL ABSCHWERNE Word -Segmentierungsergebnisliste <string> links = new ArrayList <string> (); // Inverse maximal Matching Word -Segmentierungsergebnisliste <string> right = new ArrayList <string> (); links = verschüttet (inputStr, true); /* system.out.println("forward Partizip Ergebnis: "); für (String String: links) {System.out.print (String + "/"); } System.out.println ("/n inverse Partizipergebnis:"); */ rechts = verschüttet (inputstr, false); /*für (String String: Right) {System.out.print (String + "/"); } System.out.println ("/ Nboth-Way Word Partizip-Ergebnis:");*// // Bestimmen Sie, ob das Wort Partizip-Spleißen an beiden Enden in der Mitte der Eingabezeichenfolge gekreuzt ist. Solange es keine Schnittstelle gibt, lockert es weiter, während (links.get (0) .Length () + rechts.get (rechts.size () - 1) .Length () <inputstr .Length ()) {// Wenn die Ergebnisse des Vorwärts- und Reverse -Wort -Partizips gleich sind, dann wird das Vorwärtsgebnis aus dem Schleifen, wenn (links), links (links) {Ergebnis. brechen; } // Wenn die Ergebnisse des Partizips vorwärts und des umgekehrten Wortes unterschiedlich sind, dann wird die mit der geringeren Anzahl von Partizipien genommen, und es besteht keine Notwendigkeit, zu schleifen, wenn (links.size ()! links rechts; brechen; } // Wenn die obigen Bedingungen nicht erfüllt sind, implementieren Sie dann den "Schlangen" -Algorithmus // Lassen Sie "linke gierige Schlange" das erste Wort des Vorwärtswort -Partizip -Ergebnisergebnisses. // lass "rechte gierige Schlange" das letzte Wort des umgekehrten Wortes Partizip -Ergebnis resultright.add (rechts.get (rechts.size () - 1)) essen; // Entfernen Sie die von "Snake" gegessenen Wörter InputStr = inputstr.Substring (links.get (0) .Length ()); inputStr = inputStr.substring (0, inputstr.Length () - rechts.get (rechts.size () - 1) .Length ()); // Die vorherigen positiven und reversen Wortsegmentierungsergebnisse reinigen, um störende links zu verhindern.Clear (); rechts.clear (); // Beginnen Sie das Partizip für ungeheuere Zeichenfolgen links = verschüttet (InputStr, True); rechts = verschüttet (inputstr, false); } // Das Ende der Schleife bedeutet, dass entweder das Partizip nicht mehrdeutig ist oder die "gierige Schlange" von beiden Enden zum Schnittpunkt frisst // Wenn es das Wort Partizip an der Kreuzung ist, muss das folgende Urteil gemacht werden. (links.get (0) .Length () + rechts. // Wenn sich die mittlere Kreuzung überschneidet, nimmt sie nur das Essen und es gibt keine Überlappung: // Das erste Partizip in der Vorwärtsrichtung + Die Länge des letzten Partizips in der umgekehrten Richtung = Geben Sie die Gesamtlänge der Zeichenfolge ein, dann kann die Vorwärts- und umgekehrte Richtung geschrieben werden, wenn (links (0) .Länge () + rechts (rechts () () - 1) .Länge (). resultMiddle.add (links.get (0)); resultMiddle.add (rechts.get (rechts.size () - 1)); } // ein eindeutiges Partizip -Ergebnis zum Endergebnis für (String String: resultLeft) {result.add (String) hinzufügen; } für (String String: resultMiddle) {result.add (String); } // Das Partizip, das in "Right Greedy Snake" gespeichert ist, sollte an die Weiterleitung für (int i = resultright.size ()-1; i> = 0; i--) {result.add (resultright.get (i)) angepasst werden; } Rückgabeergebnis; } / ** * Teilen Sie einen Absatz in mehrere Sätze auf und führen Sie die Wortsegmentierung separat durch * * @param inputStr * Ein Absatz, das geteilt werden soll // Wenn die Interpunktion angetroffen wird, wird sie in mehrere Sätze unterteilt, String regex = "[,.;!?]"; String [] st = inputstr.Split (Regex); // Fügen Sie das Partizipergebnis jedes Satzes dem endgültigen Partizipergebnis für (String STRI: ST) {list <string> list = resultWord (STRI) hinzu; result.addall (Liste); } Rückgabeergebnis; } public static void main (String [] args) {// Beispiel: Kommen Sie und sehen Sie, ob der Immobilienpreis teuer ist? Tabelle Tennis Auction Scanner input = neuer Scanner (System.in); String str = input.Nextline (); WordSpilt WordSpilt = null; try {WordSpilt = new WordSpilt (); } catch (ioException e) {e.printstacktrace (); } List <string> list = WordSpilt.Resultword (str); für (String String: List) {System.out.print (String + "/"); }}}Der src/dict.txt ist eine Wörterbuchdatei, und die Einstellungen sind wie folgt:
Willkommen bei Wulin.com Skript Download Skript Tutorial Material Download
Die Betriebsergebnisse sind wie folgt:
Für weitere Informationen zu Java -Algorithmen können Leser, die an dieser Website interessiert sind, die Themen "Java -Datenstruktur und Algorithmus -Tutorial", "Zusammenfassung der Java -Operation DOM -Knoten -Tipps", "Zusammenfassung der Java -Datei- und Verzeichnisoperationstipps" und "Zusammenfassung der Java -Cache -Operation Tipps" anzeigen
Ich hoffe, dieser Artikel wird für Java -Programme aller hilfreich sein.