小白算法刷题Day3

• 获取一个二维数组的行数 eg.length , 获取一个二维数组的列数 eg[0].length.
• 岛屿的数量思路：dfs 其实类似于感染， 遇到同类就感染，直到到了边界或不是同类的时候就返回（递归思想）。所有遇到的同类都应该被标记（如果不可再次访问的话），以防再次访问。

  class Solution {
      public int numIslands(char[][] grid) {
          int islandNum = 0;
          for(int i = 0; i < grid.length; i++){
              for(int j = 0; j < grid[0].length; j++){
                  if(grid[i][j] == '1'){
                      infect(grid, i, j);
                      islandNum++;
                  }
              }
          }
          return islandNum;
      }
      public void infect(char[][] grid, int i, int j){
          if(i < 0 || i > grid.length - 1 || j < 0 || j > grid[0].length - 1 || grid[i][j] != '1') {
              return;
          }
          grid[i][j] = '2';
          infect(grid, i + 1, j);
          infect(grid, i - 1, j);
          infect(grid, i, j + 1);
          infect(grid, i, j - 1);
          return;
      }
  }

•  无重复字符的最长子串：暴力破解 /滑动窗口 滑动窗口思想，是指针来标记当前子字符串的起始和终点位置。当右指针遇到的字符重复出现在当前子字符串里，记录当前子字符串的长度，并且向右移动左指针。我之前的算法是从当前位置再从新添加不同的字符，实际上只要删掉上一个子字符串的首个字母，右指针的位置保留且继续往右走，不必从当前位置开始寻找。时间从231ms 提升到13ms。
  String.indexOf(""); 这个函数在找不到内容的时候返回值是-1，传入的对像是个string。

  class Solution {
      public int lengthOfLongestSubstring(String s) {
          int maxLength = 0;
          // int beginPos = 0;
          char[] arr = s.toCharArray();
          StringBuilder ans = new StringBuilder("");
          for(int i = 0; i < s.length(); i++){
              for(int j = i + ans.length(); j < s.length(); j++){
                  if(ans.indexOf(arr[j] + "") == -1){
                      ans.append(arr[j]);
                      if(j == arr.length - 1)
                          return maxLength = ans.length() > maxLength ? ans.length() : maxLength;
                  }
                  else{
                      maxLength = ans.length() > maxLength ? ans.length() : maxLength;
                      ans.delete(0,1);
                      break;
                  }
              } 
          }
          return maxLength;
      }
  }

• 反转没对括号间的子字符串：用栈实现和StringBuilder s实现，从左到右遍历字符串，每次遇到字符就加入到s里，遇到左括号后就把已有的s加入到stack里,这里其实是将每两个左括号之间的字符串分成的块 一块一块的存在stack里。然后s.setLength(0);(StringBuilder的方法用于清空s的内容) 因为当前需要翻转的字符串不包括前面的部分。直到遇到了右括号，翻转当前的字符串s.reverse();()StringBuilder 的方法用于翻转字符串内容）且把栈顶的字符串块插入到当前s的头部用s.insert(0,stack.pop());(这也是StringBuilder类提供的方法)重复直到字符串遍历完成。

class Solution {
    public String reverseParentheses(String s) {
        Stack stack = new Stack();
        StringBuilder ans = new StringBuilder();
        for(int i = 0; i < s.length(); i++){
            char c = s.charAt(i);
            if(c == '('){
                stack.push(ans.toString());
                ans.setLength(0);
            }else if(c == ')'){
                ans.reverse();
                ans.insert(0, stack.pop());
            }else{
                ans.append(c);
            }
        }
        return ans.toString();
    }
}