找出给定一系列整数中的最小值_面试中这几道经常遇到的算法题，你学会了吗

1 给定一个整数数组 nums 和一个目标值 target ，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例：

给定 nums = [2,7,11,15], target = 9因为 nums[0] + nums[1] = 2 + 7 = 9所以返回 [0,1]

解法1：暴力法

暴力法很简单，遍历每个元素x，并查找是否存在一个值与 target - x 相等的目标元素。

class Solution {    public int[] twoSum(int[] nums, int target){        for(int i =0;i

复杂度分析：

• 时间复杂度：，对于每个元素，我们试图通过遍历数组的其余部分来寻找它所对应的的目标元素，这将耗费的时间。因此复杂度为。
• 空间复杂度： 。

解法2：两遍哈希表

为了对运行时间复杂度进行优化，我们需要一种更有效的方法来检查数组中是否存在目标元素。如果存在，我们需要找出它的索引。保持数组中的每个元素与其索引相互对应的最好方法是什么？哈希表。

通过一空间换取速度的方式，我们可以将查找时间从 O(n) 降低到 O(1) 。哈希表正是为此目的而构建的，它支持以近似恒定的时间进行快速查找。我用“近似”来描述，是因为一旦出现冲突，查找用时可能会退化到 O(n)。但只要你仔细地挑选哈希函数，在哈希表中进行查找的用时应当被摊销为 O(1)。

一个简单的实现使用了两次迭代。在第一次迭代中，我们将每个元素的值和它的索引添加到表中。然后，在第二次迭代中，我们将检查每个元素所对应的目标元素(target - nums[i])是否存在于表中。注意，该目标元素不能是 nums[i] 本身！

class Solution {    public int[] twoSum(int[] nums, int target){        Map map = new HashMap<>();        for(int i = 0;i

复杂度分析：

• 时间复杂度：O(n)，我们把包含有 n 个元素的列表遍历两次。由于哈希表将查找时间缩短到 O(1)，所以时间复杂度为 O(n)。
• 空间复杂度：O(n)，所需的额外空间取决于哈希表中存储的元素数量，该表中存储了 n 个元素。

解法3：一遍哈希表

事实证明，我们可以一次完成。在进行迭代并将元素插入到表中的同时，我们还会回过头来检查表中是否已经存在当前元素所对应的目标元素。如果它存在，那我们已经找到了对应解，并立即将其返回。

class Solution {    public int[] twoSum(int[] nums,int target) {        Map map = new HashMap<>();        for(int i = 0;i< nums.length; i++){            int complement = target - nums[i];            if(map.containsKey(complement)){                return new int[] {map.get(complement),i};            }            map.put(nums[i], i};        }         throw new IllegalArgumentException("No two sum solution");    }}

复杂度分析：

• 时间复杂度：O(n)，我们只遍历了包含有 n 个 元素的列表一次。在表中进行的每次查找只花费 O(1) 的时间。
• 空间复杂度：O(n)，所需的额外空间取决于哈希表中存储的元素数量，该表最多需要存储 n 个元素。

---

2 给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

示例 1：

输入: 123输出: 321

示例 2：

输入: -123输出: -321

示例 3：

输入: 120输出: 21

注意：假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为

。请根据这个假设，如果反转后整数溢出那么就返回 0。

解法1：弹出和推入数字 & 溢出前进行检查思路

我们可以一次构建反转整数的以为数字。在这样做的时候，我们预先检查向原整数附加另一位数字是否会导致溢出。

算法：

• 反转整数的方法可以与反转字符串进行类比。
• 我们想重复“弹出”x 的最后一位数字，并将它“推入”到 rev 的后面。最后，rev 将与 x 相反。
• 要在没有辅助堆栈/数组的帮助下“弹出”和“推入”数字，我们可以使用数学方法。

//pop operation:pop = x % 10;x /= 10;//push operation:temp = rev * 10 + pop;rev = temp;

但是，这种方法很危险，因为当 temp = rev.10 + pop 时会导致溢出。

幸运的是，实现检查这个语句是否会导致溢出很容易。

为了便于解释，我们假设 rev 是整数。

1. 如果 temp = rev.10 + pop 导致溢出，那么一定有 。
2. 如果 ，那么 temp = rev.10 + pop 一定会溢出。
3. 如果 ，那么只要 pop > 7，temp = rev.10 + pop 就会溢出。

当 rev 为负时可以应用类似地逻辑。

class Solution {    public int reverse(int x){        int rev = 0;        while (x != 0){            int pop = x % 10;            x /= 10;            if(rev > Integer.MAX_VALUE / 10 || (rev == Integer.MAX_VALUE / 10                                                && pop > Integer.MAX_VALUE % 10)){                return 0;            }             if(rev

复杂度分析：

• 时间复杂度：O(log(x)), x 中大约有 位数字。
• 空间复杂度：O(1) 。