典型的几道数组题(leetcode easy)
典型的几道数组题(leetcode easy)
1.多数元素
给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。
你可以假设数组是非空的，并且给定的数组总是存在多数元素
输入: [2,2,1,1,1,2,2]
输出: 2
class Solution {
public int majorityElement(int[] nums) {
int count=1; int cand=nums[0];
for(int i=1;i<nums.length;i++){
if(cand==nums[i]){
++count; //支持我的投1票
}else{
--count; //如果跟我不一样就投反票
if(count==0){
//当跟我一样的都没了候选人给对方
cand=nums[i];
count=1; //对方初始要为一票，不然下一个不一样就为-1了
}
}
}
return cand; //到最后返回的当选人肯定是支持票大于反对票的
}
}
第二种就是
Arrays.sort(nums);
return nums[nums.length>>1];
2. 非递减数列
给你一个长度为 n 的整数数组，请你判断在 最多 改变 1 个元素的情况下，该数组能否变成一个非递减数列。
输入: nums = [4,2,3]
输出: true
解释: 你可以通过把第一个4变成1来使得它成为一个非递减数列。
核心 :主要判断第一个数是否是递减，缓存前一个数然后比较后面得数
class Solution {
public boolean checkPossibility(int[] nums) {
int cnt = 0;
for(int i = 0; i < nums.length - 1; i++) {
//4,2,3
if(nums[i] > nums[i + 1]) {
//4>2
int tmp = nums[i]; //tmp=4
if(i >= 1) {
nums[i] = nums[i - 1]; //说明第二个数太小了
} else {
nums[i] = nums[i + 1]; //nums[0]=2 ,第一个数太大了
}
if(nums[i] > nums[i + 1]) {
nums[i] = tmp;
nums[i + 1] = nums[i];
}
cnt++;
if(cnt == 2) {
return false;
}
}
}
return true;
}
}
3.重新排列数组
给你一个数组 nums ，数组中有 2n 个元素，按 [x1,x2,…,xn,y1,y2,…,yn] 的格式排列。
请你将数组按 [x1,y1,x2,y2,…,xn,yn] 格式重新排列，返回重排后的数组。
输入：nums = [1,1,2,2], n = 2
输出：[1,2,1,2]
class Solution {
//折半赋值
public int[] shuffle(int[] nums, int n) {
int index = 0;
int[] result = new int[nums.length];
for (int i = 0; i < n; i++) {
result[index++] = nums[i];
result[index++] = nums[n+i];
}
return result;
}
}
121. 买卖股票的最佳时机
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
如果你最多只允许完成一笔交易（即买入和卖出一支股票一次），设计一个算法来计算你所能获取的最大利润。
注意：你不能在买入股票前卖出股票。
示例 1:
输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
示例 2:
输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
思路:
- 要找到价格最低得，价格高得就直接卖出去，第一次没股票所以先找价格低得
- 就是一个累积差得正数和
class Solution {
public int maxProfit(int[] prices) {
int sum=0;
int minprice = Integer.MAX_VALUE;
for(int i=0;i<prices.length;i++){
if(prices[i]<minprice){
//先找到开始顺序上价格最低得一次
minprice=prices[i];
}else if(prices[i] - minprice > sum){
//记录卖的得钱
sum = prices[i] - minprice;
}
}
return sum;
}
}
122. 买卖股票的最佳时机 II
难度简单827收藏分享切换为英文关注反馈
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
**注意：**你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1:
输入: [7,1,5,3,6,4]
输出: 7
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。
示例 2:
输入: [1,2,3,4,5]
输出: 4
解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
示例 3:
输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
//如果是递增数列，相差和也是最后一个最大得减去第一个最小得
//反之不是递增数列，递减得话，后面都比前面小，那么全是亏，所以小于0得时候不加钱
//既不是递增也不是递减，那么就计算每一次赚得得钱
class Solution {
public int maxProfit(int[] prices) {
int sum=0,tmp=0;
for(int i=1;i<prices.length;i++){
int chajia=prices[i]-prices[i-1];
if(chajia>0) sum+=chajia;
}
return sum;
}
}
844. 比较含退格的字符串
给定 S 和 T 两个字符串，当它们分别被输入到空白的文本编辑器后，判断二者是否相等，并返回结果。 # 代表退格字符。
**注意：**如果对空文本输入退格字符，文本继续为空。
示例 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 = "#a#c"
输出：true
解释：S 和 T 都会变成 “c”。
示例 4：
输入：S = "a#c", T = "b"
输出：false
解释：S 会变成 “c”，但 T 仍然是 “b”。
class Solution {
public boolean backspaceCompare(String S, String T) {
StringBuilder s=new StringBuilder();
StringBuilder s1=new StringBuilder();
char[] str1=S.toCharArray();
char[] str2=T.toCharArray();
int left=str1.length-1;int right=str2.length-1;
int count=0;
while(left>=0){
if(str1[left]!='#'){
//c
if(count>0){
left--;
count--;
continue;
}
s.append(str1[left]);
}else{
count++;
}
left--;
}
count=0;
while(right>=0){
if(str2[right]!='#'){
if(count>0){
right--;
count--;
continue;
}
s1.append(str2[right]);
}else{
count++;
}
right--;
}
return s.toString().equals(s1.toString());
}
}