这是我参与8月更文挑战的第5天，活动详情查看：8月更文挑战

前言

好久没刷过算法题了，想起大学时天天晚上一回到寝室就刷题的日子，真是令人怀念，工作了后，很多东西感觉都丢失了，一想到为了单纯的面试而刷题，就感觉毫无动力啊。

leetCode 无重复字符的最长子串 复杂度O(n)

方法一

看到这一题的时候，首先想到的方法是用LinkList按序存储每一符号（下标和char符号），遍历 如此最终求得最大值，但是此种方法超时了。代码如下

class Solution {
    class Node{
                    char c;
                    int index;
                    public Node(char c,int index) {
                            this.c=c;
                            this.index=index;
                   }
                    @Override
                   public boolean equals(Object obj) {

                           if (obj instanceof Node) {

                           }
                           return super.equals(obj);
                   }
            }
            private int getIndex(List<Node> nodes,char v) {
                       int i=0;
                           for (Node n:nodes) {
                                   if (n.c==v) {
                                           return i;
                                   }
                                   i++;

                           }
                           return -1;
                   }

            public int lengthOfLongestSubstring(String s) {
                    char[] str=s.toCharArray();
                    List<Node> nodes=new LinkedList<>();
   //		  Map< Character, Integer> map=new HashMap<Character, Integer>();
                     int len=0,max=0;

                     for(int i=0;i<str.length;i++) {
                             int index=getIndex(nodes, str[i]);
                             if (index!=-1) {

                                     if(len>max) {
                                             max=len;
                                     }
                                     nodes=nodes.subList(index+1, nodes.size());
                                     len=1+nodes.size();
                                     nodes.add(new Node(str[i],i));
                             }else {
                                     len++;
                                     nodes.add(new Node(str[i],i));
                             }
                     }
                     if(len>max)max=len;

                 return max;
           }

   
}

方法二

在看到超时的那一组数据，发现基本字符都是在128个ASCII中的，于是就想直接用一个128长度的数组去存储，数组的值默认为-1 ，即没有被访问过。 当扫描到当前字符时 （1）若该字符 被访问过了，且在当前范围内，则比较len和max大学，更新max值。再重置范围，以上次被访问的下一位为范围，再将字符指向的下标改为当前下标。 （2）字符没被访问过，或者不在当前范围，将其所 指向的下标更新为当前下标。

随机访问的速度基本可以认为是o(1)的。遍历字符O（n）. 因此时间复杂度为O(n). 代码如下

public class Soulution {

  public int lengthOfLongestSubstring(String s) {
	 	int max=0,len=0;
		char[] str=s.toCharArray();
	 	int cArray[]=new int[128];
//	 	当前访问的下标  当前范围最左边字符下标
	 	int currentIndex=0,leftIndex=-1;
		for (int i=0;i<cArray.length;i++)cArray[i]=-1;
		for (char c:str) {
//			当前字符上次访问时所在下标
			int lastVisitIndex =cArray[(short)c];
//			 该字符被访问过，且该字符上次被访问所在位置在 当前所求范围内
			if(lastVisitIndex!=-1 && lastVisitIndex>=leftIndex){
				if (len>max)max=len;
				leftIndex=lastVisitIndex+1;
				len=currentIndex-leftIndex+1;
			}else {
				len++;
			}
			cArray[(short)c]=currentIndex;
			currentIndex++;
		}
		if(len>max)max=len;
	 	return max;
	}
}