, Titel Beschreibung
Bei einer Zeichenfolge finden, die Länge der längsten Teilkette ohne Zeichen zu wiederholen.
eine Folge von wiederholten Zeichen gegeben identify nicht enthält , die längste Teilzeichenlänge.
Beispiel 1:
Input: "abcabcbb"
Output: 3
Erläuterung: Die Antwort ist "abc", mit der Länge von 3.
Beispiel 2:
Input: "bbbbb"
Output: 1
Erläuterung: Die Antwort ist , "b", mit der Länge der 1.es
Beispiel 3:
Eingang: „pwwkew“
Ausgang: 3
Erläuterung: die Antwort ist „WKE“, mit der Länge der 3.
Beachten Sie, dass die Antwort ein Teil sein „pwke“ ist ein Teilfolge und nicht ein Teil.
Zweitens Ideen zur Problemlösung
Auf einen Blick ist alles Gewalt. Durch Gewalt Act, kann es sehr einfache Lösung sein, aber die Zeitkomplexität relativ höher. Ich wählte in Java HashMap, für Doppel-Loop, die erste Schicht Schleife für jeden i einmal ++ verwenden, erstellt einen neuen HashMap Speicherplatz, um den Wert der Karte von dem i-ten Zeichen in dem i + 1-ten, die zur Vorbeugung Karte Charakter betroffen. Der zweite Schicht weiter Arbeitszyklus ist, um zu bestimmen, ob es eine HashMap ist dieses Zeichen, wenn es aus dem Zyklus der zweiten Schicht aus, wenn nicht der Charakter die Karte hinzugefügt wird, und dann die Größe der Karte und die maximale Anzahl der Zeichen die Anzahl des Vergleichs, die große Aufgabe.
Die zweite Methode ist die Zeitkomplexität O (2 n), wobei die Definition von zwei int Variable, um eine Position der Zeichenkette Steuern der gespeicherten Zeichenposition in die HashSet darstellt, wenn das Zeichen nicht das HashSet ist, es die einen Anfangswert maxnum = 0 ist, solange der Wert größer als maxnum HashSet Einstellung impart maxnum, die endgültige Rückkehr maxnum: zugegeben in, wenn dem so ist, das Zeichen löscht HashSet Index i zugespitzt und i ++ Länge maximieren Wert.
Die dritte Methode, die Verbesserung des Schiebefensteralgorithmus. Das Verfahren der Verwendung HashMap und tiefgestellte Zeichen linked zwei Variablen gesetzt ist, i und jj Subskript das aktuelle Zeichen zu identifizieren. Index i wird verwendet, um zu identifizieren, die tiefgestellten Zeichen eines Zeichens wiederholt wird. Mit j-i + 1 verwendet, wird die Länge der Zeichenkette zu erhalten, wird nicht wiederholt. Wenn hashmap einen Charakter hat, und dann erhalten Sie den Index wieder i in diesem Charakter Hashmap vergleichen, wählen Sie die größeren. (Wegen der Entstehung abba auftreten kann, wenn das letzte Zeichen, eine Wiederholung Zeichen bei Index 0 und i einen Wert von 2 hat, wenn Sie keinen großen Wert wählen, wird ein Fehler 4 führen , wird das Ergebnis im Gegensatz zu 2 der Figur in der hashmap bis die durchquert Charakter zugesetzt wird.
Das vierte Verfahren, mit einem Speicher-Array. Da die Zeichen repräsentieren alle ASCII-Code für 0-256. Die Indizes der Zeichen darstellt, wird der Wert des Index in der Position der Zeichenkette gespeichert, vorausgesetzt, es gibt doppelte Zeichen, gespeichert der Wert im aktuellen Index wird sich wiederholende Zeichen. Solange die neuesten erworben tiefgestellte Zeichen und eine Wiederholung Lage zu diesem Zeitpunkt der Zeichenfolge zu durchqueren, kann berechnet werden, ist Zeichen lang nicht wiederholt, kann der Maximalwert erhalten werden.
Drittens Code-Implementierung
package com.acm.Secondmonth;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
public class LetCode003 {
/**
* 返回：最长没有重复字符的个数
* 先用暴力法
* 直接二重循环 对第一层循环的每一个值度找一下不重复字符串个数
* @param s
* @return
*/
public static int lengthOfLongestSubstring(String s) {
if(s == null) {
throw new RuntimeException("invaild input:S is null");
}
int max = 0;
for(int i=0 ; i<s.length() && s.length()-i>=max ; i++) {
Map<Character , Integer> result = new HashMap<>();
for(int j=i ; j<s.length() ; j++) {
if(result.containsKey(s.charAt(j))) {
break;
}else {
result.put(s.charAt(j), j);
}
if(result.size() > max) {
max = result.size();
}
}
}
return max;
}
/**
*
* @param s
* @return
* 时间复杂度 O(2n)
* 每发现一个重复的字符就将一开始的字符删除 ，一直到将与其重复的字符和其前面的全部删除
*/
public static int lengthOfLongestSubstring01(String s) {
if(s == null) {
throw new RuntimeException("invaild input:S is null");
}
Set<Character> result = new HashSet<>();
int i=0 , j=0 , maxNum = 0;
while(i < s.length() && j < s.length()) {
if(!result.contains(s.charAt(j))) {
result.add(s.charAt(j++));
if(result.size() > maxNum) {
maxNum = result.size();
}
}else {
result.remove(s.charAt(i++));
}
}
return maxNum;
}
public static int lengthOfLongestSubstring03(String s ) {
if(s == null) {
throw new RuntimeException("invaild input:S is null");
}
int maxNum = 0;
Map<Character, Integer> result = new HashMap<>();
int start = 0 ; int end = 0;
while(end < s.length()) {
if(result.containsKey(s.charAt(end))) {
start = Math.max(result.get(s.charAt(end))+1 , start);
}
result.put(s.charAt(end), end);
maxNum = Math.max(maxNum, end-start+1);
end++;
}
return maxNum;
}
public static int lengthOfLongestSubstring04(String s) {
if(s == null) {
throw new RuntimeException("invaild input:S is null");
}
int maxNum = 0;
int[] result =new int[256];
for(int i=0 , j=0 ; j<s.length() ; j++) {
i = Math.max(result[s.charAt(j)], i);
maxNum = Math.max(maxNum , j-i+1);
result[s.charAt(j)] = j+1;
}
return maxNum;
}
public static void main(String[] args) {
test01();
test02();
test03();
test04();
}
private static void test01() {
String test = "abcabcbb";
System.out.println(lengthOfLongestSubstring(test));
System.out.println(lengthOfLongestSubstring01(test));
System.out.println(lengthOfLongestSubstring03(test));
System.out.println(lengthOfLongestSubstring04(test));
}
private static void test02() {
String test = "abba";
System.out.println(lengthOfLongestSubstring(test));
System.out.println(lengthOfLongestSubstring01(test));
System.out.println(lengthOfLongestSubstring03(test));
System.out.println(lengthOfLongestSubstring04(test));
}
private static void test03() {
String test = "pwwkew";
System.out.println(lengthOfLongestSubstring(test));
System.out.println(lengthOfLongestSubstring01(test));
System.out.println(lengthOfLongestSubstring03(test));
System.out.println(lengthOfLongestSubstring04(test));
}
private static void test04() {
String test = " ";
System.out.println(lengthOfLongestSubstring(test));
System.out.println(lengthOfLongestSubstring01(test));
System.out.println(lengthOfLongestSubstring03(test));
System.out.println(lengthOfLongestSubstring04(test));
}
}
