1.
public boolean isPalindrome(String s) {
StringBuffer buffer = new StringBuffer();
int length = s.length();
for (int i = 0; i < length; i++) {
char ch = s.charAt(i);
if (Character.isLetterOrDigit(ch)){
buffer.append(Character.toLowerCase(ch));
}
}
String s1 = buffer.toString();
/*String s2 = new StringBuffer(buffer).reverse().toString();
return s1.equals(s2);*/直接用string的reverse函数也可以
int left = 0;
int right = s1.length() - 1;
while(left <= right){
if (Character.toLowerCase(s1.charAt(left)) != Character.toLowerCase(s1.charAt(right))){
return false;
}
left++;
right--;
}
return true;
}
2.
public List<List<String>> partition(String s) {
List<List<String>> result = new ArrayList<>();//储存结果
Deque<String> stack = new ArrayDeque<>();//栈
if (s.length() == 0){
return result;
}
backtracking(s,0,stack,result);
return result;
}
public void backtracking(String s , int startIndex , Deque<String> stack , List<List<String>> result){
//回溯
if (startIndex >= s.length()){
result.add(new ArrayList<>(stack));
return;
}
for (int i = startIndex; i < s.length(); i++) {
if (isPalindrome2(s,startIndex,i)){
String str = s.substring(startIndex,i+1);
stack.addLast(str);
}else {
continue;
}
backtracking(s,i+1,stack,result);
stack.removeLast();
}
}
public boolean isPalindrome2(String s, int start , int end){
//判断是否为回文串
for (int i = start , j = end; i < j; i++ , j--) {
if (s.charAt(i) != s.charAt(j)){
return false;
}
}
return true;
}
3.
public boolean wordBreak(String s, List<String> wordDict) {
Set<String> wordDictSet = new HashSet(wordDict);
boolean[] dp = new boolean[s.length() + 1];
dp[0] = true;
for (int i = 1; i <= s.length(); i++) {
for (int j = 0; j < i; j++) {
if (dp[j] && wordDictSet.contains(s.substring(j, i))) {
dp[i] = true;
break;
}
}
}
return dp[s.length()];
}
4.
public List<String> wordBreak2(String s, List<String> wordDict) {
Map<Integer, List<List<String>>> map = new HashMap<Integer, List<List<String>>>();
List<List<String>> wordBreaks = backtrack(s, s.length(), new HashSet<String>(wordDict), 0, map);
List<String> breakList = new LinkedList<String>();
for (List<String> wordBreak : wordBreaks) {
breakList.add(String.join(" ", wordBreak));
}
return breakList;
}
public List<List<String>> backtrack(String s, int length, Set<String> wordSet, int index, Map<Integer, List<List<String>>> map) {
if (!map.containsKey(index)) {
//将单词的第一个index存在map中，减少回溯次数，避免例如aaaaaaaa的情况下超时
List<List<String>> wordBreaks = new LinkedList<List<String>>();
if (index == length) {
wordBreaks.add(new LinkedList<String>());
}
for (int i = index + 1; i <= length; i++) {
String word = s.substring(index, i);
if (wordSet.contains(word)) {
List<List<String>> nextWordBreaks = backtrack(s, length, wordSet, i, map);
for (List<String> nextWordBreak : nextWordBreaks) {
LinkedList<String> wordBreak = new LinkedList<String>(nextWordBreak);
wordBreak.offerFirst(word);
wordBreaks.add(wordBreak);
}
}
}
map.put(index, wordBreaks);
}
return map.get(index);
}
5.
class Trie {
private TrieNode root;
/** Initialize your data structure here. */
public Trie() {
root = new TrieNode();
}
/** Inserts a word into the trie. */
public void insert(String word) {
TrieNode node = root;
for (int i = 0; i < word.length(); i++) {
char ch = word.charAt(i);
if (!node.containsKey(ch)){
node.put(ch,new TrieNode());
}
node = node.get(ch);
}
node.setEnd();
}
/** Returns if the word is in the trie. */
public boolean search(String word) {
TrieNode node = root;
for (int i = 0; i < word.length(); i++) {
char ch = word.charAt(i);
if (node.containsKey(ch)){
node = node.get(ch);
}else {
return false;
}
}
return node.isEnd();
}
/** Returns if there is any word in the trie that starts with the given prefix. */
public boolean startsWith(String prefix) {
TrieNode node = root;
for (int i = 0; i < prefix.length(); i++) {
char ch = prefix.charAt(i);
if (node.containsKey(ch)){
node = node.get(ch);
continue;
}else {
return false;
}
}
return true;
}
}
class TrieNode {
// R links to node children
private TrieNode[] links;
private final int R = 26;
private boolean isEnd;
private String word = null;
public TrieNode() {
links = new TrieNode[R];
}
public boolean containsKey(char ch) {
if ((ch - 'a') >= 26 || (ch - 'a') < 0){
return false;
}
return links[ch -'a'] != null;
}
public TrieNode get(char ch) {
return links[ch -'a'];
}
public void put(char ch, TrieNode node) {
links[ch -'a'] = node;
}
public void setEnd() {
isEnd = true;
}
public boolean isEnd() {
return isEnd;
}
public String getWord() {
return word;
}
public void setWord(String word) {
this.word = word;
}
}
6.
public List<String> findWords(char[][] board, String[] words) {
List<String> result = new ArrayList<>();
TrieNode root = new TrieNode();//用到了上一题的TireNode
for (String word : words) {
TrieNode node = root;
for (char ch : word.toCharArray()) {
if (!node.containsKey(ch)) {
node.put(ch, new TrieNode());
}
node = node.get(ch);
}
node.setWord(word);
}
for (int i = 0; i < board.length; i++) {
for (int j = 0; j < board[i].length; j++) {
if (root.containsKey(board[i][j])){
backtracking(i,j,root,board,result);
}
}
}
return result;
}
private void backtracking(int row, int col, TrieNode parent,char[][] board,List<String> result){
char ch = board[row][col];
TrieNode node = parent.get(ch);
if (node.getWord() != null){
result.add(node.getWord());
node.setWord(null);
}
board[row][col] = '#';
int[] rowOffset = {
-1, 0, 1, 0};
int[] colOffset = {
0, 1, 0, -1};
for (int i = 0; i < 4; i++) {
int newRow = row + rowOffset[i];
int newCol = col + colOffset[i];
if (newRow < 0 || newRow >= board.length || newCol < 0 || newCol >= board[0].length){
continue;
}
if (node.containsKey(board[newRow][newCol])){
backtracking(newRow,newCol,node,board,result);
}
}
board[row][col] = ch;
}
7.
public boolean isAnagram(String s, String t) {
HashMap<Character , Integer> map1 = new HashMap<>();
HashMap<Character , Integer> map2 = new HashMap<>();
for (int i = 0; i < s.length(); i++) {
Character ch = s.charAt(i);
if (map1.containsKey(ch)){
int value = map1.get(ch).intValue() + 1;
map1.put(ch,value);
}else {
map1.put(ch,1);
}
}
for (int i = 0; i < t.length(); i++) {
Character ch = t.charAt(i);
if (map2.containsKey(ch)){
int value = map2.get(ch).intValue() + 1;
map2.put(ch,value);
}else {
map2.put(ch,1);
}
}
if (map1.equals(map2)){
return true;
}else {
return false;
}
}
8.
public int firstUniqChar(String s) {
HashMap<Character,Integer> map = new HashMap<>();
if (s.length() == 1){
return 0;
}
for (int i = 0; i < s.length(); i++) {
if (!map.containsKey(s.charAt(i)) && i == s.length() -1){
return i;
}
if (map.containsKey(s.charAt(i))){
continue;
}else {
for (int j = i+1; j <s.length() ; j++) {
if (s.charAt(i) == s.charAt(j)){
map.put(s.charAt(i),1);
break;
}
if (j == s.length() - 1){
map.put(s.charAt(i),0);
return i;
}
}
}
}
return -1;
}
或者
public int firstUniqChar(String s) {
Map<Character, Integer> frequency = new HashMap<Character, Integer>();
for (int i = 0; i < s.length(); ++i) {
char ch = s.charAt(i);
frequency.put(ch, frequency.getOrDefault(ch, 0) + 1);
}
for (int i = 0; i < s.length(); ++i) {
if (frequency.get(s.charAt(i)) == 1) {
return i;
}
}
return -1;
}
数组计数更快
public int firstUniqChar(String s) {
int[] arr = new int[26];
int n = s.length();
for (int i = 0; i < n; i++) {
arr[s.charAt(i)-'a']++ ;
}
for (int i = 0; i < n; i++) {
if (arr[s.charAt(i)-'a'] == 1) {
return i;
}
}
return -1;
}
9.
public void reverseString(char[] s) {
char tmp ;
for (int i = 0; i < s.length/2; i++) {
tmp = s[i];
s[i] = s[s.length - i - 1];
s[s.length - i - 1] = tmp;
}
}