add daily exercise

Author: quchao161

Diff for: data_struct_study/.idea/workspace.xml

@@ -4,12 +4,10 @@
 /**
  * 编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
  *
- * 不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
+ * 不要创建另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
  *
  * 你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。
  *
- *  
- *
  * 示例 1：
  *
  * 输入：["h","e","l","l","o"]
@@ -23,15 +21,37 @@
  */
 public class Solution344 {
 
-    public static String reverseRecursive(String s){
-        int length = s.length();
-        if(length<=1){
+    // 1、递归解法会占用递归栈空间
+    public String reverseString(String s) {
+        // 1、初始化数组长度 & 当长度<=1说明不需要反转
+        int len = s.length();
+        if (len <=1 ) {
             return s;
+        }
+
+        // 2、在递归的过程中不断反转当前字符串的左子字符串与右子字符串，注意右在前，左在后，就是为了实现反转的效果
+        String leftStr = s.substring(0, len / 2);
+        String rightStr = s.substring(len / 2, len);
+        return reverseString(rightStr) + reverseString(leftStr);
+    }
 
+    // 2、双指针解法，不断交换数组当前的首元素与尾元素，一个for循环搞定
+    // 时间复杂度：O(n)，空间复杂度：O(1)
+    public void reverseString(char[] nums) {
+        // 1、初始化数组长度
+        int len = nums.length;
+
+        // 2、在for循环中不断交换当前的首元素与尾元素
+        for (int l = 0, r = len - 1; l < r; ++l, --r) {
+            char t = nums[l];
+            nums[l] = nums[r];
+            nums[r] = t;
         }
-        String left  = s.substring(0,length/2);
-        String right = s.substring(length/2 ,length);
-        String afterReverse = reverseRecursive(right)+reverseRecursive(left);//此处是递归的方法调用
-        return afterReverse;
+    }
+
+    public static void main(String[] args) {
+        // ["h","e","l","l","o"]
+        String s = "hello";
+        System.out.println(new Solution344().reverseString(s));
     }
 }

Diff for: data_struct_study/out/production/data_struct_study/array_problem/Solution344.class

@@ -3,26 +3,44 @@
 /**
  * 数组中只出现一次的数字：一个整型数组里除了两个数字之外，
  * 其他的数字都出现了两次，找出这两个数。
- *
- * 两个不相等的元素在位级表示上必定会有一位存在不同，将数组的所有
- * 元素异或得到的结果为不存在重复的两个元素异或的结果。
- *
- * diff &= -diff 得到出 diff 最右侧不为 0 的位，也就是不存在
- * 重复的两个元素在位级表示上最右侧不同的那一位，利用这一位就可以
- * 将两个元素区分开来。
  */
 public class Solution_1 {
 
+
+    // 1、哈希法：遍历数组，用map记录所有元素出现的次数，然后再遍历数组，找出只出现一次的数。
+    // 时间复杂度：O(n), 空间复杂度：O(n)
+    // 2、位运算：两个不相等的元素在位级表示上必定会有一位存在不同，将数组的所有元素异或得到的结果
+    // 为不存在重复的两个元素异或的结果。
+    // diff &= -diff 得出 diff 最低位的1，也就是不存在重复的两个元素在位级表示上最右侧不同
+    // 的那一位，利用这一位就可以将两个元素区分开来。
+    // 时间复杂度：O(n), 空间复杂度：O(1)
     public void FindNumsAppearOnce(int[] nums, int num1[], int num2[]) {
+
+        // 1、利用 0 ^ x = x 和 x ^ y = 1、x ^ x = 0 的性质来遍历数组，
+        // 最后得到的值就是两个不同元素异或的值
         int diff = 0;
-        for (int num : nums)
+        for(int num:nums) {
             diff ^= num;
+        }
+
+        // 2、利用 x & -x 得到x最低位的1
         diff &= -diff;
-        for (int num : nums) {
-            if ((num & diff) == 0)
+
+        // 3、遍历数组：利用 最低位1 & 当前元素是否为0来分离两个不同的元素
+        for(int num:nums) {
+            // 注意这里加括号
+            if ((diff & num) == 0) {
                 num1[0] ^= num;
-            else
+            } else {
                 num2[0] ^= num;
+            }
         }
     }
+
+    public static void main(String[] args) {
+        int[] nums = new int[]{1, 2, 3, 2, 1, 4};
+        int[] num1 = new int[]{0};
+        int[] num2 = new int[]{0};
+        new Solution_1().FindNumsAppearOnce(nums, num1, num2);
+    }
 }

Diff for: data_struct_study/out/production/data_struct_study/array_problem/Solution_1.class

@@ -1,8 +1,8 @@
 package array_problem;
 
 /**
- * 多数投票问题，可以利用 Boyer-Moore Majority Vote Algorithm
- * 来解决这个问题，使得时间复杂度为 O(N)。
+ * 多数投票问题，可以利用 Boyer-Moore 投票算法
+ * 来解决这个问题，使得时间复杂度为 O(n)。
  *
  * 使用 cnt 来统计一个元素出现的次数，当遍历到的元素和统计元素相等时，
  * 令 cnt++，否则令 cnt--。如果前面查找了 i 个元素，且 cnt == 0，
@@ -13,19 +13,35 @@
  */
 public class Solution_2 {
 
-    public int MoreThanHalfNum_Solution(int[] nums) {
-        int majority = nums[0];
-        for (int i = 1, cnt = 1; i < nums.length; i++) {
-            cnt = nums[i] == majority ? cnt + 1 : cnt - 1;
-            if (cnt == 0) {
-                majority = nums[i];
-                cnt = 1;
+    // 1、哈希表：用hashMap统计所有元素出现的次数，时间复杂度O(n), 空间复杂度O(n)
+    // 2、排序：如果将数组 nums 中的所有元素按照单调递增或单调递减的顺序排序，
+    // 那么下标为n/2的元素一定是众数。时间复杂度O(nlog(n))，空间复杂度O(logn)(自己实现堆排序O(1))
+    // 3、Boyer Moore投票算法：时间复杂度O(n), 空间复杂度O(1)
+    public int majorityElement(int[] nums) {
+
+        // 1、初始化出现次数和候选众数
+        int count = 0;
+        Integer candidate = null;
+
+        // 2、遍历数组
+        for (int num : nums) {
+            // 3、如果出现次数为0，则更新当前的候选众数
+            if (count == 0) {
+                candidate = num;
             }
+            // 4、然后更新当前候选众数的出现次数：当前元素与候选众数相等，则+1，否则-1
+            count += (num == candidate) ? 1 : -1;
         }
-        int cnt = 0;
-        for (int val : nums)
-            if (val == majority)
-                cnt++;
-        return cnt > nums.length / 2 ? majority : 0;
+
+        // 5、最后的候选众数就是真正的众数
+        // 为什么？如果候选众数不是真正的众数，则真正众数会和其它非候选人一起反对，此时候选众数就会下台（count==0），
+        // 如果候选众数是真正的众数，则真正的众数就会支持，其它非获选人会一起反对，此时候选众数最后一定会当选。
+        return candidate;
     }
+
+    public static void main(String[] args) {
+        int[] nums = new int[]{2,2,1,1,1,2,2};
+        System.out.println(new Solution_2().majorityElement(nums));
+    }
+
 }