[算法]学习笔记day02
注：题目均来自力扣leetcode【学习参考】
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
class Solution {
public boolean isAnagram(String s, String t) {
if(s.length() != t.length()) return false;
int[] count = new int[26];
for(char c : s.toCharArray()){
count[c - 'a']++;
}
for(char c : t.toCharArray()){
count[c - 'a']--;
if(count[c - 'a'] < 0) return false;
}
return true;
}
}
字符串中的第一个唯一字符
案例:
s = “leetcode”
返回 0.
s = “loveleetcode”,
返回 2.
最优
class Solution {
public int firstUniqChar(String s) {
int index = -1;
//反过来，只有26个字符
for (char ch = 'a'; ch <= 'z'; ch++) {
int beginIndex = s.indexOf(ch);
// 从头开始的位置是否等于结束位置，相等说明只有一个，
if (beginIndex != -1 && beginIndex == s.lastIndexOf(ch)) {
//取小的，越小代表越前。
// index = (index == -1 || index > beginIndex) ? beginIndex : index;
if (index == -1 || index > beginIndex) {
index = beginIndex;
} else {
index = index;
}
}
}
return index;
}
}
class Solution {
public int firstUniqChar(String s) {
char[] chars = s.toCharArray();
int len = chars.length;
//定义数组长度为26，表示26个字母 0-25 分别表示a-z的位置
int[] arr = new int[26];
int count = 1;
//遍历字符数组，任何一个字母出现一次，都在arr数组对应位置加1
for(int i = 0;i<len;i++) {
arr[chars[i] - 'a'] += count;
}
for(int i = 0;i<len;i++) {
if(arr[chars[i] - 'a'] == 1) return i;
}
return -1;
}
}
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。
class Solution {
public void reverseString(char[] s) {
//定义一个临时变量，作为中间转换。
char temp = 0;
int len = s.length;
//第1个和最后1个进行交换，第2个和倒数第2个交换，以此类推，交换len/2次。
for (int i = 0; i < len / 2; i++) {
temp = s[i];
s[i] = s[len - i - 1];
s[len - i - 1] = temp;
}
}
}
编写一个函数，以字符串作为输入，反转该字符串中的元音字母。
示例 1:
输入: “hello”
输出: “holle”
双指针的应用
import java.util.*;
class Solution {
private final static HashSet<Character> set = new HashSet<>(Arrays.asList('a','o','e','i','u','A','O','E','I','U'));
public String reverseVowels(String s) {
int i = 0,j = s.length()-1;
char[] result = new char[s.length()];
while(i<=j){
char ci = s.charAt(i);
char cj =s.charAt(j);
if(!set.contains(ci)){
result[i++] = ci;
}else if(!set.contains(cj)){
result[j--] = cj;
}else{
result[i++] = cj;
result[j--] = ci;
}
}
return new String(result);
}
}
最优
class Solution {
public String reverseVowels(String s) {
if (s == null || s.trim().equals("")) return s;
char[] cs = s.toCharArray();
int low = 0,high = cs.length-1;
while (low < high) {
if (isVowelChar(cs[low])) {
if (isVowelChar(cs[high])) {
char temp = cs[low];
cs[low] = cs[high];
cs[high] = temp;
low++;
high--;
} else {
high--;
}
} else {
low++;
}
}
return String.valueOf(cs);
}
给定一个二维网格 board 和一个字典中的单词列表 words，找出所有同时在二维网格和字典中出现的单词。
单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母在一个单词中不允许被重复使用。
示例:
输入:
words = [“oath”,“pea”,“eat”,“rain”] and board =
[
[‘o’,‘a’,‘a’,‘n’],
[‘e’,‘t’,‘a’,‘e’],
[‘i’,‘h’,‘k’,‘r’],
[‘i’,‘f’,‘l’,‘v’]
]
输出: [“eat”,“oath”]
class Solution {
public List<String> findWords(char[][] board, String[] words) {
TrieNode tree = TrieNode.buildTree(words);
List<String> res = new LinkedList<>();
for(int i = 0; i < board.length; i++) {
for(int j = 0; j < board[0].length; j++) {
dfs(i,j,board,tree,res);
}
}
return res;
}
void dfs(int i, int j, char[][] board, TrieNode root, List<String> res) {
char c = board[i][j];
if(c=='#') return;
TrieNode node = root.children[c-'a'];
if(node==null) return;
if(node.word!=null) {
res.add(node.word);
node.word=null;
}
board[i][j]='#';
if(i+1<board.length) dfs(i+1,j,board,node,res);
if(i-1>=0) dfs(i-1,j,board,node,res);
if(j+1<board[0].length) dfs(i,j+1,board,node,res);
if(j-1>=0) dfs(i,j-1,board,node,res);
board[i][j]=c;
}
}
class TrieNode{
TrieNode[] children = new TrieNode[26];
String word;
static TrieNode buildTree(String[] words){
TrieNode root = new TrieNode();
for(String word : words){
char[] cs = word.toCharArray();
root.add(cs, 0);
}
return root;
}
void add(char[] cs, int i){
if(i==cs.length){
word = new String(cs);
return;
}
int index = cs[i]-'a';
if(children[index]==null){
children[index] = new TrieNode();
}
children[index].add(cs,i+1);
}
}
给定一个整数数组 nums ，找出一个序列中乘积最大的连续子序列（该序列至少包含一个数）。
示例 1:
输入: [2,3,-2,4]
输出: 6
解释: 子数组 [2,3] 有最大乘积 6。
class Solution {
public int maxProduct(int[] nums) {
int i = 0;
int max = Integer.MIN_VALUE;
int cur = 1;
while(i<nums.length){
cur *= nums[i];
max = cur > max ? cur : max;
if(cur == 0){
i++;
cur = 1;
continue;
}
i++;
}
cur = 1;
i = nums.length - 1;
while(i>=0){
cur *= nums[i];
max = cur > max ? cur : max;
if(cur == 0){
i--;
cur = 1;
continue;
}
i--;
}
return max;
}
}