在Java中,数组是用来存放同一种数据类型的集合,注意只能存放同一种数据类型(Object类型数组除外)。
数组是存在下标索引的,通过下标可以获取指定位置的元素,数组小标是从0开始的,也就是说下标0对应的就是数组中第1个元素,可以很方便的对数组中的元素进行存取操作。
数组特点:
- 数组一旦创建后,大小就固定了,不能动态扩展数组的元素个数。
- 查找
- 如果根据下标查找速度很快。
- 如果根据元素值来查找,对于无序数组,我们需要从数组第一个元素开始遍历,直到找到那个元素。有序数组通过特定的算法查找的速度会比无需数组快。
- 根据元素值删除,需要先遍历数组,然后将元素后面的值整体向前面移动一个位置。也需要比较多的时间。
寻找重复数
给定一个包含 n + 1 个整数的数组 nums,其数字都在 1 到 n 之间(包括 1 和 n),可知至少存在一个重复的整数。假设只有一个重复的整数,找出这个重复的数。
思路:利用HashSet去重特性
public int findDuplicate(int[] nums) {
HashSet set = new HashSet();
for(int i = 0;i<nums.length;i++){
if(!set.contains(nums[]i)){
set.add(nums[i])
}else{
return nums[i];
}
}
return 0;
}
缺失数字
给定一个包含 0, 1, 2, ..., n
中 n 个数的序列,找出 0 … n 中没有出现在序列中的那个数。
思路:数组的和减去数组序列的和即为缺失的数字
public int missingNumber(int[] nums) {
// 数组的和 =(n(n+1))/2
int res = (nums.length) * (nums.length + 1) / 2;
int sum = 0;
// 按顺序累加
for (int i = 0; i < nums.length; i++) {
sum += nums[i];
}
return res - sum;
}
斐波那契数列
思路:迭代法,中间变量保存
public int fib(int N) {
if(N == 0){
return 0;
}
if(N == 1){
return 1;
}
int[] arr = new int[N+1];
arr[0]=0;
arr[1]=1;
//中间状态值保存
for(int i=2;i<=N;++i){
arr[i]=arr[i-1]+arr[i-2];
}
return arr[N];
}
两数之和
给定一个整数数组 nums
和一个目标值 target
,请你在该数组中找出和为目标值的那 两个 整数,并返回他们的数组下标。
思路:利用HashMap,目标值减去当前值(循环遍历数组),如果map中包含就返回,如果不包含就添加到map中
public int[] twoSum(int[] nums, int target) {
Map<Integer,Integer> map = new HashMap();
for(int i=0;i<nums.length;i++){
int component = target - nums[i];
if(map.contains(component)){
return new int[]{map.get(component),i}
}else{
map.put(nums[i], i);
}
}
throw new IllegalArgumentException("No two sum solution");
}
最大子序和
给定一个整数数组 nums
,找到一个具有最大和的连续子数组(子数组最少包含一个元素),返回其最大和。
思路:动态规划
//动态规划的是首先对数组进行遍历,当前最大连续子序列和为 sum,结果为 ans
//如果 sum > 0,则说明 sum 对结果有增益效果,则 sum 保留并加上当前遍历数字
//如果 sum <= 0,则说明 sum 对结果无增益效果,需要舍弃,则 sum 直接更新为当前遍历数字
//每次比较 sum 和 ans的大小,将最大值置为ans,遍历结束返回结果
//时间复杂度:O(n)
public int maxSubArray(int[] nums) {
public int maxSubArray(int[] nums) {
int ans = nums[0];
int sum = 0;
for(int num: nums) {
if(sum > 0) {
sum += num;
} else {
sum = num;
}
ans = Math.max(ans, sum);
}
return ans;
}
}
数组中第K个最大元素
思路:数组排序,且第K个最大即N-K
public int findKthLargest(int[] nums, int k) {
if (nums == null || nums.length == 0 || k <= 0 || k > nums.length) {
return -1;
}
Arrays.sort(nums);
int N = nums.length;
return nums[N - k];
}