持续更新中..................
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--;
}
}
}