持续更新中..................
704. 二分查找
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
示例1：输入: nums = [-1,0,3,5,9,12], target = 9 输出: 4
示例2：输入: nums = [-1,0,3,5,9,12], target = 2 输出: -1
class Solution {
public int search(int[] nums, int target) {
int left = 0;
int right = nums.length - 1;
while(left <= right){
int mid = (left + right) / 2;
if(target == nums[mid]){
return mid;
}else if(target > nums[mid]){
left = mid + 1;
}else if(target < nums[mid]){
right = mid - 1;
}
}
return -1;
}
}35. 搜索插入位置
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。请必须使用时间复杂度为 O(log n) 的算法。
示例1：输入: nums = [1,3,5,6], target = 5 输出：2
示例2：输入: nums = [1,3,5,6], target = 2 输出：1
示例3：输入: nums = [1,3,5,6], target = 7 输出：4
class Solution {
public int searchInsert(int[] nums, int target) {
int left = 0;
int right = nums.length - 1;
int index = 0;
while(left <= right){
int mid = (left + right) / 2;
if(target == nums[mid]){
return mid;
}else if(target > nums[mid]){
left = mid + 1;
index = mid + 1;
}else if(target < nums[mid]){
right = mid - 1;
index = mid;
}
}
return index;
}
}34. 在排序数组中查找元素的第一个和最后一个位置
给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。
示例1：输入：nums = [5,7,7,8,8,10], target = 8 输出：[3,4]
示例2：输入：nums = [5,7,7,8,8,10], target = 6 输出：[-1,-1]
示例3：输入：nums = [], target = 0 输出：[-1,-1]
class Solution {
public int[] searchRange(int[] nums, int target) {
int index = Arrays.binarySearch(nums, target);
if(index >= 0){
int left = index - 1;
int right = index + 1;
while(left >= 0 && nums[left] == target){
left--;
}
while(right <= nums.length-1 && nums[right] == target){
right++;
}
return new int[]{left+1, right-1};
}
return new int[]{-1, -1};
}
}69. x的平方根
给你一个非负整数 x ，计算并返回 x 的 算术平方根 。由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。
示例 1：输入：x = 8 输出：2
class Solution {
public int mySqrt(int x) {
int left = 1;
int right = x;
int sqrt = 0;
while(left <= right){
int mid = (left + right) / 2;
int temp = x / mid;
if(temp == mid){
return mid;
}else if(temp > mid){
left = mid + 1;
sqrt = mid;
}else if(temp < mid){
right = mid - 1;
}
}
return sqrt;
}
}367. 有效的完全平方数
给定一个 正整数 num ，编写一个函数，如果 num 是一个完全平方数，则返回 true ，否则返回 false 。不要使用任何内置的库函数，如 sqrt 。
示例1：输入：num = 16 输出：true
示例2：输入：num = 14 输出：false
class Solution {
public boolean isPerfectSquare(int num) {
int left = 1;
int right = num;
while(left <= right){
int mid = (left + right) / 2;
int temp = num / mid;
if(temp == mid){
if(num % mid == 0){
return true;
}
return false;
}else if(temp > mid){
left = mid + 1;
}else if(temp < mid){
right = mid - 1;
}
}
return false;
}
}27. 移除元素
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地修改输入数组。元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
示例 1：输入：nums = [3,2,2,3], val = 3 输出：2, nums = [2,2]
示例 2：输入：nums = [0,1,2,2,3,0,4,2], val = 2 输出：5, nums = [0,1,4,0,3]
class Solution {
public int removeElement(int[] nums, int val) {
int slowIndex = 0;
for(int fastIndex = 0; fastIndex < nums.length; fastIndex++){
if(nums[fastIndex] != val){
nums[slowIndex] = nums[fastIndex];
slowIndex++;
}
}
return slowIndex;
}
}26. 删除有序数组中的重复项
给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。将最终结果插入 nums 的前 k 个位置后返回 k 。不要使用额外的空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
示例 1：输入：nums = [1,1,2] 输出：2, nums = [1,2,_]
示例 2：输入：nums = [0,0,1,1,1,2,2,3,3,4] 输出：5, nums = [0,1,2,3,4]
class Solution {
public int removeDuplicates(int[] nums) {
int slowIndex = 0;
for(int fastIndex = 1; fastIndex < nums.length; fastIndex++){
if(nums[fastIndex] != nums[slowIndex]){
slowIndex++;
nums[slowIndex] = nums[fastIndex];
}
}
return slowIndex + 1;
}
}283. 移动零
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。请注意，必须在不复制数组的情况下原地对数组进行操作。
示例1：输入: nums = [0,1,0,3,12] 输出: [1,3,12,0,0]
示例2：输入: nums = [0] 输出: [0]
class Solution {
public void moveZeroes(int[] nums) {
int slowIndex = 0;
for(int fastIndex = 0; fastIndex < nums.length; fastIndex++){
if(nums[fastIndex] != 0){
nums[slowIndex] = nums[fastIndex];
slowIndex++;
}
}
for(; slowIndex < nums.length; slowIndex++){
nums[slowIndex] = 0;
}
}
}844. 比较含退格的字符串
给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回 true 。# 代表退格字符。注意：如果对空文本输入退格字符，文本继续为空。
示例1：输入：s = "ab#c", t = "ad#c" 输出：true （解释：s 和 t 都会变成 "ac"）
示例2：输入：s = "ab##", t = "c#d#" 输出：true （解释：s 和 t 都会变成 ""）
示例3：输入：s = "a#c", t = "b" 输出：false （解释：s 会变成 "c"，但 t 仍然是 "b"）
class Solution {
public boolean backspaceCompare(String s, String t) {
if(backspaceString(s).equals(backspaceString(t))){
return true;
}
return false;
}
public String backspaceString(String str){
char[] strChar = str.toCharArray();
int slowIndex = 0;
for(int fastIndex = 0; fastIndex < str.length(); fastIndex++){
if(strChar[fastIndex] != '#'){
strChar[slowIndex] = strChar[fastIndex];
slowIndex++;
}else{
if(slowIndex > 0){
slowIndex--;
}
}
}
return new String(strChar).substring(0, slowIndex);
}
}88. 合并两个有序数组
给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。
示例1：输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3 输出：[1,2,2,3,5,6]
class Solution {
public void merge(int[] nums1, int m, int[] nums2, int n) {
int index = nums1.length - 1;
m--;
n--;
while(n >= 0){
if(m >= 0 && nums1[m] > nums2[n]){
nums1[index] = nums1[m];
m--;
}else{
nums1[index] = nums2[n];
n--;
}
index--;
}
}
}977. 有序数组的平方
给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。
示例1：输入：nums = [-4,-1,0,3,10] 输出：[0,1,9,16,100]
示例2：输入：nums = [-7,-3,2,3,11] 输出：[4,9,9,49,121]
class Solution {
public int[] sortedSquares(int[] nums) {
int left = 0;
int right = nums.length-1;
int[] result = new int[nums.length];
for(int i = nums.length - 1; i >= 0; i--){
if(nums[right] * nums[right] >= nums[left] * nums[left]){
result[i] = nums[right] * nums[right];
right--;
}else{
result[i] = nums[left] * nums[left];
left++;
}
}
return result;
}
}209. 长度最小的子数组
给定一个含有 n 个正整数的数组和一个正整数 target 。找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。
示例1：输入：target = 7, nums = [2,3,1,2,4,3] 输出：2
示例2：输入：target = 4, nums = [1,4,4] 输出：1
示例3：输入：target = 11, nums = [1,1,1,1,1,1,1,1] 输出：0
class Solution {
public int minSubArrayLen(int target, int[] nums) {
int slowIndex = 0;
int sum = 0;
int length = Integer.MAX_VALUE;
for(int fastIndex = 0; fastIndex < nums.length; fastIndex++){
sum += nums[fastIndex];
while(sum >= target){
length = Math.min(length, fastIndex - slowIndex + 1);
sum -= nums[slowIndex];
slowIndex++;
}
}
return length == Integer.MAX_VALUE ? 0 : length;
}
}904. 水果成篮
你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示，其中 fruits[i] 是第 i 棵树上的水果 种类 。你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：你只有 两个 篮子，并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。你可以选择任意一棵树开始采摘，你必须从 每棵 树（包括开始采摘的树）上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。给你一个整数数组 fruits ，返回你可以收集的水果的 最大 数目。
示例1：输入：fruits = [1,2,1] 输出：3
示例2： 输入：fruits = [0,1,2,2] 输出：3
示例3：输入：fruits = [3,3,3,1,2,1,1,2,3,3,4] 输出：5
class Solution {
public int totalFruit(int[] fruits) {
int slowIndex = 0;
int sum = 0;
boolean type = true;
int next = 0;
int secondFruit = fruits[slowIndex];
for(int fastIndex = 0; fastIndex < fruits.length; fastIndex++){
if(fruits[fastIndex] != fruits[slowIndex] && type == true){
secondFruit = fruits[fastIndex];
next = fastIndex;
type = false;
}
if(fruits[fastIndex] != fruits[slowIndex] && fruits[fastIndex] != secondFruit){
sum = Math.max(sum, fastIndex - slowIndex);
slowIndex = next;
fastIndex = slowIndex-1;
type = true;
}
if(fastIndex == fruits.length-1){
sum = Math.max(sum, fastIndex - slowIndex + 1);
}
}
return sum;
}
}76. 最小覆盖子串
给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。
示例1：输入：s = "ADOBECODEBANC", t = "ABC" 输出："BANC"
class Solution {
public String minWindow(String s, String t) {
int[] array = new int[128];
for(int i = 0; i < t.length(); i++){
array[t.charAt(i)]++;
}
int count = 0;
int len = Integer.MAX_VALUE;
int start = 0;
int end = 0;
int left = 0;
for(int i = 0; i < s.length(); i++){
char c = s.charAt(i);
if(array[c] > 0){
count++;
}
array[c]--;
while(count == t.length()){
if(i - left + 1 < len){
len = i - left + 1;
start = left;
end = i;
}
c = s.charAt(left);
array[c]++;
if(array[c] > 0){
count--;
}
left++;
}
}
return len == Integer.MAX_VALUE ? "" : s.substring(start, end + 1);
}
}3. 无重复字符的最长子串
给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。
示例：输入: s = "abcabcbb" 输出: 3
class Solution {
public int lengthOfLongestSubstring(String s) {
Map<Character, Integer> map = new HashMap<>();
int max = 0;
int left = 0;
for(int i = 0; i < s.length(); i ++){
char c = s.charAt(i);
if(map.containsKey(c)){
left = Math.max(left, map.get(c) + 1);
}
map.put(c, i);
max = Math.max(max, i - left + 1);
}
return max;
}
}class Solution {
public int lengthOfLongestSubstring(String s) {
Set<Character> set = new HashSet<>();
int left = 0;
int max = 0;
for(int i = 0; i < s.length(); i++){
char c = s.charAt(i);
while(set.contains(c)){
set.remove(s.charAt(left));
left++;
}
set.add(c);
max = Math.max(max, set.size());
}
return max;
}
}739. 每日温度
给定一个整数数组 temperatures ，表示每天的温度，返回一个数组 answer ，其中 answer[i] 是指对于第 i 天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用 0 来代替。
示例：输入: temperatures = [73,74,75,71,69,72,76,73] 输出: [1,1,4,2,1,1,0,0]
class Solution {
public int[] dailyTemperatures(int[] temperatures) {
int[] array = new int[temperatures.length];
Stack<Integer> stack = new Stack<>();
for(int i = 0; i < temperatures.length; i++){
while(!stack.isEmpty() && temperatures[stack.peek()] < temperatures[i]){
int index = stack.pop();
array[index] = i - index;
}
stack.push(i);
}
return array;
}
}42. 接雨水
给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
示例：输入：height = [0,1,0,2,1,0,1,3,2,1,2,1] 输出：6
class Solution {
public int trap(int[] height) {
Stack<Integer> stack = new Stack<>();
int sum = 0;
for(int i = 0; i < height.length; i++){
while(!stack.isEmpty() && (height[i] > height[stack.peek()])){ // 如果 height[i] > height[top]，则得到一个可以接雨水的区域
int top = stack.pop(); // 如果栈内至少有两个元素，记栈顶元素为top，top的下面一个元素是left，则一定有 height[left] ≥ height[top]
if(!stack.isEmpty()){
int left = stack.peek();
int curWidth = i - left - 1; // 该区域的宽度是 i−left−1，高度是 min(height[left],height[i])−height[top]，根据宽度和高度即可计算得到该区域能接的雨水量。
int curHeight = Math.min(height[left], height[i]) - height[top];
sum += curWidth * curHeight;
}
}
stack.push(i);
}
return sum;
}
}class Solution {
public int trap(int[] height) {
// 记录每个柱子左边柱子的最大高度
int[] maxLeft = new int[height.length];
maxLeft[0] = height[0];
for(int i = 1; i < height.length; i++){
maxLeft[i] = Math.max(height[i], maxLeft[i - 1]);
}
// 记录每个柱子左边柱子的最大高度
int[] maxRight = new int[height.length];
maxRight[height.length - 1] = height[height.length - 1];
for(int i = height.length - 2; i >= 0; i--){
maxRight[i] = Math.max(height[i], maxRight[i + 1]);
}
int sum = 0;
for(int i = 0; i < height.length; i++){
sum += Math.min(maxLeft[i], maxRight[i]) - height[i];
}
return sum;
}
}84. 柱状图中最大的矩形
给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。求在该柱状图中，能够勾勒出来的矩形的最大面积。
示例：输入：heights = [2,1,5,6,2,3] 输出：10
class Solution {
public int largestRectangleArea(int[] heights) {
int[] minLeftIndex = new int[heights.length];
int[] minRightIndex = new int[heights.length];
// 记录左边第一个小于该柱子的下标
minLeftIndex[0] = -1;
for(int i = 1; i < heights.length; i++){
int index = i - 1;
while(index >= 0 && heights[index] >= heights[i]){ // 不断向左寻找
index = minLeftIndex[index];
}
minLeftIndex[i] = index;
}
System.out.println(Arrays.toString(minLeftIndex));
// 记录每个柱子右边第一个小于该柱子的下标
minRightIndex[heights.length - 1] = heights.length;
for(int i = heights.length - 2; i >= 0; i--){
int index = i + 1;
while(index < heights.length && heights[index] >= heights[i]){
index = minRightIndex[index];
}
minRightIndex[i] = index;
}
System.out.println(Arrays.toString(minRightIndex));
int maxArea = 0;
for(int i = 0; i < heights.length; i++){
int area = (minRightIndex[i] - minLeftIndex[i] - 1) * heights[i];
maxArea = Math.max(maxArea, area);
}
return maxArea;
}
}1004. 最大连续1的个数III
给定一个二进制数组 nums 和一个整数 k，如果可以翻转最多 k 个 0 ，则返回 数组中连续 1 的最大个数 。
示例：输入：nums = [1,1,1,0,0,0,1,1,1,1,0], K = 2 输出：6
class Solution {
public int longestOnes(int[] nums, int k) {
int left = 0;
int count = 0;
int max = 0;
for (int right = 0; right < nums.length; right++) {
if(nums[right] == 0){
count++;
}
while(count > k) {
if(nums[left] == 0){
count--;
}
left++;
}
max = Math.max(max, right - left + 1);
}
return max;
}
}31. 下一个排列
整数数组的一个 排列 就是将其所有成员以序列或线性顺序排列。例如，arr = [1,2,3] ，以下这些都可以视作 arr 的排列：[1,2,3]、[1,3,2]、[3,1,2]、[2,3,1] 。整数数组的 下一个排列 是指其整数的下一个字典序更大的排列。例如，arr = [1,2,3] 的下一个排列是 [1,3,2] 。类似地，arr = [2,3,1] 的下一个排列是 [3,1,2] 。而 arr = [3,2,1] 的下一个排列是 [1,2,3] ，因为 [3,2,1] 不存在一个字典序更大的排列。给你一个整数数组 nums ，找出 nums 的下一个排列。必须 原地 修改，只允许使用额外常数空间。
class Solution {
public void nextPermutation(int[] nums) {
for(int i = nums.length - 2; i >= 0; i--){
for(int j = nums.length - 1; j > i; j--){
if(nums[j] > nums[i]){
// 交换
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
// 将 [i + 1, nums.length - 1] 升序排列
Arrays.sort(nums, i + 1, nums.length);
return;
}
}
}
Arrays.sort(nums); // 如果不存在下一个更大的排列，则将重新排列成最小的排列。
}
}59. 螺旋矩阵II
给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。
示例1：输入：n = 3 输出：[[1,2,3],[8,9,4],[7,6,5]]
示例2：输入：n = 1 输出：[[1]]
class Solution {
public int[][] generateMatrix(int n) {
int[][] matrix = new int[n][n];
int count = 1; //填充的数字
int loop = 1; //循环的次数
int start = 0; //开始填充的位置
int i, j; //行索引，列索引
//总共需要循环n/2次（填充周围）
while(loop <= n/2){
//上侧从左到右填充
for(j = start; j < n-loop; j++){
matrix[start][j] = count++;
}
//右侧从上到下填充
for(i = start; i < n-loop; i++){
matrix[i][j] = count++;
}
//下侧从右到左填充
for(; j >= loop; j--){
matrix[i][j] = count++;
}
//左侧从下到上填充
for(; i >= loop; i--){
matrix[i][j] = count++;
}
start++;
loop++;
}
//填充中心
if(n % 2 == 1){
matrix[start][start] = count;
}
return matrix;
}
}另一种解法：
class Solution {
public int[][] generateMatrix(int n) {
int[][] matrix = new int[n][n];
n = n - 1; //n行
int m = n; //m列
int row = 0;
int column = 0;
int count = 1; //填充的数字
while(row <= n && column <= m){
for(int i = column; i <= m; i++){ //上侧从左到右填充
matrix[row][i] = count++;
}
row++;
for(int i = row; i <= n; i++){ //右侧从上到下填充
matrix[i][m] = count++;
}
m--;
for(int i = m; i >= column && row <= n; i--){ //下侧从右到左填充
matrix[n][i] = count++;
}
n--;
for(int i = n; i >= row && column <= m; i--){ //左侧从下到上填充
matrix[i][column] = count++;
}
column++;
}
return matrix;
}
}54. 螺旋矩阵
给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。
示例1：输入：matrix = [[1,2,3],[4,5,6],[7,8,9]] 输出：[1,2,3,6,9,8,7,4,5]
示例2：输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]] 输出：[1,2,3,4,8,12,11,10,9,5,6,7]
class Solution {
public List<Integer> spiralOrder(int[][] matrix) {
List<Integer> list = new ArrayList<>();
int m = matrix.length - 1; //m行
int n = matrix[0].length - 1; //n列
int row = 0;
int column = 0;
while(row <= m && column <= n){
for(int i = column; i <= n; i++){
list.add(matrix[row][i]);
}
row++;
for(int i = row; i <= m; i++){
list.add(matrix[i][n]);
}
n--;
for(int i = n; i >= column && row <= m; i--){
list.add(matrix[m][i]);
}
m--;
for(int i = m; i >= row && column <= n; i--){
list.add(matrix[i][column]);
}
column++;
}
return list;
}
}剑指 Offer 29. 顺时针打印矩阵
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。
示例 1：输入：matrix = [[1,2,3],[4,5,6],[7,8,9]] 输出：[1,2,3,6,9,8,7,4,5]
示例2：输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]] 输出：[1,2,3,4,8,12,11,10,9,5,6,7]
class Solution {
public int[] spiralOrder(int[][] matrix) {
if(matrix.length == 0 || matrix[0].length ==0){
return new int[]{};
}
int[] array = new int[matrix.length * matrix[0].length];
int m = matrix.length-1;
int n = matrix[0].length-1;
int row = 0;
int column = 0;
int index = 0;
while (row <= m && column <= n){
for(int i = column; i <= n; i++){
array[index++] = matrix[row][i];
}
row++;
for(int i = row; i <= m; i++){
array[index++] = matrix[i][n];
}
n--;
for(int i = n; i >= column && row <= m; i--){
array[index++] = matrix[m][i];
}
m--;
for(int i = m; i >= row && column <= n; i--){
array[index++] = matrix[i][column];
}
column++;
}
return array;
}
}941. 有效的山脉数组
给定一个整数数组 arr，如果它是有效的山脉数组就返回 true，否则返回 false。
示例1：输入：arr = [2,1] 输出：false
示例2：输入：arr = [3,5,5] 输出：false
示例3：输入：arr = [0,3,2,1] 输出：true
class Solution {
public boolean validMountainArray(int[] arr) {
int left = 0;
int right = arr.length - 1;
while(left + 1 < arr.length && arr[left] < arr[left + 1]){
left++;
}
while(right > 0 && arr[right] < arr[right - 1]){
right--;
}
if(left == right && left != 0 && right != arr.length - 1){
return true;
}
return false;
}
}724. 寻找数组的中心下标
给你一个整数数组 nums ，请计算数组的 中心下标 。数组 中心下标 是数组的一个下标，其左侧所有元素相加的和等于右侧所有元素相加的和。如果数组有多个中心下标，应该返回 最靠近左边 的那一个。如果数组不存在中心下标，返回 -1 。
示例1：输入：nums = [1, 7, 3, 6, 5, 6] 输出：3
示例2：输入：nums = [1, 2, 3] 输出：-1
示例3：输入：nums = [2, 1, -1] 输出：0
class Solution {
public int pivotIndex(int[] nums) {
int sum = 0;
for(int i = 0; i < nums.length; i++){
sum += nums[i]; //总和
}
int leftSum = 0;
int rightSum = 0;
for(int i = 0; i < nums.length; i++){
leftSum += nums[i];
rightSum = sum - leftSum + nums[i];
if(leftSum == rightSum){
return i;
}
}
return -1;
}
}922. 按奇偶排序数组II
给定一个非负整数数组 nums， nums 中一半整数是 奇数 ，一半整数是 偶数 。对数组进行排序，以便当 nums[i] 为奇数时，i 也是 奇数 ；当 nums[i] 为偶数时， i 也是 偶数 。你可以返回 任何满足上述条件的数组作为答案 。
示例1：输入：nums = [4,2,5,7] 输出：[4,5,2,7]
class Solution {
public int[] sortArrayByParityII(int[] nums) {
int[] result = new int[nums.length];
int even = 0; //偶
int odd = 1; //奇
for(int i = 0; i < nums.length; i++){
if(nums[i] % 2 == 0){
result[even] = nums[i];
even += 2;
}else{
result[odd] = nums[i];
odd += 2;
}
}
return result;
}
}189. 轮转数组
给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。
示例1：输入: nums = [1,2,3,4,5,6,7], k = 3 输出: [5,6,7,1,2,3,4]
示例2：输入：nums = [-1,-100,3,99], k = 2 输出：[3,99,-1,-100]
class Solution {
public void rotate(int[] nums, int k) {
k = k % nums.length;
reverse(nums, 0, nums.length - 1);
reverse(nums, 0, k - 1);
reverse(nums, k, nums.length - 1);
}
public void reverse(int[] nums, int left, int right) {
while(left < right){
int temp = nums[left];
nums[left] = nums[right];
nums[right] = temp;
left++;
right--;
}
}
}
284
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
