字符串2、27、34

2、替换空格

toCharArray（） 字符数组

java

import java.util.*;
public class Solution {
    public String replaceSpace (String s) {
        StringBuilder sb = new StringBuilder();
        for(char c:s.toCharArray()){
            sb.append(c==' '?"%20":c);
        }
        return sb.toString();
    }
}

python

s.replace(" ", "%20")

27、字符串的排列

回溯与递归

解析非常好

LEETCODE

class Solution {
    List<String> res = new LinkedList<>();
    char[] c;
    public String[] permutation(String s) {
        c = s.toCharArray();
        dfs(0);
        return res.toArray(new String[res.size()]);
    }
    void dfs(int x) {
        if(x == c.length - 1) {
            res.add(String.valueOf(c));      // 添加排列方案
            return;
        }
        HashSet<Character> set = new HashSet<>();
        for(int i = x; i < c.length; i++) {
            if(set.contains(c[i])) continue; // 重复，因此剪枝
            set.add(c[i]);
            swap(i, x);                      // 交换，将 c[i] 固定在第 x 位
            dfs(x + 1);                      // 开启固定第 x + 1 位字符
            swap(i, x);                      // 恢复交换
        }
    }
    void swap(int a, int b) {
        char tmp = c[a];
        c[a] = c[b];
        c[b] = tmp;
    }
}

牛客上的解析也很好

牛客

import java.util.ArrayList;
import java.util.List;
import java.util.Collections;
public class Solution {
    public ArrayList<String> Permutation(String str) {
        List<String> resultList = new ArrayList<>();
        if(str.length() == 0)
            return (ArrayList)resultList;
        //递归的初始值为（str数组，空的list，初始下标0）
        fun(str.toCharArray(),resultList,0);
        Collections.sort(resultList);
        return (ArrayList)resultList;
    }
    
    private void fun(char[] ch,List<String> list,int i){
        //这是递归的终止条件，就是i下标已经移到char数组的末尾的时候，考虑添加这一组字符串进入结果集中
        if(i == ch.length-1){
            //判断一下是否重复
            if(!list.contains(new String(ch))){
                list.add(new String(ch));
                return;
            }
        }else{//回溯法
            for(int j=i;j<ch.length;j++){
                swap(ch,i,j);
                fun(ch,list,i+1);
                swap(ch,i,j);
            }
        }
    }
    
    //交换数组的两个下标的元素
    private void swap(char[] str, int i, int j) {
            if (i != j) {
                char t = str[i];
                str[i] = str[j];
                str[j] = t;
            }
        }
    } 

34、第一个只出现一次的字符

Map是存储键和值这样的双列数据集合，但存储的数据是没有顺序的，其键不能重复，但其值是可以重复的，可以通过每一个键找到每一个对应的值;HashMap线程不同步的，即线程不安全的，但只有一个线程访问时效率较高;

两者功能相同，不过一般在项目中，HashMap用的比较多些

HashMap不能使用基本数据类型，要使用引用类型

leetcode 返回字母

class Solution {
    public char firstUniqChar(String s) {
        HashMap<Character, Boolean> dic = new HashMap<> ();
        char[] char_array = s.toCharArray(); // 字符串转为字符数组，便于遍历
        for(char c:char_array){
            /*
            若 dic中不包含键(key) c ：则向 dic中添加键值对(c, True)，代表字符 c的数量为 1;
            若 dic中包含键(key) c ：则修改 dic中键 c的值为 False，代表字符 c的数量 > 1;
            */
            dic.put(c, !dic.containsKey(c));
        }
        for(char c:char_array) {
            if(dic.get(c)) // 若 dic中键 c对应的值为 True，则返回 c 
                return c;
        }
        return ' '; // 字符串无只出现一次的字符
    }
}

牛客 返回字母位置

public class Solution {
    public int FirstNotRepeatingChar(String str) {
        int[] cnts = new int[128];
        for (int i = 0; i < str.length(); i++)
            cnts[str.charAt(i)]++;
        for (int i = 0; i < str.length(); i++)
            if (cnts[str.charAt(i)] == 1)
                return i;
        return -1;
    }
}