leetcode总结——数组篇

环形数组
快慢指针：最多出现两次的数组，环入口地址
Map：两数和/三数和/四数和，播放磁带，01数组，连续和为k的数组(含有负数)
滑动窗口：最长不重复子串,t步内差小于k。
首尾指针：水桶容量，两数和/三数和/四数
序列和：最小/最大的连续和为k的数组。pat型：除开自己的以外的乘积
贪心算法：合并区间，跳跃数组，矩阵面积，会议室，汽车加油
计算机数字转化
锯齿遍历，递增的三元组

zhizhen,xuliehe,huadongchuankou,map
环形数组：
给定一个含有正整数和负整数的环形数组 nums。 如果某个索引中的数 k 为正数，则向前移动 k 个索引。相反，如果是负数 (-k)，则向后移动 k 个索引。因为数组是环形的，所以可以假设最后一个元素的下一个元素是第一个元素，而第一个元素的前一个元素是最后一个元素。
/**

• Definition for singly-linked list.
• class ListNode {

• int val;
  

• ListNode next;
  

• ListNode(int x) {
  

•     val = x;
  

•     next = null;
  

• }
  

• }
  */
  public class Solution {
  public boolean hasCycle(ListNode head) {
  ListNode slowNode = head;
  ListNode fastNode = head;
  while(fastNode!=null&&fastNode.next!=null){
  fastNode=fastNode.next.next;
  slowNode=slowNode.next;
  if (slowNode==fastNode){
  return true;
  }
  }
  return false;
  }
  }
  确定 nums 中是否存在循环（或周期）。循环必须在相同的索引处开始和结束并且循环长度 > 1。此外，一个循环中的所有运动都必须沿着同一方向进行。换句话说，一个循环中不能同时包括向前的运动和向后的运动。

示例 1：
输入：[2,-1,1,2,2]
输出：true
解释：存在循环，按索引 0 -> 2 -> 3 -> 0 。循环长度为 3 。
示例 2：

输入：[-1,2]
输出：false
解释：按索引 1 -> 1 -> 1 … 的运动无法构成循环，因为循环的长度为 1 。根据定义，循环的长度必须大于 1 。

    import java.lang.*;
    class Solution {
        public boolean circularArrayLoop(int[] nums) {
            int flag1;//作为前向或者正向运动的标志
            int length=0;//长度
            for(int i=0;i<nums.length;i++){
                int j=i;//记录当前的位置
                length=0;
                if(nums[i]>0){flag1=1;}
                else flag1=0;
                while((nums[j]+j+nums.length)%nums.length!=i&&flag1!=-1){
                       if(flag1!=nums[j]/Math.abs(nums[j]))flag1=-1;
                       length++;
                       j=(nums[j]+j+nums.length)%nums.length;
                }
                if(length==0||flag1==-1){break;}
                else{
                    return true;
                }
            }
            return false;
        }
    }

除开自己的以外的乘积
给定长度为 n 的整数数组 nums，其中 n > 1，返回输出数组 output ，其中 output[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。
示例:
输入: [1,2,3,4]
输出: [24,12,8,6]
说明: 请不要使用除法，且在 O(n) 时间复杂度内完成此题。

答案：
除num[i]以外数字的乘积等于数字左边的乘积 乘以数字右边的乘积。转化为找"pat"类型题目
答案一：

class Solution {
    public int[] productExceptSelf(int[] nums) {
        int leftNums[]=new int [nums.length];//记录i数字左边的乘积
        leftNums[0]=1;//第一个数字是1
        int rightNums[]=new int [nums.length];//记录i数字右边的乘积
        rightNums[nums.length-1]=1;//最后一个数字1
        int resultNums[]=new int [nums.length];//除了i以外数字的乘积
        for(int i=1;i<nums.length;i++){
            leftNums[i]=leftNums[i-1]*nums[i-1];
        }
        for(int i=nums.length-2;i>=0;i--){
            rightNums[i]=rightNums[i+1]*nums[i+1];
            resultNums[i]=leftNums[i]*rightNums[i];
        }
        resultNums[nums.length-1]=leftNums[nums.length-1]*rightNums[nums.length-1];
        return resultNums;
    }
}

答案二：
来源于leetcode解析里 LDouble 的作法
利用单数组res,k记录

class Solution {
    public int[] productExceptSelf(int[] nums) {
        int[] res = new int[nums.length];
        int k = 1;
        for(int i = 0; i < res.length; i++){
            res[i] = k;
            k = k * nums[i]; // 此时数组存储的是除去当前元素左边的元素乘积
        }
        k = 1;
        for(int i = res.length - 1; i >= 0; i--){
            res[i] *= k; // k为该数右边的乘积。
            k *= nums[i]; // 此时数组等于左边的 * 该数右边的。
        }
        return res;
    }
}

两数和：
解析：利用辅助数组(或者Map)

两次遍历:

 class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer,Integer> map =new HashMap<>();
        for(int i=0;i<nums.length;i++){
            map.put(target-nums[i],i);
        }
        for(int i=0;i<nums.length;i++){
            if(map.containsKey(nums[i])&&map.get(nums[i])!=i){
                return new int[]{i,map.get(nums[i])};
            }
        }
        return null;
    }
}

一次遍历：

 class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer,Integer> map =new HashMap<>();
        for(int i=0;i<nums.length;i++){
            if(map.containsKey(target-nums[i])){
                return new int []{map.get(target-nums[i]),i};
            }
            map.put(nums[i],i);
        }
        return null;
    }
}

三数和：
给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。

注意：答案中不可以包含重复的三元组。
例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为：
[
[-1, 0, 1],
[-1, -1, 2]
]

import java.lang.*;
import java.util.*;

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> list=new LinkedList<>();
        int low,high;
        int len=nums.length;
        Arrays.sort(nums);
        for(int i=0;i<len-2;i++){
            if(i>0&&nums[i]==nums[i-1]) continue;
            low=i+1;
            high=len-1;
            while