We’re rewarding the question askers & reputations are being recalculated! Read more.

 3 added 116 characters in body edited Oct 13 '14 at 7:53 maaartinus 13.3k11 gold badge2727 silver badges6969 bronze badges static int longest_length = -1;  No. Static is useless here and makes you method much less usable. A non-static variable would be better, but actually, why not return a result??? There's no longest_length in Java. Maybe longestLength. Better, return the substring, the length can be easily obtained from it. Separated printing and computation, good. if(index >= str.length()) return;  Spacing (after if). Also according to conventions, you should always use braces (I personally don't). LinkedHashMap map = new LinkedHashMap();  Use Java 7 diamonds or Guava's Maps.newLinkedHashMap() to save yourself repeated generics. You need no linked map. calc(str,last_index+1);  I find the recursion confusing here. You really do nothing, but a simple loop, so use a loop (Even a goto would be clearer than recursion here). The algorithm indeed runs in O(n*n), which can be shown with a string like abcde.... abcde....  where you always run through half of the string. I was assuming an unlimited alphabet here, more precisely the complexity is O(n*alphabetSize) as no runs can be longer than alphabetSize. A much better O(n) algorithm would keep track of the starting and ending positions. Wherever you see a duplicate, advance the start. Sounds damn simple. static int longest_length = -1;  No. Static is useless here and makes you method much less usable. A non-static variable would be better, but actually, why not return a result??? Better, return the substring, the length can be easily obtained from it. Separated printing and computation, good. if(index >= str.length()) return;  Spacing (after if). Also according to conventions, you should always use braces (I personally don't). LinkedHashMap map = new LinkedHashMap();  Use Java 7 diamonds or Guava's Maps.newLinkedHashMap() to save yourself repeated generics. You need no linked map. calc(str,last_index+1);  I find the recursion confusing here. You really do nothing, but a simple loop, so use a loop. The algorithm indeed runs in O(n*n), which can be shown with a string like abcde.... abcde....  where you always run through half of the string. I was assuming an unlimited alphabet here, more precisely the complexity is O(n*alphabetSize) as no runs can be longer than alphabetSize. A much better O(n) algorithm would keep track of the starting and ending positions. Wherever you see a duplicate, advance the start. Sounds damn simple. static int longest_length = -1;  No. Static is useless here and makes you method much less usable. A non-static variable would be better, but actually, why not return a result??? There's no longest_length in Java. Maybe longestLength. Better, return the substring, the length can be easily obtained from it. Separated printing and computation, good. if(index >= str.length()) return;  Spacing (after if). Also according to conventions, you should always use braces (I personally don't). LinkedHashMap map = new LinkedHashMap();  Use Java 7 diamonds or Guava's Maps.newLinkedHashMap() to save yourself repeated generics. You need no linked map. calc(str,last_index+1);  I find the recursion confusing here. You really do nothing, but a simple loop, so use a loop (Even a goto would be clearer than recursion here). The algorithm indeed runs in O(n*n), which can be shown with a string like abcde.... abcde....  where you always run through half of the string. I was assuming an unlimited alphabet here, more precisely the complexity is O(n*alphabetSize) as no runs can be longer than alphabetSize. A much better O(n) algorithm would keep track of the starting and ending positions. Wherever you see a duplicate, advance the start. Sounds damn simple. 2 added 2 characters in body edited Oct 13 '14 at 6:43 maaartinus 13.3k11 gold badge2727 silver badges6969 bronze badges static int longest_length = -1;  No. Static is useless here and makes you method much less usable. A non-static variable would be better, but actually, why not return a result??? Better, return the substring, the length can be easily obtained from it. Separated printing and computation, good. if(index >= str.length()) return;  Spacing (after if). Also according to conventions, you should always use braces (I personally don't). LinkedHashMap map = new LinkedHashMap();  Use Java 7 diamonds or Guava's Maps.newLinkedHashMap() to save yourself repeated generics. You need no linked map. calc(str,last_index+1);  I find the recursion confusing here. You really do nothing, but a simple loop, so use a loop. The algorithm indeed runs in O(n*n), which can be shown with a string like abcde.... abcde....  where you always run through half of the string. I was assuming an unlimited alphabet here, more precisely the complexity is O(n*alphabetSize) as no runs can be longer than alphabetSize. A much better O(n) algorithm would keep track of the starting and ending positionpositions. Wherever you see a duplicate, advance the start. SoundSounds damn simple. static int longest_length = -1;  No. Static is useless here and makes you method much less usable. A non-static variable would be better, but actually, why not return a result??? Better, return the substring, the length can be easily obtained from it. Separated printing and computation, good. if(index >= str.length()) return;  Spacing (after if). Also according to conventions, you should always use braces (I personally don't). LinkedHashMap map = new LinkedHashMap();  Use Java 7 diamonds or Guava's Maps.newLinkedHashMap() to save yourself repeated generics. You need no linked map. calc(str,last_index+1);  I find the recursion confusing here. You really do nothing, but a simple loop, so use a loop. The algorithm indeed runs in O(n*n), which can be shown with a string like abcde.... abcde....  where you always run through half of the string. I was assuming an unlimited alphabet here, more precisely the complexity is O(n*alphabetSize) as no runs can be longer than alphabetSize. A much better O(n) algorithm would keep track of the starting and ending position. Wherever you see a duplicate, advance the start. Sound damn simple. static int longest_length = -1;  No. Static is useless here and makes you method much less usable. A non-static variable would be better, but actually, why not return a result??? Better, return the substring, the length can be easily obtained from it. Separated printing and computation, good. if(index >= str.length()) return;  Spacing (after if). Also according to conventions, you should always use braces (I personally don't). LinkedHashMap map = new LinkedHashMap();  Use Java 7 diamonds or Guava's Maps.newLinkedHashMap() to save yourself repeated generics. You need no linked map. calc(str,last_index+1);  I find the recursion confusing here. You really do nothing, but a simple loop, so use a loop. The algorithm indeed runs in O(n*n), which can be shown with a string like abcde.... abcde....  where you always run through half of the string. I was assuming an unlimited alphabet here, more precisely the complexity is O(n*alphabetSize) as no runs can be longer than alphabetSize. A much better O(n) algorithm would keep track of the starting and ending positions. Wherever you see a duplicate, advance the start. Sounds damn simple. 1 answered Oct 13 '14 at 4:52 maaartinus 13.3k11 gold badge2727 silver badges6969 bronze badges static int longest_length = -1;  No. Static is useless here and makes you method much less usable. A non-static variable would be better, but actually, why not return a result??? Better, return the substring, the length can be easily obtained from it. Separated printing and computation, good. if(index >= str.length()) return;  Spacing (after if). Also according to conventions, you should always use braces (I personally don't). LinkedHashMap map = new LinkedHashMap();  Use Java 7 diamonds or Guava's Maps.newLinkedHashMap() to save yourself repeated generics. You need no linked map. calc(str,last_index+1);  I find the recursion confusing here. You really do nothing, but a simple loop, so use a loop. The algorithm indeed runs in O(n*n), which can be shown with a string like abcde.... abcde....  where you always run through half of the string. I was assuming an unlimited alphabet here, more precisely the complexity is O(n*alphabetSize) as no runs can be longer than alphabetSize. A much better O(n) algorithm would keep track of the starting and ending position. Wherever you see a duplicate, advance the start. Sound damn simple.