数据结构—字符串

1 反转字符串中的单词
题目： 给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序
示例 1:
输入: “Let’s take LeetCode contest”
输出: “s’teL ekat edoCteeL tsetnoc”
注意：在字符串中，每个单词由单个空格分隔，并且字符串中不会有任何额外的空格。
方法一：简单的解法 [Accepted]

public class Solution {
    public String reverseWords(String s) {
        String words[] = s.split(" ");
        StringBuilder res=new StringBuilder();
        for (String word: words)
            res.append(new StringBuffer(word).reverse().toString() + " ");
        return res.toString().trim();
    }
}

方法二：不使用自带的 split 和 reverse 函数
我们可以自己写一个 split 和 reverse 函数。 split 函数将字符串按照 " " （空格）为分隔符将字符串分开并返回单词列表。 reverse 函数返回每个字符串反转后的字符串。

public class Solution {
    public String reverseWords(String s) {
        String words[] = split(s);
        StringBuilder res=new StringBuilder();
        for (String word: words)
            res.append(reverse(word) + " ");
        return res.toString().trim();
    }
    public String[] split(String s) {
        ArrayList < String > words = new ArrayList < > ();
        StringBuilder word = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == ' ') {
                words.add(word.toString());
                word = new StringBuilder();
            } else
                word.append( s.charAt(i));
        }
        words.add(word.toString());
        return words.toArray(new String[words.size()]);
    }
    public String reverse(String s) {
        StringBuilder res=new StringBuilder();
        for (int i = 0; i < s.length(); i++)
            res.insert(0,s.charAt(i));
        return res.toString();
    }
}

3 使用 StringBuilder 和 reverse 方法

public class Solution {
    public String reverseWords(String input) {
        final StringBuilder result = new StringBuilder();
        final StringBuilder word = new StringBuilder();
        for (int i = 0; i < input.length(); i++) {
            if (input.charAt(i) != ' ') {
                word.append(input.charAt(i));
            } else {
                result.append(word.reverse());
                result.append(" ");
                word.setLength(0);//反转每个 定时清零
            }
        }
        result.append(word.reverse());
        return result.toString();
    }
}

2 检测大写字母
给定一个单词，你需要判断单词的大写使用是否正确。
我们定义，在以下情况时，单词的大写用法是正确的：
全部字母都是大写，比如"USA"。
单词中所有字母都不是大写，比如"leetcode"。
如果单词不只含有一个字母，只有首字母大写， 比如 “Google”。
否则，我们定义这个单词没有正确使用大写字母。思路：把正确的条件判断上，其余就是错误。
示例 1:
输入: “USA”
输出: True
示例 2:
输入: “FlaG”
输出: False
注意: 输入是由大写和小写拉丁字母组成的非空单词。

class Solution {
    public boolean detectCapitalUse(String word) {
        int count=0;
        int index=0;
        for(int i=0;i<word.length();i++){
            if(word.charAt(i)-'A'<=25){
                count++;
                index=i;
            }
        }
        if((count==word.length())||(count==0)||(count==1&&index==0)){
            return true;
        }
        return false;
    }
}

3 替换空格
题目请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
示例 1：
输入：s = “We are happy.”
输出：“We%20are%20happy.”

package com.jiashun;
public class test6 {
    public static void main(String[] args) {
        String string = replaceSpace("we are happy");
        System.out.println(string);
    }
    public static String replaceSpace(String s) {
        StringBuilder sb=new StringBuilder();
        for(Character c:s.toCharArray()){
              if(c==' '){
                  sb.append("%20");
              }else
                  sb.append(c);
        }
         return sb.toString();
    }
}

4 存在重复元素
给定一个整数数组，判断是否存在重复元素。
如果任何值在数组中出现至少两次，函数返回 true。如果数组中每个元素都不相同，则返回 false。
示例 1:
输入: [1,2,3,1]
输出: true
示例 2:
输入: [1,2,3,4]
输出: false
示例 3:
输入: [1,1,1,3,3,4,3,2,4,2]
输出: true
方法一：

public static boolean containsDuplicate(int[] nums) {
        Map<Integer,Integer>map=new HashMap<>();
           for(int c:nums){
                if(map.containsKey(c)){
                    map.put(c,map.get(c)+1);
             }else{
                 map.put(c,1);
             }
        }
        for(int c:map.values()){
               if(c>=2){
                   return true;
               }
        }
      return false;
    }
}

方法二：哈希表
利用支持快速搜索和插入操作的动态数据结构
有许多数据结构常用作动态集合,如二进制搜索树和哈希表。这里我们需要的操作是 search 和 insert。对于平衡二叉搜索树（Java 中的 TreeSet 或 TreeMap），search 和 insert 的时间复杂度均为 O(log⁡n)O(\log n)O(logn)。对于哈希表（Java 中的 HashSet 或HashMap），search 和 insert 的平均时间复杂度为 O(1)O(1)O(1)。因此，通过使用哈希表，我们可以达到在线性时间复杂度解决问题。

public boolean containsDuplicate(int[] nums) {
    Set<Integer> set = new HashSet<>(nums.length);
    for (int x: nums) {
        if (set.contains(x)) return true;
        set.add(x);
    }
    return false;
}
}