算法与数据结构 c++选手转java

前言：

由于就业还得看java，很多面试也是要求用java写代码（算法题or一段程序如多线程实现），本c++选手不得不离开舒适区，尝试使用java在力扣刷题。以下内容将分为两个部分，持续更新：

第一部分记录在c++中的常用代码如何在java中实现，如二维数组声明、队列和栈的使用（java乱七八糟的容器太多了）等等；

第二部分将是用java代码写的刷题记录和必要的笔记；

c++转java注意事项：

1.输入输出

<code>Scanner in = new Scanner(System.in);

int a = in.nextInt();//整数类型的输入方式

double b = in.nextDouble();//小数类型的输入方式

in.nextLine();//nextLine()用以吃掉回车符

String s1 = in.nextLine();//nextLine可以输入带空格的数据

System.out.println("输出");

2.常用数据结构

int[] arr = new int[5];

Scanner in = new Scanner(System.in);

arr[0] = in.nextInt();//输入

System.out.println(arr[0]);//输出

Arrays.sort(arr);//排序，类似于c++ sort(arr,arr+n),默认升序

Arrays.sort(arr, 0, 3);//只排序 下标0到2

//想要逆序，可以借助 ArrayList 如下

//List

List<Integer> list = new ArrayList<>();

int nums = in.nextInt();

list.add(nums); // 输入

System.out.print(list.get(i));//输出，i是下标

int size = list.size() //list大小

list.sort(new Comparator<Integer>() { //降序排序，升序可以直接list.sort()

@Override

public int compare(Integer o1, Integer o2) { //如果存的是自定义的类，Integer换成自己的类就行

return o2.compareTo(o1);//这里还可以用 o2 - o1

}

});

//Map

Map<String,Integer> map = new HashMap<>();

String name = in.next();

int grade = in.nextInt();

map.put(name,grade);//插入

for (String s : map.keySet()) { // 遍历

System.out.println(s + ":" + map.get(s));

}

map.containsKey("key");//key是否存在

map.remove("key")//删除

map.getOrDefault("key",0);//存在返回值，不存在返回默认值0

//Set

HashSet<Integer> set = new HashSet<>();

int nums = in.nextInt();

set.add(nums);//插入和map、list一样也是add

for (int nums:set) { //遍历

System.out.println(nums);

}

set.contains(1);//存在

set.remove(1);//删除

set.clear();//清空

//queue和stack

//栈和队列比较特殊，似乎ArrayDeque（双端队列）能胜任这两种数据结构且效率更高

//先说栈

ArrayDeque<Integer> stack = new ArrayDeque<>();

deque.push(1);//push推进栈

int top = deque.peek(); // peek栈顶

deque.pop();//pop弹出栈顶

//再说队列，声明和上面一样，用的函数不一样

//这是一个双端队列

ArrayDeque<Integer> deque = new ArrayDeque<>();

deque.add(1);//add加入队尾

int head = deque.peek();//peek队首，栈里是栈顶

deque.poll(); // poll队首出队

deque.getLast();//访问队尾元素

deque.removeLast();//移除队尾元素

3.其他

//二维数组

int[][] array = new int[2][4]; // 直接给每一维分配内存空间,和c++差不多

Arrays.sort(array, new Comparator<int[]>() {

public int compare(int[] array1, int[] array2) {

return array1[0] - array2[0];

}

});

//下面这种做法类似于c++: vector<int> vec[n];

List<List<Integer>> edges= new ArrayList<List<Integer>>();

for(int i = 0;i < n;i++){

edges.add(new ArrayList<Integer>());

}

edges.get(i).add(k);//在第i行加入k

刷题记录

1.算法与数据结构

88. 合并两个有序数组

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

**注意：**最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

class Solution {

public void merge(int[] nums1, int m, int[] nums2, int n) {

for(int i = 0;i < n;i++){

//找到nums[i]应该插入在哪里

int j = 0;

for(;j < m+i;j++)

if(nums2[i] < nums1[j]) break;

//要把nums2[i] 插入j的位置，j后的每个元素都要后移

for(int k = n+m-1;k > j;k--) nums1[k] = nums1[k-1];

nums1[j] = nums2[i];

}

}

}

27. 移除元素

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。

假设 nums 中不等于 val 的元素数量为 k，要通过此题，您需要执行以下操作：

更改 nums 数组，使 nums 的前 k 个元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。返回 k。

class Solution {

public int removeElement(int[] nums, int val) {

int n = nums.length;

int left = 0;

for (int right = 0; right < n; right++) {

if (nums[right] != val) {

nums[left] = nums[right];

left++;

}

}

return left;

}

}

26. 删除有序数组中的重复项

给你一个 非严格递增排列 的数组 nums ，请你** 原地** 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。

考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：

更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。返回 k 。

class Solution {

public int removeDuplicates(int[] nums) {

int n = nums.length;

int left = 1;

for(int i = 1;i < n;i++){

if(nums[i] != nums[i-1]){

nums[left++] = nums[i];

}

}

return left;

}

}

80. 删除有序数组中的重复项 II

给你一个有序数组 nums ，请你** 原地** 删除重复出现的元素，使得出现次数超过两次的元素只出现两次 ，返回删除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

class Solution {

public int removeDuplicates(int[] nums) {

int n = nums.length;

int left = 0;

for(int i = 0;i < n;i++){

if(i+2 >= n || !(nums[i] == nums[i+1] && nums[i+1] == nums[i+2])){

nums[left++] = nums[i];

}

}

return left;

}

}

169. 多数元素

给定一个大小为 n 的数组 nums ，返回其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

class Solution {

public int majorityElement(int[] nums) {

Arrays.sort(nums);

return nums[nums.length/2];

}

}

189. 轮转数组

给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

class Solution {

public void rotate(int[] nums, int k) {

int[] cp = nums.clone();

int len = nums.length;

k = k%len;//小坑

for(int i = 0;i < len;i++){

nums[i] = cp[(i+ len-k)%len];

}

}

}

121. 买卖股票的最佳时机

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

class Solution {

public int maxProfit(int[] prices) {

int mi = 99999999,ans = 0;

for(int c : prices){

mi = Math.min(mi,c);

ans = Math.max(c - mi,ans);

}

return ans;

}

}

122. 买卖股票的最佳时机 II

给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。

在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。

返回 你能获得的 最大 利润 。

class Solution {

public int maxProfit(int[] prices) {

int ans = 0,mi = prices[0];

int l = prices.length;

for(int i = 1;i < l;i++){

if(prices[i] < prices[i-1]){

ans += prices[i-1] - mi;

mi = prices[i];

}

}

if(prices[l-1] > mi) ans += prices[l-1]-mi;

return ans;

}

}

55. 跳跃游戏

给你一个非负整数数组 nums ，你最初位于数组的 第一个下标 。数组中的每个元素代表你在该位置可以跳跃的最大长度。

判断你是否能够到达最后一个下标，如果可以，返回 true ；否则，返回 false 。

class Solution {

public boolean canJump(int[] nums) {

if(nums.length == 1) return true;

int k = 0;

for(int i = 0;i < nums.length;i++){

if(i > k ) return false;

k = Math.max(i + nums[i],k);

}

return true;

}

}

45. 跳跃游戏 II

给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。

每个元素 nums[i] 表示从索引 i 向前跳转的最大长度。换句话说，如果你在 nums[i] 处，你可以跳转到任意 nums[i + j] 处:

0 <= j <= nums[i]i + j < n

返回到达 nums[n - 1] 的最小跳跃次数。生成的测试用例可以到达 nums[n - 1]。

class Solution {

public int jump(int[] nums) {

int length = nums.length;

int end = 0;

int maxPosition = 0;

int steps = 0;

for (int i = 0; i < length - 1; i++) {

maxPosition = Math.max(maxPosition, i + nums[i]);

if (i == end) {

end = maxPosition;

steps++;

}

}

return steps;

}

}

274. H 指数

给你一个整数数组 citations ，其中 citations[i] 表示研究者的第 i 篇论文被引用的次数。计算并返回该研究者的 h 指数。

根据维基百科上 h 指数的定义：h 代表“高引用次数” ，一名科研人员的 h 指数 是指他（她）至少发表了 h 篇论文，并且 至少 有 h 篇论文被引用次数大于等于 h 。如果 h 有多种可能的值，h 指数 是其中最大的那个。

class Solution {

public int hIndex(int[] citations) {

int ans = 0;

int l = citations.length;

ArrayList<Integer> list = new ArrayList<>();

for(int c : citations) list.add(c);

list.sort(new Comparator<Integer>(){

@Override

public int compare(Integer a,Integer b){

return Integer.compare(b,a);

}

});

for(int h = 1;h <= l;h++){

if(list.get(h-1) >= h) ans = Math.max(ans,h);

}

return ans;

}

}

380. O(1) 时间插入、删除和获取随机元素

实现RandomizedSet 类：

RandomizedSet() 初始化 RandomizedSet 对象bool insert(int val) 当元素 val 不存在时，向集合中插入该项，并返回 true ；否则，返回 false 。bool remove(int val) 当元素 val 存在时，从集合中移除该项，并返回 true ；否则，返回 false 。int getRandom() 随机返回现有集合中的一项（测试用例保证调用此方法时集合中至少存在一个元素）。每个元素应该有 相同的概率 被返回。

你必须实现类的所有函数，并满足每个函数的 平均 时间复杂度为 O(1) 。

class RandomizedSet {

List<Integer> nums;

Map<Integer, Integer> indices;

Random random;

public RandomizedSet() {

nums = new ArrayList<Integer>();

indices = new HashMap<Integer, Integer>();

random = new Random();

}

public boolean insert(int val) {

if (indices.containsKey(val)) {

return false;

}

int index = nums.size();

nums.add(val);

indices.put(val, index);

return true;

}

public boolean remove(int val) {

if (!indices.containsKey(val)) {

return false;

}

int index = indices.get(val);

int last = nums.get(nums.size() - 1);

nums.set(index, last);

indices.put(last, index);

nums.remove(nums.size() - 1);

indices.remove(val);

return true;

}

public int getRandom() {

int randomIndex = random.nextInt(nums.size());

return nums.get(randomIndex);

}

}

238. 除自身以外数组的乘积

给你一个整数数组 nums，返回 数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积 。

题目数据 保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位 整数范围内。

请 **不要使用除法，**且在 O(*n*) 时间复杂度内完成此题。

class Solution {

public int[] productExceptSelf(int[] nums) {

int length = nums.length;

// L 和 R 分别表示左右两侧的乘积列表

int[] L = new int[length];

int[] R = new int[length];

int[] answer = new int[length];

// L[i] 为索引 i 左侧所有元素的乘积

// 对于索引为 '0' 的元素，因为左侧没有元素，所以 L[0] = 1

L[0] = 1;

for (int i = 1; i < length; i++) {

L[i] = nums[i - 1] * L[i - 1];

}

// R[i] 为索引 i 右侧所有元素的乘积

// 对于索引为 'length-1' 的元素，因为右侧没有元素，所以 R[length-1] = 1

R[length - 1] = 1;

for (int i = length - 2; i >= 0; i--) {

R[i] = nums[i + 1] * R[i + 1];

}

// 对于索引 i，除 nums[i] 之外其余各元素的乘积就是左侧所有元素的乘积乘以右侧所有元素的乘积

for (int i = 0; i < length; i++) {

answer[i] = L[i] * R[i];

}

return answer;

}

}

135. 分发糖果

n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。

你需要按照以下要求，给这些孩子分发糖果：

每个孩子至少分配到 1 个糖果。相邻两个孩子评分更高的孩子会获得更多的糖果。

请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。

class Solution {

public int candy(int[] ratings) {

int n = ratings.length;

int[] ans =new int[n];

for(int i = 0;i < n;i++) ans[i] = 1;

for(int i = 1;i < n;i++ ){

if(ratings[i] > ratings[i-1]) ans[i] = ans[i-1] + 1;

}

for(int i = n-2;i >= 0;i--){

if(ratings[i] > ratings[i+1]) ans[i] = Math.max(ans[i],ans[i+1]+1);

}

int res = 0;

for(int c : ans) res += c;

return res;

}

}

42. 接雨水

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

class Solution {

public int trap(int[] height) {

int ans = 0;

Deque<Integer> stack = new LinkedList<Integer>();

int n = height.length;

for (int i = 0; i < n; ++i) {

while (!stack.isEmpty() && height[i] > height[stack.peek()]) {

int top = stack.pop();

if (stack.isEmpty()) {

break;

}

int left = stack.peek();

int currWidth = i - left - 1;

int currHeight = Math.min(height[left], height[i]) - height[top];

ans += currWidth * currHeight;

}

stack.push(i);

}

return ans;

}

}

13. 罗马数字转整数

罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。

字符 数值

I 1

V 5

X 10

L 50

C 100

D 500

M 1000

例如， 罗马数字 2 写做 II ，即为两个并列的 1 。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。

给定一个罗马数字，将其转换成整数。

class Solution {

Map<Character, Integer> symbolValues = new HashMap<Character, Integer>() { {

put('I', 1);

put('V', 5);

put('X', 10);

put('L', 50);

put('C', 100);

put('D', 500);

put('M', 1000);

}};

public int romanToInt(String s) {

int ans = 0;

int n = s.length();

for (int i = 0; i < n; ++i) {

int value = symbolValues.get(s.charAt(i));

if (i < n - 1 && value < symbolValues.get(s.charAt(i + 1))) {

ans -= value;

} else {

ans += value;

}

}

return ans;

}

}

58. 最后一个单词的长度

给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 最后一个 单词的长度。

单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。

class Solution {

public int lengthOfLastWord(String s) {

int index = s.length() - 1;

while (s.charAt(index) == ' ') {

index--;

}

int wordLength = 0;

while (index >= 0 && s.charAt(index) != ' ') {

wordLength++;

index--;

}

return wordLength;

}

}

14. 最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 ""。

class Solution {

public String longestCommonPrefix(String[] strs) {

if (strs == null || strs.length == 0) {

return "";

}

int length = strs[0].length();

int count = strs.length;

for (int i = 0; i < length; i++) {

char c = strs[0].charAt(i);

for (int j = 1; j < count; j++) {

if (i == strs[j].length() || strs[j].charAt(i) != c) {

return strs[0].substring(0, i);

}

}

}

return strs[0];

}

}

151. 反转字符串中的单词

给你一个字符串 s ，请你反转字符串中 单词 的顺序。

单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。

返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。

**注意：**输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。

class Solution {

public String reverseWords(String s) {

// 除去开头和末尾的空白字符

s = s.trim();

// 正则匹配连续的空白字符作为分隔符分割

List<String> wordList = Arrays.asList(s.split("\\s+"));

Collections.reverse(wordList);

return String.join(" ", wordList);

}

}

6. Z 字形变换

将一个给定字符串 s 根据给定的行数 numRows ，以从上往下、从左到右进行 Z 字形排列。

比如输入字符串为 "PAYPALISHIRING" 行数为 3 时，排列如下：

P A H N

A P L S I I G

Y I R

之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如："PAHNAPLSIIGYIR"。

class Solution {

public String convert(String s, int numRows) {

int n = s.length();

int[] idx = new int[n];

idx[0]=1;int d = -1;

if(numRows == 1) d = 0;

for(int i = 1;i < n;i++){

if(idx[i-1] == numRows || idx[i-1] == 1) d = -d;

idx[i] = idx[i-1] + d;

}

String ans = "";

for(int i = 1;i <= numRows;i++){

for(int j = 0;j < n;j++){

if(idx[j] == i){

ans += s.charAt(j);

}

}

}

return ans;

}

}

28. 找出字符串中第一个匹配项的下标

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。

class Solution {

public int strStr(String haystack, String needle) {

int k = needle.length();

for(int i = 0;i+k <= haystack.length();i++){

String s = haystack.substring(i,i+k);

if(s.equals(needle)) return i;

}

return -1;

}

}

125. 验证回文串

如果在将所有大写字符转换为小写字符、并移除所有非字母数字字符之后，短语正着读和反着读都一样。则可以认为该短语是一个 回文串 。

字母和数字都属于字母数字字符。

给你一个字符串 s，如果它是 回文串 ，返回 true ；否则，返回 false 。

class Solution {

public boolean isPalindrome(String s) {

s = s.toLowerCase();

int i = 0,j = s.length()-1;

while(i < j){

while(i < j && (s.charAt(i)>'z' || s.charAt(i)<'a') && !(s.charAt(i)>='0' && s.charAt(i)<='9')) i++;

while(i < j && (s.charAt(j)>'z' || s.charAt(j)<'a' && !(s.charAt(j)>='0' && s.charAt(j)<='9'))) j--;

if(s.charAt(i) != s.charAt(j)) return false;

i++;j--;

}

return true;

}

}

392. 判断子序列

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

进阶：

如果有大量输入的 S，称作 S1, S2, … , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？

class Solution {

public boolean isSubsequence(String s, String t) {

int n = s.length(), m = t.length();

int i = 0, j = 0;

while (i < n && j < m) {

if (s.charAt(i) == t.charAt(j)) {

i++;

}

j++;

}

return i == n;

}

}

167. 两数之和 II - 输入有序数组

给你一个下标从 1 开始的整数数组 numbers ，该数组已按 非递减顺序排列 ，请你从数组中找出满足相加之和等于目标数 target 的两个数。如果设这两个数分别是 numbers[index1] 和 numbers[index2] ，则 1 <= index1 < index2 <= numbers.length 。

以长度为 2 的整数数组 [index1, index2] 的形式返回这两个整数的下标 index1 和 index2。

你可以假设每个输入 只对应唯一的答案 ，而且你 不可以 重复使用相同的元素。

你所设计的解决方案必须只使用常量级的额外空间。

class Solution {

public int[] twoSum(int[] numbers, int target) {

int i = 0,j = numbers.length-1;

while(i < j){

int c = numbers[i] + numbers[j];

if(c == target) return new int[] { i+1,j+1};

else if(c < target) i++;

else j--;

}

return new int[] { };

}

}

11. 盛最多水的容器

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

public class Solution {

public int maxArea(int[] height) {

int l = 0, r = height.length - 1;

int ans = 0;

while (l < r) {

int area = Math.min(height[l], height[r]) * (r - l);

ans = Math.max(ans, area);

if (height[l] <= height[r]) {

++l;

}

else {

--r;

}

}

return ans;

}

}

15. 三数之和

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。

**注意：**答案中不可以包含重复的三元组。

class Solution {

public List<List<Integer>> threeSum(int[] nums) {

int n = nums.length;

Arrays.sort(nums);

List<List<Integer>> ans = new ArrayList<List<Integer>>();

// 枚举 a

for (int first = 0; first < n; ++first) {

// 需要和上一次枚举的数不相同

if (first > 0 && nums[first] == nums[first - 1]) {

continue;

}

// c 对应的指针初始指向数组的最右端

int third = n - 1;

int target = -nums[first];

// 枚举 b

for (int second = first + 1; second < n; ++second) {

// 需要和上一次枚举的数不相同

if (second > first + 1 && nums[second] == nums[second - 1]) {

continue;

}

// 需要保证 b 的指针在 c 的指针的左侧

while (second < third && nums[second] + nums[third] > target) {

--third;

}

// 如果指针重合，随着 b 后续的增加

// 就不会有满足 a+b+c=0 并且 b<c 的 c 了，可以退出循环

if (second == third) {

break;

}

if (nums[second] + nums[third] == target) {

List<Integer> list = new ArrayList<Integer>();

list.add(nums[first]);

list.add(nums[second]);

list.add(nums[third]);

ans.add(list);

}

}

}

return ans;

}

}

209. 长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其总和大于等于 target 的长度最小的 连续

子数组

[numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度**。**如果不存在符合条件的子数组，返回 0 。

class Solution {

public int minSubArrayLen(int s, int[] nums) {

int n = nums.length;

if (n == 0) {

return 0;

}

int ans = Integer.MAX_VALUE;

int start = 0, end = 0;

int sum = 0;

while (end < n) {

sum += nums[end];

while (sum >= s) {

ans = Math.min(ans, end - start + 1);

sum -= nums[start];

start++;

}

end++;

}

return ans == Integer.MAX_VALUE ? 0 : ans;

}

}

3. 无重复字符的最长子串

给定一个字符串 s ，请你找出其中不含有重复字符的 最长 子串 的长度。

class Solution {

public int lengthOfLongestSubstring(String s) {

// 哈希集合，记录每个字符是否出现过

Set<Character> occ = new HashSet<Character>();

int n = s.length();

// 右指针，初始值为 -1，相当于我们在字符串的左边界的左侧，还没有开始移动

int rk = -1, ans = 0;

for (int i = 0; i < n; ++i) {

if (i != 0) {

// 左指针向右移动一格，移除一个字符

occ.remove(s.charAt(i - 1));

}

while (rk + 1 < n && !occ.contains(s.charAt(rk + 1))) {

// 不断地移动右指针

occ.add(s.charAt(rk + 1));

++rk;

}

// 第 i 到 rk 个字符是一个极长的无重复字符子串

ans = Math.max(ans, rk - i + 1);

}

return ans;

}

}

383. 赎金信

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

如果可以，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次。

class Solution {

public boolean canConstruct(String ransomNote, String magazine) {

HashMap<Character,Integer> hmap = new HashMap<>();

for(int t = 0;t < magazine.length();t++){

char c = magazine.charAt(t);

int i = hmap.getOrDefault(c,0);

hmap.put(c,i+1);

}

for(int t = 0;t < ransomNote.length();t++){

char c = ransomNote.charAt(t);

int i = hmap.getOrDefault(c,0);

i--;

if(i < 0) return false;

hmap.put(c,i);

}

return true;

}

}

205. 同构字符串

给定两个字符串 s 和 t ，判断它们是否是同构的。

如果 s 中的字符可以按某种映射关系替换得到 t ，那么这两个字符串是同构的。

每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，相同字符只能映射到同一个字符上，字符可以映射到自己本身。

class Solution {

public boolean isIsomorphic(String s, String t) {

Map<Character, Character> s2t = new HashMap<Character, Character>();

Map<Character, Character> t2s = new HashMap<Character, Character>();

int len = s.length();

for (int i = 0; i < len; ++i) {

char x = s.charAt(i), y = t.charAt(i);

if ((s2t.containsKey(x) && s2t.get(x) != y) || (t2s.containsKey(y) && t2s.get(y) != x)) {

return false;

}

s2t.put(x, y);

t2s.put(y, x);

}

return true;

}

}

228. 汇总区间

给定一个 无重复元素 的 有序 整数数组 nums 。

返回 恰好覆盖数组中所有数字 的 最小有序 区间范围列表 。也就是说，nums 的每个元素都恰好被某个区间范围所覆盖，并且不存在属于某个范围但不属于 nums 的数字 x 。

列表中的每个区间范围 [a,b] 应该按如下格式输出：

"a->b" ，如果 a != b"a" ，如果 a == b

class Solution {

public List<String> summaryRanges(int[] nums) {

List<String> ret = new ArrayList<String>();

int i = 0;

int n = nums.length;

while (i < n) {

int low = i;

i++;

while (i < n && nums[i] == nums[i - 1] + 1) {

i++;

}

int high = i - 1;

StringBuffer temp = new StringBuffer(Integer.toString(nums[low]));

if (low < high) {

temp.append("->");

temp.append(Integer.toString(nums[high]));

}

ret.add(temp.toString());

}

return ret;

}

}

56. 合并区间

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。

class Solution {

public int[][] merge(int[][] intervals) {

if (intervals.length == 0) {

return new int[0][2];

}

Arrays.sort(intervals, new Comparator<int[]>() {

public int compare(int[] interval1, int[] interval2) {

return interval1[0] - interval2[0];

}

});

List<int[]> merged = new ArrayList<int[]>();

for (int i = 0; i < intervals.length; ++i) {

int L = intervals[i][0], R = intervals[i][1];

if (merged.size() == 0 || merged.get(merged.size() - 1)[1] < L) {

merged.add(new int[]{ L, R});

} else {

merged.get(merged.size() - 1)[1] = Math.max(merged.get(merged.size() - 1)[1], R);

}

}

return merged.toArray(new int[merged.size()][]);

}

}

2.SQL

3.多线程