剑指offerDayN

今天没有好好学习呢，补习了一下java的基础知识类似于break,comparator

• 数组组合成最小的数字

  package offer;
  
  import java.lang.reflect.Array;
  import java.util.Arrays;
  import java.util.Comparator;
  
  /*
  数组排列最小的数
   */
  public class Test21 {
      /**
       * 传入数组
       * 自己定义比较器comparator进行比较
       * 不懂知识点 集合比较器 集合外比较器 lamada函数写法
       * 返回字符串原因 因为排成的数字可能越界 所以输出字符串
       *
       * @param arr
       */
      public static String numberMin(int[] arr) {
          //判空数组
          if (arr.length == 0 || arr == null)
              return null;
          //先把数组的内容 转换成字符串
          //定义一个字符串数组存储
          String[] str = new String[arr.length];
          for (int i = 0; i < arr.length; i++) {
              str[i] = String.valueOf(arr[i]);
          }
          //比较器 字符串的o1+o2 与o2+o1不一样
          Arrays.sort(str, new Comparator<String>() {
              @Override
              public int compare(String o1, String o2) {
                  return (o1 + o2).compareTo(o2 + o1);
              }
          });
          //已经排好序列了
          //把字符串数组的内容放进StringBuffer
          StringBuffer sb = new StringBuffer();
          for (String s : str) {
              sb.append(s);
          }
          return sb.toString();
      }
  
      /**
       * 用快排的方法排序
       *
       * @param arr
       * @return
       */
      public static String numberMin2(int[] arr) {
          //判空
          if (arr.length == 0 || arr == null)
              return null;
          //数字转换成字符串
          //建字符串数组
          String[] str = new String[arr.length];
          for (int i = 0; i < arr.length; i++) {
              str[i] = String.valueOf(arr[i]);
          }
          //进行快排
          quickSort(str, 0, arr.length - 1);
          //以StringBuffer形式输出
          StringBuffer sb = new StringBuffer();
          for (String s : str) {
              sb.append(s);
          }
          return sb.toString();
      }
  
      public static void quickSort(String[] str, int left, int right) {
          if (right <= left) {
              return;
          }
          //快速排序 不是二分查找
          // 三个指针
          int i = left;
          int j = right;
          String temp = str[left];
          //两个指针不相遇 则一次循环没有出结果
          while (i < j) {
              //str[j] > = temp 两个字符串的比较
              while ((str[j] + temp).compareTo(temp + str[j]) >= 0 && i < j)
                  j--;
              while ((str[i] + temp).compareTo(temp + str[i]) <= 0 && i < j)
                  i++;
              //走到应该替换字符的位置
              String s = str[i];
              str[i] = str[j];
              str[j] = s;
          }
          //交换一次要将中间数值与初始节点交换
          str[left] = str[j];
          //更改基准的数值
          str[j] = temp;
          quickSort(str, left, i - 1);
          quickSort(str, j + 1, right);
      }
  
      public static void main(String[] args) {
          int[] arr = {10, 2};
          System.out.println(numberMin2(arr));
      }
  }
  

  简简单单的一道题发现自己有太多的不会了

• 存在的问题 1数字转字符2比较器3为什么选用字符串输出

• 数组中一个数存在的次数

  package offer;
  
  import java.util.HashMap;
  import java.util.Map;
  
  /*
  有序数组 同一个数出现的次数
  1, 2, 3, 3,3, 3, 4, 5
   */
  public class Test22 {
      public static int countSame(int[] arr, int val) {
          HashMap<Integer, Integer> map = new HashMap<>();
          for (int i : arr) {
              int count = map.getOrDefault(i, 0);
              count++;
              map.put(i, count);
          }
          return map.get(val);
      }
  
      /**
       * 排序好的数组中存在的次数 二分查找
       * 找到第一出现次数 跟最后一次出现的位置 二分查找的变种
       *
       * @param arr
       * @param val
       * @return
       */
      public static int countSame2(int[] arr, int val) {
          //先写二分查找
          //按照数组长度改进
          int low = 0, high = arr.length - 1;
          //记录相同元素数组长度
          int numK = 0;
          while (low <= high) {
              int mid = low + (high - low) / 2;
              //查找的数组正好是 123 3 345
              if (arr[mid] == val) {
                  numK++;
                  int midR = mid + 1;
                  int midL = mid - 1;
                  while (midR <= arr.length - 1 && arr[midR] == val) {
                      numK++;
                      midR++;
                  }
                  while (midL >= 0 && arr[midL] == val) {
                      numK++;
                      midL--;
                  }
                  return numK;
              }
              //往左去看左边有么
              else if (arr[mid] < val)
                  low = mid + 1;
              else
                  high = mid - 1;
          }
          return -1;
      }
  
      public static void main(String[] args) {
          int[] arr = {1, 2, 3, 3, 3, 3, 4, 5};
          int map = countSame2(arr, 3);
          System.out.println(map);
      }
  }
  

能开始写一点点代码了，知道了思路之后能写出来了，但是在细节实现方面还是不行，加油啊骚年