前言
所有题目均来自力扣题库中的hot 100，之所以要记录在这里，只是方便后续复习
3.无重复字符的最长子串
题目：
给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: s = “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。
示例 2:
输入: s = “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。
示例 3:
输入: s = “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。
解题思路：
【双指针】类似于寻找某两个值或边界符合一定条件时可以考虑双指针；我们可以定义两个指针：左指针和右指针，起始都在头位置；右指针一直向右滑，直到遇到重复的字符（这就代表以0为起始位置无重复子串的最大长度），此时记录一下长度后，左指针开始右滑，每次都判断一下右指针是否还可以右滑，若可以右滑就继续滑直到不能右滑（这就代表以左指针为起始位置无重复子串的最大长度），然后并记录长度，重复如此，直到左指针都结尾位置。另外怎么判断是否存在重复字符呢，可以利用hashset存储左右指针之间的字符有哪些（因为hash找值为O1），左指针右滑即将该值从hashset中移除，右指针右滑即将该值添加到hashset中。那怎么记录整个过程中的最大长度呢，可以定义一个结果值，每次与当前长度比较取较大值即可
代码（python）：
class Solution(object):
def lengthOfLongestSubstring(self, s):
"""
:type s: str
:rtype: int
"""
# 定义一个set集合，用来鉴别滑动存储滑动左右指针之间的值
chars = set()
# 定义结果值
result = 0
# 定义右指针
right = 0
# 定义左指针 从0 开始到 length - 1
for left in range(0, len(s)):
# 如果左指针不是起始位置，左指针右滑，即对应set中的值删除（隐藏的点是，每循环一次left已经+1）
if left != 0:
chars.remove(s[left - 1])
# 如果右没到头 且 右指针的值不在set中 右指针一直右滑，即将右指针的值加到set中后，右指针 + 1
while right < len(s) and s[right] not in chars:
chars.add(s[right])
right += 1
# 当右指针 滑到不能再滑 计算间隔，即无重复字符串长度，并与比较结果值比较，较大者赋给结果值
result = max(result, right - left)
return result
代码（java）：
class Solution {
public int lengthOfLongestSubstring(String s) {
int right = 0;
int len = 0;
Set<Character> set = new HashSet<>();
for(int i = 0; i<s.length(); i++){
if(i != 0){
set.remove(s.charAt(i-1));
}
while(right < s.length() && ! set.contains(s.charAt(right))){
set.add(s.charAt(right));
right++;
}
len = Math.max(len, right - i );
}
return len;
}
}
知识点：
- java中Hash结构可以用HashSet，添加是add(val)，删除是remove(val)；python中可以用set()，添加是add(val)，删除是remove(val)
原题链接：无重复字符的最长子串
11.盛最多水的容器
题目：
给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。
找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
返回容器可以储存的最大水量。
说明：你不能倾斜容器。
示例 1：
输入：[1,8,6,2,5,4,8,3,7]
输出：49
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
示例 2：
输入：height = [1,1]
输出：1
解题思路：
【双指针】类似于寻找两个值和边界符合一定条件的可以考虑双指针，定义双指针一般有两种情况，一种是左右指针都是头位置，都向右滑，过程中判断是否符合一定条件，另一种是左右指针分别在头和尾位置，向中间滑，过程中判断是否符合一定条件；我们可以定义两个指针，左指针在头位置，右指针在尾位置，计算能接水数并记录，然后取两个指针较矮者滑动再计算接水数并于之前值比较保留较大值，以此类推直到两个指针相遇。那为什么要选较矮的指针滑动呢？笨思维：边界肯定越高水才能接更多，所以二者选一个更新，肯定选较矮的。
代码（python）：
class Solution:
def maxArea(self, height: List[int]) -> int:
result = 0
left = 0
right = len(height) - 1
while left < right:
result = max (min(height[left], height[right]) * (right -left) , result)
if height[left] < height[right]:
left = left + 1
else:
right = right - 1
return result
代码（java）：
class Solution {
public int maxArea(int[] height) {
//定义结果值
int result = 0;
//定义双指针，左指针头位置，右指针尾位置
int left = 0;
int right = height.length - 1;
int cur_result = 0;
//双指针滑动的中止条件是 左指针和右指针相遇
while(left < right){
//计算当前以左右指针为边界的情况下，接水的多少，并于结果值比较，将较大者赋给结果值
cur_result = (right - left) * Math.min(height[right], height[left]);
result = Math.max(result, cur_result);
// 左右两个边界取 较矮的边界滑动，左指针右滑，或者右指针左滑
if (height[left] > height[right]){
right --;
}else{
left ++;
}
}
return result;
}
}
知识点：
- 无
原题链接：盛最多水的容器
15.三数之和
题目：
给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。
示例 1：
输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
示例 2：
输入：nums = []
输出：[]
示例 3：
输入：nums = [0]
输出：[]
解题思路：
【排序+双指针】排序的目的是满足题意中的不重复；双指针是先选则元素a后，b和c分别为a右侧的区域窗口的左右边界，即a + 1 和 length - 1。如果a+b+c 大于0，则将c左滑；如果等于0则将三个索引添加到结果中；如果小于0，则将b右滑。需要注意的是滑动的过程中要满足b<c，和为了防止排序后的数组两个相同的数挨在一起，在确定元素a和b的时，要判断是否和左边的一个元素相等，若相等则跳过。
代码（python）：
class Solution:
def threeSum(self, nums: List[int]) -> List[List[int]]:
result = []
nums.sort()
for i in range(0, len(nums)):
if i == 0 or nums[i] != nums[i-1]:
k = len(nums) - 1
for j in range(i + 1, len(nums) - 1):
if j == i + 1 or nums[j] != nums [j-1]:
while j < k:
if nums[i] + nums[j] + nums[k] == 0:
result.append([nums[i], nums[j], nums[k]])
break
elif nums[i] + nums[j] + nums[k] > 0:
k = k - 1
else:
break
return result
代码（java）：
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
ArrayList<List<Integer>> result = new ArrayList<>();
// 排序
Arrays.sort(nums);
// 遍历数组，确定a
for(int a = 0; a < nums.length; a ++){
// 判断a是否和左边的元素相等，注意a是0的情况
if (a == 0 || nums[a] != nums[a - 1]){
// 定义c，即右指针
int c = nums.length - 1;
// 从a+1开始遍历，即定义b，
for(int b = a + 1; b < nums.length; b ++){
// 判断b是否和左边的元素相等，注意b是a+1的情况
if(b == a + 1 || nums[b] != nums[b - 1]){
// 开始滑动，要满足条件左边界小于右边界
while(b < c){
// 如果三个数相加等于0，添加到结果中
if(nums[a] + nums[b] + nums[c] == 0){
ArrayList<Integer> item = new ArrayList<>();
item.add(nums[a]);
item.add(nums[b]);
item.add(nums[c]);
result.add(item);
break;
// 如果大于0，则将c左滑
}else if(nums[a] + nums[b] + nums[c] > 0){
c--;
// 如果小于0，则将b右滑，由于这里b是遍历的情况，右滑的操作即是执行下一个循环
}else{
break;
}
}
}
}
}
}
return result;
}
}
知识点：
- python里提供的系统排序方法为list.sort()，java里则是Arrays.sort(nums)。二者都无需接收返回值，时间复杂度为NlogN。
原题链接：三数之和
75.颜色分类
题目：
给定一个包含红色、白色和蓝色、共 n 个元素的数组 nums ，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。
我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。
必须在不使用库的sort函数的情况下解决这个问题。
示例 1：
输入：nums = [2,0,2,1,1,0]
输出：[0,0,1,1,2,2]
示例 2：
输入：nums = [2,0,1]
输出：[0,1,2]
解题思路：
【双指针】红白蓝分为三个不同的区域，共有两个边界，我们可以考虑用双指针分隔这三个区域，左指针初始值为头位置，左侧是已经分好的0，右指针初始值是尾位置，右侧是已经分好的2；我们遍历数组，拿到0就和左指针交换，并且左指针向右滑动，拿到2就和右指针交换，并且右指针向左滑动，就这样直到索引和右指针相遇即停止，因为右指针右侧已经都是2；需要注意的是，当前值若是2时，有可能与右指针交换出来的值也是2，这样我们就需要一直交换并右指针左滑，直到交换出的不是2，此时该值可能是0，若是0则与左指针交换即可
代码（python）：
class Solution(object):
def sortColors(self, nums):
"""
:type nums: List[int]
:rtype: None Do not return anything, modify nums in-place instead.
"""
# 定义左指针为头位置，代表左指针左边都是分好类的 0
left = 0
# 定义右指针为尾位置，代表右指针右边都是分好类的 2
right = len(nums) - 1
i = 0
# 遍历列表，直到遍历到右指针位置（因为右指针右边已经分好类，就不用再遍历了）
while i <= right:
# 如果 当前值是 2，将该值和右指针的值交换，并滑动右指针，为了防止右指针的值也是2被交换出来，需要重复交换直到该值不在是2，但要注意的是 右指针不能小于当前位置
while i <= right and nums[i] == 2:
nums[i], nums[right] = nums[right], nums[i]
right -= 1
# 判断完当前值是否为2后，要在判断一下当前值是否为0（可能原来就是0也可能是被右指针交换过来的0），若为0要和左指针交换，并滑动左指针
if nums[i] == 0:
nums[i], nums[left] = nums[left], nums[i]
left += 1
i += 1
return nums
代码（java）：
class Solution {
public void sortColors(int[] nums) {
int left = 0;
int right = nums.length - 1;
int index = 0;
while(left < nums.length - 1 && nums[left] == 0){
left++;
}
while(right > 0 && nums[right] == 2){
right--;
}
while(index <= right){
if (index >= left){
if(nums[index] == 0){
swapValue(nums, index, left);
}
if(nums[index] == 2){
swapValue(nums, index, right);
if(nums[index] == 0){
swapValue(nums, index, left);
}
}
}
index ++;
while(left < nums.length - 1 && nums[left] == 0){
left++;
}
while(right > 0 && nums[right] == 2){
right--;
}
}
}
private void swapValue(int[] nums, int index1, int index2){
int value = nums[index1];
nums[index1] = nums[index2];
nums[index2] = value;
}
}
知识点：
- 无
原题链接：颜色分类
285.移动零
题目：
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
请注意 ，必须在不复制数组的情况下原地对数组进行操作。
示例 1:
输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]
示例 2:
输入: nums = [0]
输出: [0]
解题思路：
【双指针】首先肯定要一个指针要遍历数组，找到非零数将其前移，那如何前移呢？就是找到第一个为0得位置进行交换，那如何维护这个位置呢？我们可以考虑再定义一个边界指针，该指针代表着其左侧都是已经排好得非零数；两个指针初始位置都是0，如果索引指针遇到了非零数就和边界指针得值交换，此时两个指针都要移动（左指针移动的原因是当前位置是已经排好的非零数了，边界自然要移动），如果索引指针遇到了0就自己移动，直到索引指针遍历完成
代码（python）：
class Solution(object):
def moveZeroes(self, nums):
"""
:type nums: List[int]
:rtype: None Do not return anything, modify nums in-place instead.
"""
#定义左指针 左指针左侧都是非零数
left = 0
#定义右指针 右指针遍历整个数组
right = 0
n = len(nums)
# 如果右指针没超过范围
while right < n:
#如果右指针遇到了非零数 就和左指针交换，并左指针加1
if nums[right] != 0:
nums[left], nums[right] = nums[right], nums[left]
left += 1
#无论是否交换指针 右指针都得右滑
right += 1
代码（java）：
class Solution {
public void moveZeroes(int[] nums) {
if(nums.length == 0 || nums.length == 1){
return;
}
int zeroIndex = getZeroIndex(nums);
if (zeroIndex == nums.length){
return;
}
for (int i = 0; i < nums.length; i++){
if(nums[i] != 0 && zeroIndex < i){
int k = nums[i];
nums[i] = nums[zeroIndex];
nums[zeroIndex] = k;
zeroIndex = getZeroIndex(nums);
}
}
}
public int getZeroIndex(int[] nums){
int zeroIndex = 0;
while (zeroIndex < nums.length && nums[zeroIndex] != 0){
zeroIndex ++ ;
}
return zeroIndex;
}
}
知识点：
- 无
原题链接：移动零
361
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
