数组
题目中涉及到的解法是我目前找到的解法,这些解法可能并不是最优的,但我会随着自己能力的提升一直更新它
1.从排序数组中删除重复项
给定一个排序数组,你需要在原地删除重复出现的元素,使得每个元素只出现一次,返回移除后数组的新长度。
不要使用额外的数组空间,你必须在原地修改输入数组并在使用 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。
你不需要考虑数组中超出新长度后面的元素。
说明:
为什么返回数值是整数,但输出的答案是数组呢?
请注意,输入数组是以“引用”方式传递的,这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:
// nums 是以“引用”方式传递的。也就是说,不对实参做任何拷贝
int len = removeDuplicates(nums);
// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}
langage C
int removeDuplicates(int* nums, int numsSize) {
}
思路
两个指针i、j
,指针i
向后检索,指针j
指向当前填充的位置,当向后检索发现它的前个值与当前值不同时,将该值填充到指针j
指向的位置,指针后移
解法
c语言解法
int removeDuplicates(int* nums, int numsSize) {
if(numsSize<=0) return 0;
int i,j=1;
for(i=1;i<numsSize;i++){
if(nums[i]==nums[i-1]){
continue;
}
nums[j++]=nums[i];
}
return j;
}
2.买卖股票的最佳时机 II
给定一个数组,它的第 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。
langage Java
class Solution {
public int maxProfit(int[] prices) {
}
}
思路
贪心算法,只要有收益,就卖出
解法
java 解法
class Solution {
public int maxProfit(int[] prices) {
int max=0;
for(int i=1;i<prices.length;i++){
int a=prices[i]-prices[i-1];
if(a>0) max+=a;
}
return max;
}
}
3.旋转数组
给定一个数组,将数组中的元素向右移动 k 个位置,其中 k 是非负数。
示例 1:
输入: [1,2,3,4,5,6,7] 和 k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右旋转 1 步: [7,1,2,3,4,5,6]
向右旋转 2 步: [6,7,1,2,3,4,5]
向右旋转 3 步: [5,6,7,1,2,3,4]
示例 2:
输入: [-1,-100,3,99] 和 k = 2
输出: [3,99,-1,-100]
解释:
向右旋转 1 步: [99,-1,-100,3]
向右旋转 2 步: [3,99,-1,-100]
说明:
尽可能想出更多的解决方案,至少有三种不同的方法可以解决这个问题。
要求使用空间复杂度为 O(1) 的原地算法。
langage c
void rotate(int* nums, int numsSize, int k) {
}
思路
写出向右旋转一步的算法,然后循环k次;将数组最后一个元素保存至临时变量,从数组的倒数第二个元素开始,将当前值复制到后一个位置,最后将临时变量的值存储在数组的第一个位置
解法
C 解法
void rotate(int* nums, int numsSize, int k) {
int tail,i;
while(k>0){
tail=nums[numsSize-1];
for(i=numsSize-1;i>0;i--){
nums[i]=nums[i-1];
}
nums[i]=tail;
k--;
}
}
4.存在重复
给定一个整数数组,判断是否存在重复元素。
如果任何值在数组中出现至少两次,函数返回 true。如果数组中每个元素都不相同,则返回 false。
示例 1:
输入: [1,2,3,1]
输出: true
示例 2:
输入: [1,2,3,4]
输出: false
示例 3:
输入: [1,1,1,3,3,4,3,2,4,2]
输出: true
langage C
bool containsDuplicate(int* nums, int numsSize) {
}
思路
使用插入排序的思想,对每个元素插入排序完成后,检查它的上一个元素是否和当前值相同,如果相同,返回true
解法
c语言解法
bool containsDuplicate(int* nums, int numsSize) {
int i,j;
int tmp;
for(int i=1;i<numsSize;i++){
tmp=nums[i];
j=i-1;
while(j>=0&&tmp<nums[j]){
nums[j+1]=nums[j];
j--;
}
nums[j+1]=tmp;
if(j>=-1&&nums[j+1]==nums[j]){
return true;
}
}
return false;
}
5.只出现一次的数字
给定一个非空整数数组,除了某个元素只出现一次以外,其余每个元素均出现两次。找出那个只出现了一次的元素。
说明:
你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗?
示例 1:
输入: [2,2,1]
输出: 1
示例 2:
输入: [4,1,2,1,2]
输出: 4
langage c
int singleNumber(int* nums, int numsSize) {
}
思路
使用异或运算
解法
c语言解法
int singleNumber(int* nums, int numsSize) {
int ret=0;
for(int i=0;i<numsSize;i++){
ret^=nums[i];
}
return ret;
}
6.两个数组的交集 II
给定两个数组,写一个方法来计算它们的交集。
例如:
给定 nums1 = [1, 2, 2, 1], nums2 = [2, 2], 返回 [2, 2].
注意:
输出结果中每个元素出现的次数,应与元素在两个数组中出现的次数一致。
我们可以不考虑输出结果的顺序。
跟进:
- 如果给定的数组已经排好序呢?你将如何优化你的算法?
- 如果 nums1 的大小比 nums2 小很多,哪种方法更优?
- 如果nums2的元素存储在磁盘上,内存是有限的,你不能一次加载所有的元素到内存中,你该怎么办?
langage Java
class Solution {
public int[] intersect(int[] nums1, int[] nums2) {
}
}
思路
有待补充。。
解法
java 解法
class Solution {
public int[] intersect(int[] nums1, int[] nums2) {
int len1=nums1.length;
int len2=nums2.length;
int[] b=new int[Math.max(len1,len2)];
for(int i=0;i<b.length;i++) b[i]=0;
for(int j=0;j<len2;j++){
for(int i=0;i<len1;i++){
if(b[i]!=1&&nums1[i]==nums2[j]){
b[i]=1;
break;
}
}
}
int c=0;
for(int i=0;i<b.length;i++){
if(b[i]==1) c++;
}
int[] r=new int[c];
int m=0;
for(int i=0;i<b.length;i++){
if(b[i]==1) r[m++]=nums1[i];
}
return r;
}
}
7.加一
给定一个非负整数组成的非空数组,在该数的基础上加一,返回一个新的数组。
最高位数字存放在数组的首位, 数组中每个元素只存储一个数字。
你可以假设除了整数 0 之外,这个整数不会以零开头。
示例 1:
输入: [1,2,3]
输出: [1,2,4]
解释: 输入数组表示数字 123。
示例 2:
输入: [4,3,2,1]
输出: [4,3,2,2]
解释: 输入数组表示数字 4321。
langage Java
class Solution {
public int[] plusOne(int[] digits) {
}
}
思路
先保存数组的第一个元素为tmp,然后从数组的最后一个元素开始,执行以下步骤:
- 如果该值小于9,那么直接加一并停止执行
- 如果值为9,设置该值为0,并向前迭代,依然是这两个步骤
迭代结束后,如果tmp=9并且迭代了索引0的位置,那么将数组的长度扩充,第一位补1,将原数组从新数组的第2个索引处开始复制
解法
java 解法
class Solution {
public int[] plusOne(int[] digits) {
int i=0;
int first=digits[0];
for(i=digits.length-1;i>=0;i--){
int digit=digits[i];
if(digit<9) {
digits[i]=digit+1;
break;
}else {
digits[i]=0;
}
}
if(i<0&&first==9){
int[] newArray=new int[digits.length+1];
newArray[0]=1;
for(int j=1;j<newArray.length;j++) newArray[j]=digits[j-1];
return newArray;
}
return digits;
}
}
8.移动零
给定一个数组 nums,编写一个函数将所有 0 移动到数组的末尾,同时保持非零元素的相对顺序。
示例:
输入: [0,1,0,3,12]
输出: [1,3,12,0,0]
说明:
必须在原数组上操作,不能拷贝额外的数组。
尽量减少操作次数。
langage c
void moveZeroes(int* nums, int numsSize) {
}
思路
双指针,一个指向0,一个指向非0,找到之后,两者交换,继续寻找
解法
c语言解法
void moveZeroes(int* nums, int numsSize) {
int i=0;//find zero
int j=0;//find not zero
while(true){
for(;nums[i]!=0;) i++;
for(;nums[j]==0;) j++;
if(j>=numsSize||i>=numsSize) break;
if(i<j){
nums[i]=nums[j];
nums[j]=0;
}else{
int tmp=i;
i=j;
j=tmp;
}
}
}
9.两数之和
给定一个整数数组和一个目标值,找出数组中和为目标值的两个数。
你可以假设每个输入只对应一种答案,且同样的元素不能被重复利用。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
langage c
/**
* Note: The returned array must be malloced, assume caller calls free().
*/
int* twoSum(int* nums, int numsSize, int target) {
}
解法
c语言解法
/**
* Note: The returned array must be malloced, assume caller calls free().
*/
int* twoSum(int* nums, int numsSize, int target) {
int *result=(int *)malloc(2*sizeof(int));
result[0]=-1;
result[1]=-1;
for(int i=0;i<numsSize-1;i++){
for(int j=i+1;j<numsSize;j++){
if(nums[i]+nums[j]==target){
result[0]=i;
result[1]=j;
break;
}
}
}
return result;
}
10.有效的数独
判断一个 9x9 的数独是否有效。只需要根据以下规则,验证已经填入的数字是否有效即可。
数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。
上图是一个部分填充的有效的数独。
数独部分空格内已填入了数字,空白格用 ‘.’ 表示。
示例 1:
输入:
[
[“5”,”3”,”.”,”.”,”7”,”.”,”.”,”.”,”.”],
[“6”,”.”,”.”,”1”,”9”,”5”,”.”,”.”,”.”],
[“.”,”9”,”8”,”.”,”.”,”.”,”.”,”6”,”.”],
[“8”,”.”,”.”,”.”,”6”,”.”,”.”,”.”,”3”],
[“4”,”.”,”.”,”8”,”.”,”3”,”.”,”.”,”1”],
[“7”,”.”,”.”,”.”,”2”,”.”,”.”,”.”,”6”],
[“.”,”6”,”.”,”.”,”.”,”.”,”2”,”8”,”.”],
[“.”,”.”,”.”,”4”,”1”,”9”,”.”,”.”,”5”],
[“.”,”.”,”.”,”.”,”8”,”.”,”.”,”7”,”9”]
]
输出: true
示例 2:
输入:
[
[“8”,”3”,”.”,”.”,”7”,”.”,”.”,”.”,”.”],
[“6”,”.”,”.”,”1”,”9”,”5”,”.”,”.”,”.”],
[“.”,”9”,”8”,”.”,”.”,”.”,”.”,”6”,”.”],
[“8”,”.”,”.”,”.”,”6”,”.”,”.”,”.”,”3”],
[“4”,”.”,”.”,”8”,”.”,”3”,”.”,”.”,”1”],
[“7”,”.”,”.”,”.”,”2”,”.”,”.”,”.”,”6”],
[“.”,”6”,”.”,”.”,”.”,”.”,”2”,”8”,”.”],
[“.”,”.”,”.”,”4”,”1”,”9”,”.”,”.”,”5”],
[“.”,”.”,”.”,”.”,”8”,”.”,”.”,”7”,”9”]
]
输出: false
解释: 除了第一行的第一个数字从 5 改为 8 以外,空格内其他数字均与 示例1 相同。
但由于位于左上角的 3x3 宫内有两个 8 存在, 因此这个数独是无效的。
说明:
- 一个有效的数独(部分已被填充)不一定是可解的。
- 只需要根据以上规则,验证已经填入的数字是否有效即可。
- 给定数独序列只包含数字 1-9 和字符 ‘.’ 。
- 给定数独永远是 9x9 形式的。
langage Java
class Solution {
public boolean isValidSudoku(char[][] board) {
}
}
思路
我这里用了很笨的方法,对每行,每列,每个单元格进行判别
解法
java 解法
class Solution {
public boolean isValidSudoku(char[][] board) {
int[][] b=new int[board.length][board.length];
for(int i=0;i<b.length;i++)
for(int j=0;j<b.length;j++){
if(board[i][j]=='.') b[i][j]=0;
else b[i][j]=board[i][j]-48;
}
boolean is=false;
for(int i=0;i<b.length;i++){
is=isValid(b[i]);
if(!is) return false;
}
int[] m;
for(int j=0;j<b.length;j++){
m=new int[b.length];
for(int i=0;i<b.length;i++){
m[i]=b[i][j];
}
is=isValid(m);
if(!is) return false;
}
int k=0;
for(int i=0;i<=6;i+=3){
for(int j=0;j<=6;j+=3){
m=new int[b.length];
k=0;
m[k++]=b[i][j];
m[k++]=b[i][j+1];
m[k++]=b[i][j+2];
m[k++]=b[i+1][j];
m[k++]=b[i+1][j+1];
m[k++]=b[i+1][j+2];
m[k++]=b[i+2][j];
m[k++]=b[i+2][j+1];
m[k++]=b[i+2][j+2];
is=isValid(m);
if(!is) return false;
}
}
return true;
}
public static boolean isValid(int[] b) {
int[] a=new int[10];
for(int i=0;i<a.length;i++) a[i]=0;
for(int i=0;i<b.length;i++){
a[b[i]]++;
}
for(int i=1;i<a.length;i++){
if(a[i]>1) return false;
}
return true;
}
}
11.旋转图像
给定一个 n × n 的二维矩阵表示一个图像。
将图像顺时针旋转 90 度。
说明:
你必须在原地旋转图像,这意味着你需要直接修改输入的二维矩阵。请不要使用另一个矩阵来旋转图像。
示例 1:
给定 matrix =
[
[1,2,3],
[4,5,6],
[7,8,9]
],
原地旋转输入矩阵,使其变为:
[
[7,4,1],
[8,5,2],
[9,6,3]
]
示例 2:
给定 matrix =
[
[ 5, 1, 9,11],
[ 2, 4, 8,10],
[13, 3, 6, 7],
[15,14,12,16]
],
原地旋转输入矩阵,使其变为:
[
[15,13, 2, 5],
[14, 3, 4, 1],
[12, 6, 8, 9],
[16, 7,10,11]
]
langage Java
class Solution {
public void rotate(int[][] matrix) {
}
}
思路
先将矩阵沿着正对角线翻转,再上下翻转
解法
java 解法
class Solution {
public void rotate(int[][] matrix) {
int size = matrix.length;
int tmp;
for (int i = 0; i < size-1 ; i++) {
for (int j = 0; j < size-i-1 ; j++) {
tmp=matrix[i][j];
matrix[i][j] = matrix[size - j - 1][size - i - 1];
matrix[size - j - 1][size - i - 1]=tmp;
}
}
for(int i=0;i<size/2;i++){
for(int j=0;j<size;j++){
tmp=matrix[i][j];
matrix[i][j]=matrix[size-i-1][j];
matrix[size-i-1][j]=tmp;
}
}
}
}