数据结构和算法——数组

在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];
    }