Length of the longest substring without repeating characters - GeeksforGeeks

13 Apr, 2022
Given a string str, find the length of the longest substring without repeating characters. 
For “ABDEFGABEF”, the longest substring are “BDEFGA” and “DEFGAB”, with length 6.
For “BBBB” the longest substring is “B”, with length 1.
For “GEEKSFORGEEKS”, there are two longest substrings shown in the below diagrams, with length 7
The desired time complexity is O(n) where n is the length of the string.
Method 1 (Simple : O(n3)): We can consider all substrings one by one and check for each substring whether it contains all unique characters or not. There will be n*(n+1)/2 substrings. Whether a substring contains all unique characters or not can be checked in linear time by scanning it from left to right and keeping a map of visited characters. Time complexity of this solution would be O(n^3).
C++
Java
Python3
C#
Javascript
// C++ program to find the length of the longest substring// without repeating characters#include <bits/stdc++.h>using namespace std; // This function returns true if all characters in str[i..j]// are distinct, otherwise returns falsebool areDistinct(string str, int i, int j){     // Note : Default values in visited are false    vector<bool> visited(26);     for (int k = i; k <= j; k++) {        if (visited[str[k] - 'a'] == true)            return false;        visited[str[k] - 'a'] = true;    }    return true;} // Returns length of the longest substring// with all distinct characters.int longestUniqueSubsttr(string str){    int n = str.size();    int res = 0; // result    for (int i = 0; i < n; i++)        for (int j = i; j < n; j++)            if (areDistinct(str, i, j))                res = max(res, j - i + 1);    return res;} // Driver codeint main(){    string str = "geeksforgeeks";    cout << "The input string is " << str << endl;    int len = longestUniqueSubsttr(str);    cout << "The length of the longest non-repeating "            "character substring is "         << len;    return 0;}
// Java program to find the length of the// longest substring without repeating// charactersimport java.io.*;import java.util.*; class GFG{ // This function returns true if all characters in// str[i..j] are distinct, otherwise returns falsepublic static Boolean areDistinct(String str,                                  int i, int j){         // Note : Default values in visited are false    boolean[] visited = new boolean[26];     for(int k = i; k <= j; k++)    {        if (visited[str.charAt(k) - 'a'] == true)            return false;                     visited[str.charAt(k) - 'a'] = true;    }    return true;} // Returns length of the longest substring// with all distinct characters.public static int longestUniqueSubsttr(String str){    int n = str.length();         // Result    int res = 0;         for(int i = 0; i < n; i++)        for(int j = i; j < n; j++)            if (areDistinct(str, i, j))                res = Math.max(res, j - i + 1);                     return res;} // Driver codepublic static void main(String[] args){    String str = "geeksforgeeks";    System.out.println("The input string is " + str);     int len = longestUniqueSubsttr(str);         System.out.println("The length of the longest " +                       "non-repeating character " +                       "substring is " + len);}} // This code is contributed by akhilsaini
# Python3 program to find the length# of the longest substring without# repeating characters # This function returns true if all# characters in str[i..j] are# distinct, otherwise returns falsedef areDistinct(str, i, j):     # Note : Default values in visited are false    visited = [0] * (26)     for k in range(i, j + 1):        if (visited[ord(str[k]) -                   ord('a')] == True):            return False                     visited[ord(str[k]) -                ord('a')] = True     return True # Returns length of the longest substring# with all distinct characters.def longestUniqueSubsttr(str):         n = len(str)         # Result    res = 0         for i in range(n):        for j in range(i, n):            if (areDistinct(str, i, j)):                res = max(res, j - i + 1)                     return res # Driver codeif __name__ == '__main__':         str = "geeksforgeeks"    print("The input is ", str)         len = longestUniqueSubsttr(str)    print("The length of the longest "          "non-repeating character substring is ", len) # This code is contributed by mohit kumar 29
// C# program to find the length of the// longest substring without repeating// charactersusing System;  class GFG{  // This function returns true if all characters in// str[i..j] are distinct, otherwise returns falsepublic static bool areDistinct(string str,                               int i, int j){         // Note : Default values in visited are false    bool[] visited = new bool[26];      for(int k = i; k <= j; k++)    {        if (visited[str[k] - 'a'] == true)            return false;                      visited[str[k] - 'a'] = true;    }    return true;}  // Returns length of the longest substring// with all distinct characters.public static int longestUniqueSubsttr(string str){    int n = str.Length;          // Result    int res = 0;          for(int i = 0; i < n; i++)        for(int j = i; j < n; j++)            if (areDistinct(str, i, j))                res = Math.Max(res, j - i + 1);                      return res;}  // Driver codepublic static void Main(){    string str = "geeksforgeeks";    Console.WriteLine("The input string is " + str);      int len = longestUniqueSubsttr(str);          Console.WriteLine("The length of the longest " +                      "non-repeating character " +                      "substring is " + len);}} // This code is contributed by sanjoy_62
<script> // JavaScript program to find the length of the// longest substring without repeating// characters// This function returns true if all characters in// str[i..j] are distinct, otherwise returns falsefunction areDistinct(str, i, j){         // Note : Default values in visited are false    var visited = new [26];     for(var k = i; k <= j; k++)    {        if (visited[str.charAt(k) - 'a'] == true)            return false;                     visited[str.charAt(k) - 'a'] = true;    }    return true;} // Returns length of the longest substring// with all distinct characters.function longestUniqueSubsttr(str){    var n = str.length();         // Result    var res = 0;         for(var i = 0; i < n; i++)        for(var j = i; j < n; j++)            if (areDistinct(str, i, j))                res = Math.max(res, j - i + 1);                     return res;} // Driver code    var str = "geeksforgeeks";    document.write("The input string is " + str);     var len = longestUniqueSubsttr(str);         document.write("The length of the longest " +                       "non-repeating character " +                       "substring is " + len); // This code is contributed by shivanisinghss2110. </script>
The input string is geeksforgeeks
The length of the longest non-repeating character substring is 7
Method 2 (Better : O(n2)) The idea is to use window sliding. Whenever we see repetition, we remove the previous occurrence and slide the window.
C++
Java
Python3
C#
Javascript
// C++ program to find the length of the longest substring// without repeating characters#include <bits/stdc++.h>using namespace std; int longestUniqueSubsttr(string str){    int n = str.size();    int res = 0; // result     for (int i = 0; i < n; i++) {                 // Note : Default values in visited are false        vector<bool> visited(256);           for (int j = i; j < n; j++) {             // If current character is visited            // Break the loop            if (visited[str[j]] == true)                break;             // Else update the result if            // this window is larger, and mark            // current character as visited.            else {                res = max(res, j - i + 1);                visited[str[j]] = true;            }        }         // Remove the first character of previous        // window        visited[str[i]] = false;    }    return res;} // Driver codeint main(){    string str = "geeksforgeeks";    cout << "The input string is " << str << endl;    int len = longestUniqueSubsttr(str);    cout << "The length of the longest non-repeating "            "character substring is "         << len;    return 0;}
// Java program to find the length of the// longest substring without repeating// charactersimport java.io.*;import java.util.*; class GFG{ public static int longestUniqueSubsttr(String str){    int n = str.length();         // Result    int res = 0;         for(int i = 0; i < n; i++)    {                 // Note : Default values in visited are false        boolean[] visited = new boolean[256];                 for(int j = i; j < n; j++)        {                         // If current character is visited            // Break the loop            if (visited[str.charAt(j)] == true)                break;             // Else update the result if            // this window is larger, and mark            // current character as visited.            else            {                res = Math.max(res, j - i + 1);                visited[str.charAt(j)] = true;            }        }         // Remove the first character of previous        // window        visited[str.charAt(i)] = false;    }    return res;} // Driver codepublic static void main(String[] args){    String str = "geeksforgeeks";    System.out.println("The input string is " + str);     int len = longestUniqueSubsttr(str);    System.out.println("The length of the longest " +                       "non-repeating character " +                       "substring is " + len);}} // This code is contributed by akhilsaini
# Python3 program to find the# length of the longest substring# without repeating charactersdef longestUniqueSubsttr(str):         n = len(str)         # Result    res = 0      for i in range(n):                  # Note : Default values in        # visited are false        visited = [0] * 256            for j in range(i, n):              # If current character is visited            # Break the loop            if (visited[ord(str[j])] == True):                break              # Else update the result if            # this window is larger, and mark            # current character as visited.            else:                res = max(res, j - i + 1)                visited[ord(str[j])] = True                     # Remove the first character of previous        # window        visited[ord(str[i])] = False         return res # Driver codestr = "geeksforgeeks"print("The input is ", str) len = longestUniqueSubsttr(str)print("The length of the longest "      "non-repeating character substring is ", len) # This code is contributed by sanjoy_62
// C# program to find the length of the// longest substring without repeating// charactersusing System; class GFG{     static int longestUniqueSubsttr(string str){    int n = str.Length;         // Result    int res = 0;       for(int i = 0; i < n; i++)    {                 // Note : Default values in visited are false        bool[] visited = new bool[256];                 // visited = visited.Select(i => false).ToArray();        for(int j = i; j < n; j++)        {                         // If current character is visited            // Break the loop            if (visited[str[j]] == true)                break;               // Else update the result if            // this window is larger, and mark            // current character as visited.            else            {                res = Math.Max(res, j - i + 1);                visited[str[j]] = true;            }        }                 // Remove the first character of previous        // window        visited[str[i]] = false;    }    return res;} // Driver codestatic void Main(){    string str = "geeksforgeeks";    Console.WriteLine("The input string is " + str);         int len = longestUniqueSubsttr(str);    Console.WriteLine("The length of the longest " +                      "non-repeating character " +                      "substring is " + len );}} // This code is contributed by divyeshrabadiya07
<script> // JavaScript program to find the length of the// longest substring without repeating// characters function longestUniqueSubsttr(str){    var n = str.length();         // Result    var res = 0;         for(var i = 0; i < n; i++)    {                 // Note : Default values in visited are false        var visited = new Array(256);                 for(var j = i; j < n; j++)        {                         // If current character is visited            // Break the loop            if (visited[str.charCodeAt(j)] == true)                break;             // Else update the result if            // this window is larger, and mark            // current character as visited.            else            {                res = Math.max(res, j - i + 1);                visited[str.charCodeAt(j)] = true;            }        }    }    return res;} // Driver code    var str = "geeksforgeeks";    document.write("The input string is " + str);     var len = longestUniqueSubsttr(str);    document.write("The length of the longest " +                       "non-repeating character " +                       "substring is " + len);  // This code is contributed by shivanisinghss2110// This code is edited by ziyak9803</script>
The input string is geeksforgeeks
The length of the longest non-repeating character substring is 7
Method 3 ( Linear Time ): Using this solution the problem can be solved in linear time using the window sliding technique. Whenever we see repetition, we remove the window till the repeated string.
Java
import java.io.*; class GFG {    public static int longestUniqueSubsttr(String str)    {        String test = "";         // Result        int maxLength = -1;         // Return zero if string is empty        if (str.isEmpty()) {            return 0;        }        // Return one if string length is one        else if (str.length() == 1) {            return 1;        }        for (char c : str.toCharArray()) {            String current = String.valueOf(c);             // If string already contains the character            // Then substring after repeating character            if (test.contains(current)) {                test = test.substring(test.indexOf(current)                                      + 1);            }            test = test + String.valueOf(c);            maxLength = Math.max(test.length(), maxLength);        }         return maxLength;    }     // Driver code    public static void main(String[] args)    {        String str = "geeksforgeeks";        System.out.println("The input string is " + str);         int len = longestUniqueSubsttr(str);        System.out.println("The length of the longest "                           + "non-repeating character "                           + "substring is " + len);    }} // This code is contributed by Alex Bennet
The input string is geeksforgeeks
The length of the longest non-repeating character substring is 7
Method 4 (Linear Time): Let us talk about the linear time solution now. This solution uses extra space to store the last indexes of already visited characters. The idea is to scan the string from left to right, keep track of the maximum length Non-Repeating Character Substring seen so far in res. When we traverse the string, to know the length of current window we need two indexes. 1) Ending index ( j ) : We consider current index as ending index. 2) Starting index ( i ) : It is same as previous window if current character was not present in the previous window. To check if the current character was present in the previous window or not, we store last index of every character in an array lasIndex[]. If lastIndex[str[j]] + 1 is more than previous start, then we updated the start index i. Else we keep same i.  
Below is the implementation of the above approach :
C++
Java
Python3
C#
Javascript
// C++ program to find the length of the longest substring// without repeating characters#include <bits/stdc++.h>using namespace std;#define NO_OF_CHARS 256 int longestUniqueSubsttr(string str){    int n = str.size();     int res = 0; // result     // last index of all characters is initialized    // as -1    vector<int> lastIndex(NO_OF_CHARS, -1);     // Initialize start of current window    int i = 0;     // Move end of current window    for (int j = 0; j < n; j++) {         // Find the last index of str[j]        // Update i (starting index of current window)        // as maximum of current value of i and last        // index plus 1        i = max(i, lastIndex[str[j]] + 1);         // Update result if we get a larger window        res = max(res, j - i + 1);         // Update last index of j.        lastIndex[str[j]] = j;    }    return res;} // Driver codeint main(){    string str = "geeksforgeeks";    cout << "The input string is " << str << endl;    int len = longestUniqueSubsttr(str);    cout << "The length of the longest non-repeating "            "character substring is "         << len;    return 0;}
// Java program to find the length of the longest substring// without repeating charactersimport java.util.*; public class GFG {     static final int NO_OF_CHARS = 256;     static int longestUniqueSubsttr(String str)    {        int n = str.length();         int res = 0; // result         // last index of all characters is initialized        // as -1        int [] lastIndex = new int[NO_OF_CHARS];        Arrays.fill(lastIndex, -1);         // Initialize start of current window        int i = 0;         // Move end of current window        for (int j = 0; j < n; j++) {             // Find the last index of str[j]            // Update i (starting index of current window)            // as maximum of current value of i and last            // index plus 1            i = Math.max(i, lastIndex[str.charAt(j)] + 1);             // Update result if we get a larger window            res = Math.max(res, j - i + 1);             // Update last index of j.            lastIndex[str.charAt(j)] = j;        }        return res;    }     /* Driver program to test above function */    public static void main(String[] args)    {        String str = "geeksforgeeks";        System.out.println("The input string is " + str);        int len = longestUniqueSubsttr(str);        System.out.println("The length of "                           + "the longest non repeating character is " + len);    }}// This code is contributed by Sumit Ghosh
# Python3 program to find the length# of the longest substring# without repeating charactersdef longestUniqueSubsttr(string):     # last index of every character    last_idx = {}    max_len = 0     # starting index of current    # window to calculate max_len    start_idx = 0     for i in range(0, len(string)):               # Find the last index of str[i]        # Update start_idx (starting index of current window)        # as maximum of current value of start_idx and last        # index plus 1        if string[i] in last_idx:            start_idx = max(start_idx, last_idx[string[i]] + 1)         # Update result if we get a larger window        max_len = max(max_len, i-start_idx + 1)         # Update last index of current char.        last_idx[string[i]] = i     return max_len  # Driver program to test the above functionstring = "geeksforgeeks"print("The input string is " + string)length = longestUniqueSubsttr(string)print("The length of the longest non-repeating character" +      " substring is " + str(length))
// C# program to find the length of the longest substring// without repeating charactersusing System;public class GFG{  static int NO_OF_CHARS = 256;  static int longestUniqueSubsttr(string str)  {    int n = str.Length;    int res = 0; // result     // last index of all characters is initialized    // as -1    int [] lastIndex = new int[NO_OF_CHARS];    Array.Fill(lastIndex, -1);     // Initialize start of current window    int i = 0;     // Move end of current window    for (int j = 0; j < n; j++)    {       // Find the last index of str[j]      // Update i (starting index of current window)      // as maximum of current value of i and last      // index plus 1      i = Math.Max(i, lastIndex[str[j]] + 1);       // Update result if we get a larger window      res = Math.Max(res, j - i + 1);       // Update last index of j.      lastIndex[str[j]] = j;    }    return res;  }   /* Driver program to test above function */  static public void Main ()  {    string str = "geeksforgeeks";    Console.WriteLine("The input string is " + str);    int len = longestUniqueSubsttr(str);    Console.WriteLine("The length of "+                      "the longest non repeating character is " +                      len);  }} // This code is contributed by avanitrachhadiya2155
<script> // JavaScript program to find the length of the longest substring// without repeating charactersvar NO_OF_CHARS = 256; function longestUniqueSubsttr(str)    {        var n = str.length();         var res = 0; // result         // last index of all characters is initialized        // as -1        var lastIndex = new [NO_OF_CHARS];        Arrays.fill(lastIndex, -1);         // Initialize start of current window        var i = 0;         // Move end of current window        for (var j = 0; j < n; j++) {             // Find the last index of str[j]            // Update i (starting index of current window)            // as maximum of current value of i and last            // index plus 1            i = Math.max(i, lastIndex[str.charAt(j)] + 1);             // Update result if we get a larger window            res = Math.max(res, j - i + 1);             // Update last index of j.            lastIndex[str.charAt(j)] = j;        }        return res;    }     /* Driver program to test above function */             var str = "geeksforgeeks";        document.write("The input string is " + str);        var len = longestUniqueSubsttr(str);        document.write("The length of the longest non repeating character is " + len); // This code is contributed by shivanisinghss2110 </script>
The input string is geeksforgeeks
The length of the longest non-repeating character substring is 7
Time Complexity: O(n + d) where n is length of the input string and d is number of characters in input string alphabet. For example, if string consists of lowercase English characters then value of d is 26. Auxiliary Space: O(d) 
Alternate Implementation : 
C++
Java
Python3
C#
Javascript
#include <bits/stdc++.h>using namespace std; int longestUniqueSubsttr(string s){         // Creating a set to store the last positions    // of occurrence    map<char, int> seen ;    int maximum_length = 0;     // Starting the initial point of window to index 0    int start = 0;     for(int end = 0; end < s.length(); end++)    {                 // Checking if we have already seen the element or        // not        if (seen.find(s[end]) != seen.end())        {                         // If we have seen the number, move the start            // pointer to position after the last occurrence            start = max(start, seen[s[end]] + 1);        }         // Updating the last seen value of the character        seen[s[end]] = end;        maximum_length = max(maximum_length,                             end - start + 1);    }    return maximum_length;} // Driver codeint main(){    string s = "geeksforgeeks";    cout << "The input String is " << s << endl;    int length = longestUniqueSubsttr(s);         cout<<"The length of the longest non-repeating character "        <<"substring is "        << length;} // This code is contributed by ukasp
import java.util.*;class GFG {   static int longestUniqueSubsttr(String s)  {     // Creating a set to store the last positions of occurrence    HashMap<Character, Integer> seen = new HashMap<>();     int maximum_length = 0;     // starting the initial point of window to index 0    int start = 0;     for(int end = 0; end < s.length(); end++)    {      // Checking if we have already seen the element or not      if(seen.containsKey(s.charAt(end)))      {        // If we have seen the number, move the start pointer        // to position after the last occurrence        start = Math.max(start, seen.get(s.charAt(end)) + 1);      }       // Updating the last seen value of the character      seen.put(s.charAt(end), end);      maximum_length = Math.max(maximum_length, end-start + 1);    }    return maximum_length;  }   // Driver code  public static void main(String []args)  {    String s = "geeksforgeeks";    System.out.println("The input String is " + s);    int length = longestUniqueSubsttr(s);    System.out.println("The length of the longest non-repeating character substring is " + length);  }} // This code is contributed by rutvik_56.
# Here, we are planning to implement a simple sliding window methodology  def longestUniqueSubsttr(string):          # Creating a set to store the last positions of occurrence    seen = {}    maximum_length = 0      # starting the initial point of window to index 0    start = 0          for end in range(len(string)):          # Checking if we have already seen the element or not        if string[end] in seen:             # If we have seen the number, move the start pointer            # to position after the last occurrence            start = max(start, seen[string[end]] + 1)          # Updating the last seen value of the character        seen[string[end]] = end        maximum_length = max(maximum_length, end-start + 1)    return maximum_length  # Driver Codestring = "geeksforgeeks"print("The input string is", string)length = longestUniqueSubsttr(string)print("The length of the longest non-repeating character substring is", length)
using System;using System.Collections.Generic;class GFG {   static int longestUniqueSubsttr(string s)  {     // Creating a set to store the last positions of occurrence    Dictionary<char, int> seen = new Dictionary<char, int>();     int maximum_length = 0;     // starting the initial point of window to index 0    int start = 0;     for(int end = 0; end < s.Length; end++)    {      // Checking if we have already seen the element or not      if(seen.ContainsKey(s[end]))      {        // If we have seen the number, move the start pointer        // to position after the last occurrence        start = Math.Max(start, seen[s[end]] + 1);      }       // Updating the last seen value of the character      seen[s[end]] = end;      maximum_length = Math.Max(maximum_length, end-start + 1);    }    return maximum_length;  }   // Driver code  static void Main() {    string s = "geeksforgeeks";    Console.WriteLine("The input string is " + s);    int length = longestUniqueSubsttr(s);    Console.WriteLine("The length of the longest non-repeating character substring is " + length);  }} // This code is contributed by divyesh072019.
<script>function longestUniqueSubsttr(s){         // Creating a set to store the last positions    // of occurrence    let seen = new Map();    let maximum_length = 0;     // Starting the initial point of window to index 0    let start = 0;     for(let end = 0; end < s.length; end++)    {                 // Checking if we have already seen the element or        // not        if (seen.has(s[end]))        {                         // If we have seen the number, move the start            // pointer to position after the last occurrence            start = Math.max(start, seen.get(s[end]) + 1);        }                     // Updating the last seen value of the character        seen.set(s[end],end)        maximum_length = Math.max(maximum_length, end - start + 1);    }    return maximum_length;} // Driver code let s = "geeksforgeeks"document.write(`The input String is ${s}`)let length = longestUniqueSubsttr(s);     document.write(`The length of the longest non-repeating character substring is ${length}`) // This code is contributed by shinjanpatra</script>
The input String is geeksforgeeks
The length of the longest non-repeating character substring is 7
As an exercise, try the modified version of the above problem where you need to print the maximum length NRCS also (the above program only prints the length of it).
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
rathbhupendra
shubham_singh
SukritBedi
shubhamshah92
MayankS19
hitesh_tripathi
mohit kumar 29
akhilsaini
divyeshrabadiya07
sanjoy_62
avanitrachhadiya2155
divyesh072019
ajaypsnd
rutvik_56
ukasp
adnanirshad158
akshaysingh98088
alexbennet
shivanisinghss2110
sooda367
ziyak9803
amartyaghoshgfg
shinjanpatra
simmytarika5
sweetyty
Amazon
Housing.com
Microsoft
Morgan Stanley
Strings
Morgan Stanley
Amazon
Microsoft
Housing.com
Strings
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Python program to check if a string is palindrome or not
Check for Balanced Brackets in an expression (well-formedness) using Stack
KMP Algorithm for Pattern Searching
Different methods to reverse a string in C/C++
Convert string to char array in C++
Array of Strings in C++ (5 Different Ways to Create)
Longest Palindromic Substring | Set 1
Reverse words in a given string
Caesar Cipher in Cryptography
Check whether two strings are anagram of each other