力扣-初级算法_力扣初级算法

学习目标：

1、用java和c++和c，把题目都做一遍。
2、然后把做题过程，做到csdn上。
3、定期检索。

1. 删除排序数组中的重复项

public int removeDuplicates(int[] nums) {
    if (nums.length == 0) return 0;
    int i = 0;
    for (int j = 1; j < nums.length; j++) {
        if (nums[j] != nums[i]) {
            i++;
            nums[i] = nums[j];
        }
    }
    return i + 1;
}

1
2
3
4
5
6
7
8
9
10
11
12

原地算法

在计算机科学中，一个原地算法（in-place algorithm）是一种使用小的，固定数量的额外之空间来转换资料的算法。
当算法执行时，输入的资料通常会被要输出的部份覆盖掉。

2. 买卖股票的最佳时机 II

c++贪心算法

class Solution {
    public int maxProfit(int[] prices) {
        int maxprofit = 0;
        for (int i = 1; i < prices.length; i++) {
            if (prices[i] > prices[i - 1])
                maxprofit += prices[i] - prices[i - 1];
        }
        return maxprofit;
    }
}

1
2
3
4
5
6
7
8
9
10
11

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size() <= 1) return 0;

        int maxprofit = 0;

        for(int i=1;i<prices.size();++i)
        {
            maxprofit += max(prices[i]-prices[i-1], 0);
        }

        return maxprofit;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3. 旋转数组

public static void rotate3(int[] nums, int k) {
        k %= nums.length;
        //k = k % nums.length;//如果超出数组长度，就需要重头再来。
        reverse(nums, 0, nums.length - 1);
        reverse(nums, 0, k - 1);
        reverse(nums, k, nums.length - 1);
    }
    public static void reverse(int[] nums, int start, int end) {
        while (start < end) {
            int temp = nums[start];
            nums[start] = nums[end];
            nums[end] = temp;
            start++;
            end--;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

4. 存在重复元素

public boolean containsDuplicate(int[] nums) {
    Set<Integer> set = new HashSet<>(nums.length);
    for (int x: nums) {
        if (set.contains(x)) return true;
        set.add(x);
    }
    return false;
}

1
2
3
4
5
6
7
8
9

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        unordered_map<int, int> map;
        for(int n : nums) {
            map[n] ++;
            if(map[n] > 1) 
				return true;
        }
        return false;
    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13

这道题目
c++和java解法都用到了，集合。
c不用集合很麻烦。

5. 只出现一次的数字

异或，同为零，不同为1

为什么空间复杂度也是On？
因为需要建立与原本数组一样的大小的数组，原本的数组大小是n个。

代码

class Solution {
    public int singleNumber(int[] nums) {
        int single = 0;
        for (int num : nums) {
            single ^= num;
        }
        return single;
    }
}
1
2
3
4
5
6
7
8
9

6. 两个数组的交集 II

方法1：哈希映射

代码

c++的语法需要去学习

代吗2：先排序，再遍历

细节：
如果num1中的元素大于num2，则num2向后移动1位。
如果num2中的元素大于num1，则num1向后移动1位。

代码

为什么时间复杂度？

因为用了排序，然后用了线性扫描。

方法三：使用内置函数

c++的语法需要去学习

import java.text.SimpleDateFormat;
import java.util.*;
class Solution {
    public static void main(String[] args) {
        ArrayList<Integer> num1 = new ArrayList<>();
        ArrayList<Integer> num2 = new ArrayList<>();
        num1.add(1);
        num1.add(1);
        num1.add(2);

        num2.add(1);
        num2.add(1);
        num2.add(2);
        num2.add(3);
        fun(num1,num2);
    }
    public static void fun(ArrayList<Integer> num1,ArrayList<Integer> num2){
        //可以直接求出交集
        num1.retainAll(num2);
        System.out.println(num1);
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

7.加一

我的理解：

我一开始没理解。
现在理解了题意，就是用数组来表示数字，
题目让我们加一。如果没有进位，说明这个数组就是这个数字，
如果进位了，就是100000。。。。

思路：

只要+1求余数，余数不等于0，说明没有进位，直接返回。如果余数等于0，说明有进位，遍历前一个数字，加1再求余数，以此循环。如果for循环都遍历完了，说明最高位也有进位，则重新建立一个数组，初始化为0，将第一位设置为1就可以了，因为，99、999之类的数字加一为100、1000

class Solution {
    public int[] plusOne(int[] digits) {
        for (int i = digits.length - 1; i >= 0; i--) {
            digits[i]++;
            digits[i] = digits[i] % 10;
            if (digits[i] != 0)
                return digits;
        }
        digits = new int[digits.length + 1];
        digits[0] = 1;
        return digits;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class Solution {
public:
    vector<int> plusOne(vector<int>& digits) {
        reverse(digits.begin(),digits.end());
        int n = digits.size();
        for (int i = 0; i < n; i++)
        {
            digits[i] += 1;
            if (digits[i] !=  10)
            {
                break;
            }
            else
            {
                digits[i] = 0;
            }
        }
        if (digits[n - 1] == 0)
        {
            digits.push_back(1);
        }
        reverse(digits.begin(),digits.end());
        return digits;
    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26