字符的最短距离

题目：

给你一个字符串 s 和一个字符 c ，且 c 是 s 中出现过的字符。

返回一个整数数组 answer ，其中 answer.length == s.length 且 answer[i] 是 s 中从下标 i 到离它 最近 的字符 c 的 距离 。

两个下标 i 和 j 之间的 距离 为 abs(i - j) ，其中 abs 是绝对值函数。

示例 1：

输入：s = "loveleetcode", c = "e"

输出：[3,2,1,0,1,0,0,1,2,2,1,0]

解释：字符 'e' 出现在下标 3、5、6 和 11 处（下标从 0 开始计数）。

距下标 0 最近的 'e' 出现在下标 3 ，所以距离为 abs(0 - 3) = 3 。

距下标 1 最近的 'e' 出现在下标 3 ，所以距离为 abs(1 - 3) = 2 。

对于下标 4 ，出现在下标 3 和下标 5 处的 'e' 都离它最近，但距离是一样的 abs(4 - 3) == abs(4 - 5) = 1 。

距下标 8 最近的 'e' 出现在下标 6 ，所以距离为 abs(8 - 6) = 2 。

示例 2：

输入：s = "aaab", c = "b"

输出：[3,2,1,0]

提示：

1 <= s.length <= 104

s[i] 和 c 均为小写英文字母

题目数据保证 c 在 s 中至少出现一次

Related Topics

数组

双指针

字符串

解题思路：

1. 先将字符串转换成字符数组进行遍历，找出字符所在的位置。
2. 将字符所在位置的索引值加1后存入一个字符位置列表中。
3. 并将整数数组对应位置的值设置为0，然后将非字符的所在位置的索引值加1后赋值给整数数组索引对应的位置。
4. 使用两层遍历，第一层为字符数组的遍历，同时在第一层中设置一个距离的参照值（我默认为字符数组的长度），第二层为位置列表的遍历。
5. 将位置列表的每个值与字符数组中每个非零的值进行相减，然后取所得值的绝对值。
6. 将绝对值与参照值比较，当绝对值比参照值小的时候，就将小的值赋给参照值。
7. 一直重复步骤5，6后，最终就可以计算出对应的位置距离数组。

public int[] shortestToChar (String test,char c){
            // 整数数组
            Integer answer[] = new Integer[test.length()];

            // 记录字符的位置列表
            List<Integer> zero = new ArrayList<>();

            // 转换为字符数组
            char[] chars = test.toCharArray();

            // 找出字符在字符串中的位置
            for (int i = 0; i < chars.length; i++) {
                if (chars[i] == c) {
                    answer[i] = 0;
                    // 记录c字符的位置
                    zero.add(i + 1);
                } else {
                    // 记录非c字符的位置
                    answer[i] = i + 1;
                }
            }

            System.out.print("c的位置:");
            for (Integer integer : zero) {
                System.out.print(integer + "-");
            }

            System.out.println();
            System.out.print("数组的初始位置:");
            for (Integer integer : answer) {
                System.out.print(integer + "-");
            }

            System.out.println();
            for (int i = 0; i < answer.length; i++) {
                // 给一个较大的值
                int distance = answer.length;
                for (int k = 0; k < zero.size(); k++) {
                    if (answer[i] != 0) {
                        // 计算某个字符到目标字符之间的距离
                        int length = answer[i] - zero.get(k);
                        // 取绝对值
                        length = Math.abs(length);
                        if (length < distance) {
                            // 赋值最小的距离
                            distance = length;
                        }
                    } else {
                        distance = 0;
                    }
                }
                answer[i] = distance;
            }

            System.out.print("距离数组:");
            for (Integer integer : answer) {
                System.out.print(integer + "-");
            }
        }

这种思路实现的算法的时间复杂度和空间复杂度情况：

 个人暂时使用的是初步破解，方法不是最有，待个人的优化