其他解法

znn0301 · znn0301 · commit 1b158577e379 · 2020-10-10T18:03:00.000+08:00
diff --git a/src/main/java/com/chen/algorithm/study/offer/test29/Solution.java b/src/main/java/com/chen/algorithm/study/offer/test29/Solution.java
@@ -0,0 +1,87 @@
+package com.chen.algorithm.study.offer.test29;
+
+import java.util.Arrays;
+
+/**
+ * @Auther: zhunn
+ * @Date: 2020/10/10 13:58
+ * @Description: 顺时针从外往里打印矩阵（螺旋矩阵，力扣第54题）
+ */
+public class Solution {
+
+    public static int[] spiralOrder(int[][] matrix) {
+        if (matrix.length == 0) {
+            return new int[0];
+        }
+        int[] res = new int[matrix.length * matrix[0].length];
+        int u = 0, d = matrix.length - 1, l = 0, r = matrix[0].length - 1;
+        int idx = 0;
+        while (true) {
+            for (int i = l; i <= r; i++) {
+                res[idx++] = matrix[u][i];
+            }
+            if (++u > d) {
+                break;
+            }
+            for (int i = u; i <= d; i++) {
+                res[idx++] = matrix[i][r];
+            }
+            if (--r < l) {
+                break;
+            }
+            for (int i = r; i >= l; i--) {
+                res[idx++] = matrix[d][i];
+            }
+            if (--d < u) {
+                break;
+            }
+            for (int i = d; i >= u; i--) {
+                res[idx++] = matrix[i][l];
+            }
+            if (++l > r) {
+                break;
+            }
+        }
+        return res;
+    }
+
+    private static int[] spiralOrder1(int[][] matrix) {
+        if (matrix == null || matrix.length == 0) return new int[0];
+
+        int numEle = matrix.length * matrix[0].length;
+        int[] result = new int[numEle];
+        int idx = 0;
+        int left = 0, right = matrix[0].length - 1, top = 0, bottom = matrix.length - 1;
+
+        while (numEle >= 1) {
+            for (int i = left; i <= right && numEle >= 1; i++) {
+                result[idx++] = matrix[top][i];
+                numEle--;
+            }
+            top++;
+            for (int i = top; i <= bottom && numEle >= 1; i++) {
+                result[idx++] = matrix[i][right];
+                numEle--;
+            }
+            right--;
+            for (int i = right; i >= left && numEle >= 1; i--) {
+                result[idx++] = matrix[bottom][i];
+                numEle--;
+            }
+            bottom--;
+            for (int i = bottom; i >= top && numEle >= 1; i--) {
+                result[idx++] = matrix[i][left];
+                numEle--;
+            }
+            left++;
+        }
+        return result;
+    }
+
+    public static void main(String[] args) {
+        int[][] matrix = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
+        int[] res = spiralOrder1(matrix);
+        System.out.println(Arrays.toString(res));
+    }
+
+}
diff --git a/src/main/java/com/chen/algorithm/study/test1/Solution.java b/src/main/java/com/chen/algorithm/study/test1/Solution.java
@@ -6,10 +6,15 @@
  * 正确
  * @author :  chen weijie
  * @Date: 2019-09-02 23:52
+ * @Description: 两数之和
  */
 public class Solution {
 
     public int[] twoSum(int[] nums, int target) {
+        if (nums == null || nums.length == 0) {
+            return new int[0];
+        }
+
         for (int i = 0; i < nums.length; i++) {
             for (int j = i + 1; j < nums.length; j++) {
                 if (nums[i] + nums[j] == target) {
diff --git a/src/main/java/com/chen/algorithm/study/test26/Solution3.java b/src/main/java/com/chen/algorithm/study/test26/Solution3.java
@@ -0,0 +1,38 @@
+package com.chen.algorithm.study.test26;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+
+/**
+ * @Auther: zhunn
+ * @Date: 2020/10/10 16:23
+ * @Description: 删除排序数组中的重复项，返回新数组长度。双指针法
+ */
+public class Solution3 {
+
+    /**
+     * 双指针法 ,数组是一个引用
+     *
+     * @param nums
+     * @return
+     */
+    public int removeDuplicates(int[] nums) {
+        if (nums == null || nums.length == 0) return 0;
+
+        int i = 0;
+        for (int j = 0; j < nums.length; j++) {
+            if (nums[j] != nums[i]) {
+                i++;
+                nums[i] = nums[j];
+            }
+        }
+        //System.out.println(Arrays.toString(nums));
+        return i + 1;
+    }
+
+    @Test
+    public void test() {
+        System.out.println(removeDuplicates(new int[]{0, 0, 1, 1, 2, 3, 4, 5, 5, 6}));
+    }
+}
diff --git a/src/main/java/com/chen/algorithm/study/test27/Solution2.java b/src/main/java/com/chen/algorithm/study/test27/Solution2.java
@@ -0,0 +1,32 @@
+package com.chen.algorithm.study.test27;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+
+/**
+ * @Auther: zhunn
+ * @Date: 2020/10/10 16:40
+ * @Description: 移除元素，双指针法
+ */
+public class Solution2 {
+
+    public int removeElement(int[] nums, int val) {
+        if (nums == null || nums.length == 0) return 0;
+
+        int i = 0;
+        for (int j = 0; j < nums.length; j++) {
+            if (nums[j] != val) {
+                nums[i] = nums[j];
+                i++;
+            }
+        }
+        System.out.println(Arrays.toString(nums));
+        return i;
+    }
+
+    @Test
+    public void test() {
+        System.out.println(removeElement(new int[]{1, 1, 2, 2, 3, 5, 6, 7, 8}, 2));
+    }
+}
diff --git a/src/main/java/com/chen/algorithm/study/test34/Solution4.java b/src/main/java/com/chen/algorithm/study/test34/Solution4.java
@@ -0,0 +1,83 @@
+package com.chen.algorithm.study.test34;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+
+/**
+ * @Auther: zhunn
+ * @Date: 2020/10/10 17:04
+ * @Description: 在排序数组中查找元素的第一个和最后一个位置
+ * (可使用二分查找到第一个与target相等元素和最后一个与target相等元素 方式，返回下标)
+ */
+public class Solution4 {
+
+    /**
+     * 当key=array[mid]时， 往左边一个一个逼近，right = mid -1; 返回left
+     *
+     * @param nums
+     * @param target
+     * @return
+     */
+    private int leftIndex(int[] nums, int target) {
+        if (nums == null || nums.length == 0) {
+            return -1;
+        }
+
+        int left = 0, right = nums.length - 1;
+        while (left <= right) {
+            int mid = (right - left) / 2 + left;
+            if (nums[mid] >= target) {
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        }
+
+        if (left <= nums.length - 1 && nums[left] == target) {
+            return left;
+        }
+        return -1;
+    }
+
+    /**
+     * 当key=array[mid]时， 往右边一个一个逼近，left = mid + 1; 返回right
+     *
+     * @param nums
+     * @param target
+     * @return
+     */
+    private int rightIndex(int[] nums, int target) {
+        if (nums == null || nums.length == 0) {
+            return -1;
+        }
+        int left = 0, right = nums.length - 1;
+        while (left <= right) {
+            int mid = (right - left) / 2 + left;
+            if (nums[mid] <= target) {
+                left = mid + 1;
+            } else {
+                right = mid - 1;
+            }
+        }
+        if (right >= 0 && nums[right] == target) {
+            return right;
+        }
+        return -1;
+    }
+
+    public int[] find(int[] nums, int target) {
+        int[] res = new int[2];
+        res[0] = leftIndex(nums, target);
+        res[1] = rightIndex(nums, target);
+        return res;
+    }
+
+    @Test
+    public void test() {
+        int[] nums = new int[]{5, 7, 7, 8, 8, 8, 10};
+        int[] res = find(nums, 8);
+        System.out.println(Arrays.toString(res));
+    }
+
+}
diff --git a/src/main/java/com/chen/algorithm/study/test69/Solution.java b/src/main/java/com/chen/algorithm/study/test69/Solution.java
@@ -5,6 +5,7 @@
 /**
  * @author :  chen weijie
  * @Date: 2020-05-03 09:39
+ * @Description: x的平方根，舍弃小数
  */
 public class Solution {
 
diff --git a/src/main/java/com/chen/algorithm/study/test72/Solution2.java b/src/main/java/com/chen/algorithm/study/test72/Solution2.java
@@ -0,0 +1,124 @@
+package com.chen.algorithm.study.test72;
+
+/**
+ * @Auther: zhunn
+ * @Date: 2020/10/9 13:54
+ * @Description: 编辑距离算法
+ * 距离值：变更次数--- 先计算两个字符串的差异, str1 str2, str1要做多少次(每次一个char字符)增加 删除 替换 操作 才能与str2一致
+ * 相似度：用最长的字符串的len 减去 变更次数 ,然后除以最长的字符串长度.  similarity = (maxLen - changeTimes)/maxLen
+ * ORACLE函数: UTL_MATCH.EDIT_DISTANCE
+ * select UTL_MATCH.EDIT_DISTANCE('Java你好','你好') from dual;
+ */
+public class Solution2 {
+
+
+    /**
+     * 编辑距离算法
+     *
+     * @param sourceStr 原字符串
+     * @param targetStr 目标字符串
+     * @return 返回最小距离: 原字符串需要变更多少次才能与目标字符串一致（变更动作：增加/删除/替换,每次都是以字节为单位）
+     */
+    public static int minDistance(String sourceStr, String targetStr) {
+        int sourceLen = sourceStr.length();
+        int targetLen = targetStr.length();
+
+        if (sourceLen == 0) {
+            return targetLen;
+        }
+        if (targetLen == 0) {
+            return sourceLen;
+        }
+
+        //定义矩阵(二维数组)
+        int[][] arr = new int[sourceLen + 1][targetLen + 1];
+
+        for (int i = 0; i < sourceLen + 1; i++) {
+            arr[i][0] = i;
+        }
+        for (int j = 0; j < targetLen + 1; j++) {
+            arr[0][j] = j;
+        }
+
+        //矩阵打印
+        System.out.println("初始化矩阵打印开始");
+        for (int i = 0; i < sourceLen + 1; i++) {
+
+            for (int j = 0; j < targetLen + 1; j++) {
+                System.out.print(arr[i][j] + "\t");
+            }
+            System.out.println();
+        }
+        System.out.println("初始化矩阵打印结束");
+
+        for (int i = 1; i < sourceLen + 1; i++) {
+            for (int j = 1; j < targetLen + 1; j++) {
+
+                if (sourceStr.charAt(i - 1) == targetStr.charAt(j - 1)) {
+                    /*
+                     *  如果source[i] 等于target[j]，则：d[i, j] = d[i-1, j-1] + 0          （递推式 1）
+                     */
+                    arr[i][j] = arr[i - 1][j - 1];
+                } else {
+                    /*  如果source[i] 不等于target[j]，则根据插入、删除和替换三个策略，分别计算出使用三种策略得到的编辑距离，然后取最小的一个：
+                        d[i, j] = min(d[i, j - 1] + 1, d[i - 1, j] + 1, d[i - 1, j - 1] + 1 )    （递推式 2）
+                        >> d[i, j - 1] + 1 表示对source[i]执行插入操作后计算最小编辑距离
+                        >> d[i - 1, j] + 1 表示对source[i]执行删除操作后计算最小编辑距离
+                        >> d[i - 1, j - 1] + 1表示对source[i]替换成target[i]操作后计算最小编辑距离
+                    */
+                    arr[i][j] = (Math.min(Math.min(arr[i - 1][j], arr[i][j - 1]), arr[i - 1][j - 1])) + 1;
+                }
+            }
+        }
+
+        System.out.println("----------矩阵打印---------------");
+        //矩阵打印
+        for (int i = 0; i < sourceLen + 1; i++) {
+
+            for (int j = 0; j < targetLen + 1; j++) {
+                System.out.print(arr[i][j] + "\t");
+            }
+            System.out.println();
+        }
+        System.out.println("----------矩阵打印---------------");
+
+        return arr[sourceLen][targetLen];
+    }
+
+    /**
+     * 计算字符串相似度
+     * similarity = (maxlen - distance) / maxlen
+     * ps: 数据定义为double类型,如果为int类型 相除后结果为0(只保留整数位)
+     *
+     * @param str1
+     * @param str2
+     * @return
+     */
+    public static double getsimilarity(String str1, String str2) {
+        double distance = minDistance(str1, str2);
+        double maxlen = Math.max(str1.length(), str2.length());
+        double res = (maxlen - distance) / maxlen;
+
+        //System.out.println("distance="+distance);
+        //System.out.println("maxlen:"+maxlen);
+        //System.out.println("(maxlen - distance):"+(maxlen - distance));
+        return res;
+    }
+
+    public static String evaluate(String str1, String str2) {
+        double result = getsimilarity(str1, str2);
+        return String.valueOf(result);
+    }
+
+    public static void main(String[] args) {
+        String str1 = "2/F20NGNT";
+        String str2 = "1/F205ONGNT";
+        int result = minDistance(str1, str2);
+        //String res = evaluate(str1, str2);
+        System.out.println("最小编辑距离minDistance:" + result);
+        //System.out.println(str1 + "与" + str2 + "相似度为：" + res);
+
+
+    }
+
+}
