小白算法刷题Day1

• java 中的string是无法改变的，这意味着在调用replace等方法时实际上是创建了一个新的string。如果此时仅使用s.replace("xx",""); s还是原来的s。只能通过重新分配来改变s。方法如下： s = s.replace("xx",""); 这种方法来实现字符串修改会浪费大量的空间。
• 与String不同的是 StringBuffer 和 StringBuilder 类的对象能够被多次修改且不会创建新的对象造成空间浪费。StringBuilder 相比于 StringBuffer 有速度上的优势所以一般用StringBuilder。 但是StringBuilder相比于StringBuffer 线程不安全。因为没有同步锁，所以不适用于多线程。还不懂啥是多线程，以后回来补充，常用方法链接。Java StringBuffer 和 StringBuilder 类 | 菜鸟教程
• Stack 的定义 Stack<Object类型> stack = new stack<Object 类型>()； Object类型可以不特意声明，这样stack中存的可以是各种你自己创建的或者现有的object。如 Integer Character。。。
• stack.peek(); 栈顶取值，不出栈。
• stack.empty();/stack.isEmpty(); 都可用来判断栈是否为空。
• stack.size();
• 三目运算符：？ value = a ? b : c; 等于 if (a) value = b； else value = c；。
• continue 用于跳过本轮循环continue后面的语句，执行下一轮。
• 数组创建的过程：
  1.在内存中开辟出一段连续的空间。
  2.初始化数组时，给所有元素赋数组类型的默认值。例：int 默认值是0
  3.数组完成初始化之后会分配一个唯一的地址值
  4.地址交给数组名（数组引用类型变量）来保存
  5.如果想操作数组中的元素，可以根据引用变量的地址来找到数组，然后根据下标访问数组中的元素。
  注：数组名是引用类型变量，保存的是数组的地址。
• import java.util.Arrays;
  1.String s = Array.toString(数组名)；可以直接把数组的内容转换成字符串。
  2.Array.sort(数组名)；对数组进行排序。
  3.Array.copyOf(原数组名，新数组长度)；
   3.1新数组长度>=原数组长度，复制多出来的部分是对应类型的额默认值
   3.2新数组长度<=原数组长度，截取
• 括号匹配问题思路，在检测到一个右括号时离它最近的做括号必须和它一类，用栈来实现。与编译原理中的词法分析器的括号匹配相同，遍历一遍整个字符串，在检测的左括号时将与其同类的右括号压入栈中，直到遇到右括号，这时若栈为空或者栈顶弹出的元素与当前遇到的右括号不同则不匹配。遍历完成之后若栈为空则匹配。

• import java.util.Stack;
  
  public class bracketsCompete {
      public static boolean solution(String s) {
          char[] charArray = s.toCharArray();
          Stack<Character> brackets = new Stack<Character>();
          for(int i = 0; i < s.length(); i++){
              if(charArray[i] == '(')
                  brackets.push(')');
              else if(charArray[i] == '[')
                  brackets.push(']');
              else if(charArray[i] == '{')
                  brackets.push('}');
              else if(brackets.isEmpty() || charArray[i] != brackets.pop())
                  return false;
          }
          return brackets.isEmpty();
      }
      public static void main(String[] args) {
          System.out.println(solution("[]{}()"));
      }
  }

• 跳跃游戏思路：因为题目假设一定能跳到终点，所以只要遍历一遍数组，找出在当前所在点能到达的所有点中，这些点的index加上他们本身可跳跃的距离离终点最近的点，把符合条件的当前点的可到达的点设为当前点且step加1. 在遍历当前点可到达点时 若可达点是终点则返回step+1。

• class Solution {
      public int jump(int[] nums) {
          int steps = 0;
          int curIndex = 0;
          if(nums.length == 1){
              return 0;
          }
          for(int i = 0; i < nums.length; i++){
              curIndex = i;
              for(int j = 1; j <= nums[i]; j++){
                  if(i + j == nums.length - 1)
                      return steps + 1;
                  else if(i + j < nums.length)
                      curIndex = i + j + nums[i+j] > curIndex + nums[curIndex] ? i + j : curIndex; 
              }
              i = curIndex - 1;
              steps++;
          }
          return steps;
      }

  注：在for循环中，当想要在循环里改变循环变量的时候 往往要多-1，因为在执行下一层循环的时候循环变量会++。导致下一个循环的起点与所需不符。

• HashMap 的使用
  1.定义：HashMap<Object, Object> map = new HashMap<Object, Object>;
  2.存储：map.put(key, value); 注：map中的key是唯一的 如果重复对一个key添加value则是覆盖原本的value。
  3.获取：map.get(key); 返回 value;
  4.删除：map.remove(key);
• 两数之合效率为O(n)思路，用HashMap 来存储数据。 由于我们需要的值是index， 所以key是数组中的元素，value则是元素对应的index。map.get(key); 方法查找的时间复杂度是O(1)，以此来减少整体程序的时间复杂度。

  class Solution {
      public int[] twoSum(int[] nums, int target) {
          HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
          for(int i = 0; i < nums.length; i++){
              if(map.containsKey(target - nums[i])){
                  return new int[]{i,map.get(target - nums[i])};
              }
              map.put(nums[i],i);
          }
      }
  }