快速计算1比特数 x= x&(x-1) 将数字的最后一位变成0直到x=0，就可以计算出每一个数字中的1比特数。不过要求O(N)

• 动态规划
  • 奇数：二进制表示中，奇数一定比前面那个偶数多一个 1，因为多的就是最低位的 1。
  • 偶数：二进制表示中，偶数中 1 的个数一定和除以 2 之后的那个数一样多。因为最低位是 0，除以 2 就是右移一位，也就是把那个 0 抹掉而已，所以 1 的个数是不变的。

链接：

class Solution {
    public int[] countBits(int n) {
        int [] res = new int[n+1];
        res[0]=0;
        for(int i=1;i<=n;i++){
            if(i%2==1) res[i]=res[i-1]+1;
            else res[i] = res[i>>1];
        }
        return res;
    }
}

• 依次确定每一个二进制位

  答案的第 i个二进制位就是数组中所有元素的第 i个二进制位之和除以3的余数。

class Solution {
    public int singleNumber(int[] nums) {
        //位运算，计算所有数值 某个位上之和，如果和为3的倍数那么 改为上要求的数值为0
        //否则改位为1
        int bitSum[] = new int[32];
        
        for(int i=0;i<nums.length;i++){
            int t = nums[i];
            int j=0;
            while(j<32&&t!=0){
                //左移一位
                if((t&1)==1) bitSum[j]++;
                t>>=1;
                j++;
            }
        }
        int res =0;
        for(int i=0;i<32;i++){
            if(bitSum[i]%3!=0){
                res|=1<<i;
            }
        }
        System.out.println(bitSum[31]);
        return res;
    }
}

• 异或运算

算数三补1，逻辑双补0。

要求时间O(N),空间O(1) 注意条件数组长度n，数值0~n-1.

原地置换，将所有元素归位。

#include <iostream>
using namespace std;

int main() {
    int nums [] = {1,4,3,2,2};
    while(nums[nums[0]]!=nums[0]){
        int t = nums[0];
        nums[0] = nums[t];
        nums[t] = t;
    }
    cout<<nums[0];
}

class Solution {
    public int firstMissingPositive(int[] nums) {
        //归位 将x 放入索引为 x-1的位置
        // 缺失的数值一定在 1~len+1中

        //遍历一遍 正数最小
        // int min = Integer.MAX_VALUE;
        // for(int i=0;i<nums.length;i++) if(nums[i]>0&&min>nums[i]) min = nums[i];
        // [7,8,9,11,12] 长度为5 缺失的数值一定在 1~6之间,对于超过n+1的数直接忽略掉.
        // 
        // for(int i=0;i<nums.length;i++) if(nums[i]>0) nums[i]-=min;
    
        int len = nums.length;

        for(int i=0;i<nums.length;i++){
            while(nums[i]>0&&nums[i]<=len&&nums[nums[i]-1]!=nums[i]){
                swap(nums,nums[i]-1,i);
            }   
            //  for(int j=0;j<nums.length;j++) System.out.print(nums[j]+" ");
        }

        // for(int i=0;i<nums.length;i++) System.out.print(nums[i]+" ");

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

        return len+1;
    }

    public void swap(int []nums,int i,int j){
        nums[i] = nums[i]^nums[j];
        nums[j] = nums[i]^nums[j];
        nums[i] = nums[i]^nums[j];
    }
}

• hash表记录某个元素是否出现，比如hash[i] = -1 表示元素i+1出现了，那么只要遍历一遍数组大等于0的就是首个未出现的正整数。
  怎么维护hash表？

1. 遍历一遍数组，对值小于0或者大于len+1的数值，一定不是答案，那就重新赋值为1.
2. 再次遍历数组，对于数值x，取绝对值求得索引下标 i=abs(x)-1,那么对i下标的位置abs(y)数值取相反数-abs(y),这样遍历一遍，只要数组下标x位置数值为负数，就说明x+1存在。否则缺失。

• 可以用一个 int 型整数记录某个字符串中出现的字符。如果字符串包含 ‘a’，那么整数最右边的数位为 1，如果字符串包含 ‘b’，那么整数从右边起倒数第 2 位为 1。这样做的好处就是能更快地判定两个字符串是否包含相同的字符。如果两个字符串包含相同的字符，那么两个整数的与运算将不等于 0。反之，如果两个字符串不包含相同的字符，那么两个整数的与运算将等于 0 。

  答案

class Solution {
    public int maxProduct(String[] words) {
        //map去重复的字母  
        //特点 只需要比较字符串中的相同字母 以及相同字母数量是否相同。
        //getBitMask 为什么要|而不是+，主要是mett与met拥有相同的字母，长度不同而已，但实际与其他字符串判断结果是相同。 所以|运算可以去除重复的字母。
        //如果用 + ： abad 1+2+1+8=12 ccc 4+4+4 12 这种实际字母组成不同但是会被直接排除在最终计算之内
        //如果用 | ： abad 1+2+8=11 ccc 4 对应二进制位的&也没有交集所以是正确的
        HashMap<Integer,Integer> map = new HashMap<>();
        for(int i=0;i<words.length;i++){
            int bitmask = getBitMask(words[i]);
            int l = map.getOrDefault(bitmask,0);
            //如果数组中存在由相同的字母组成的不同单词，则会造成不必要的重复计算 如meet与met
            map.put(bitmask,Math.max(l,words[i].length()));
        }
        Set<Integer> keyset = map.keySet();
        int max=0;
        for(int i:keyset){
           for(int j:keyset){
              if((i&j)==0) max = Math.max(max,map.get(i)*map.get(j));
           } 
        }

        return max;
    }

    int getBitMask(String str){
        int bit=0;
        for(int i=0;i<str.length();i++){
            bit|=1<<(str.charAt(i)-'a');
        }
        return bit;
    }
}

• 首先对数组排序，然后采用双指针便利
• 先左边确定一个base，然后从右边双指针遍历
• 判重
  • base遍历连续相同的数值，直接跳过
  • front，end指针遍历相同数值指针也直接跳过

题解

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> ans= new ArrayList();
        Arrays.sort(nums);
        int lg = nums.length;
        for(int i=0;i<lg;i++){
            int front = i+1;
            int end = lg-1;
            int total =0;
            //去重
            if((i>0&&nums[i]==nums[i-1])||nums[i]>0) continue;
            while(front<end){
                total = nums[i]+nums[front]+nums[end];
                if(total<0) front++;
                else if(total>0) end--;
                else {
                    ans.add(Arrays.asList(nums[i],nums[front],nums[end]));
                    //去重
                     front++;
                    while(front<end&&nums[front]==nums[front-1]) front++;
                    while(front<end&&end+1<lg&&nums[end]==nums[end+1]) end--;   
                }
            }
        }
        return ans;

    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Rh51vKQM-1690389392989)(https://s2.loli.net/2022/02/20/pQiK7s4vb8cRonI.png)]

• 滑动窗口

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
       //滑动窗口
        int start = 0,end = 0,sum = 0,res = Integer.MAX_VALUE;

        while(end<nums.length){
            sum+=nums[end];
            if(sum<target) {end++;continue;}
            while(start<=end&&sum>=target){
                res = Math.min(res,end-start+1);
                if(res==1) return 1;
                sum -= nums[start++];
            }
            end++;
        }
       return res==Integer.MAX_VALUE?0:res;
    }
}

class Solution {
    public int numSubarrayProductLessThanK(int[] nums, int k) {
        if(k<=1) return 0;
        int front=0,end=0,count=0,res=1;
        while(end<nums.length){
            //以右指针为基准，每次遍历一个右指针计数， 所有后缀数组
            //res<k 那么久移动右指针，res累乘，res<k ，那么front~end之间的左右后缀数组都满足小于k
            while(end<nums.length&&res*nums[end]<k){
                res*=nums[end];
                count+=(end-front+1);
                end++;
            }
           
           if(end==nums.length) return count;
            // 当res>k时候，1.收缩左指针（front<end) 2.两个指针都右挪（front==end)
           res*=nums[end];
            //System.out.println(res+","+count+"/");
           while(front<end&&res>=k){
              res/=nums[front++];
           }
            count+=(end-front+1);
            end++;
        }
        return count;

    }
}

• 思路前缀和：

  • 前缀和记录之前所有和为sum1的连续子数组之和。当遍历到sum_j,假设存在以数组下标0开始以i为结尾的连输子数组之和为sum-k，那么一定存在i_{j的连续子数组之和为k的连续子数组，那么COUNT}j~ = COUNT_i。

• map存储的是前缀和sum的个数，那么当计算到前缀和为sum的时候，从map中获取前缀和为sum-k的数量。（像动态规划。）

class Solution {
    public int subarraySum(int[] nums, int k) {
        //前缀和 计算前j个数字中可能的连续数组和为kk
        //即为 前j的前缀和sum 前面种有多少个前缀和为sum-k的前缀数组
        HashMap<Integer,Integer> map = new HashMap<>();
        map.put(0,1);
        int sum=0,count=0;
        for(int e:nums){
            sum+=e;
            count+=map.getOrDefault(sum-k,0); 
            //前缀数组存储
            map.put(sum,map.getOrDefault(sum,0)+1);
        }
        return count;

    }
}

• 前缀和+hash表

同上一个题目，将0和1个数相同的数组长度转换为和为0的最大连续子数组长度（0记为-1），map记录前缀和x的最小左下标。

references

class Solution {
    public int findMaxLength(int[] nums) {
        //求最长连续子数组和为0的长度
        //最长连续,求和为k的连续子数组
        //map存储 前缀和为sum的连续子组的下标preIndex，则当前前缀和为sum的数组下标为i。
        //那么中间区间的数组和即位0 长度为i-preIndex。
        //默认和为0的连续子数组下标为-1。

        HashMap<Integer,Integer> map = new HashMap<>();
        int sum=0,max=0;
        map.put(0,-1);
        for(int i=0;i<nums.length;i++){
            if(nums[i]==0) sum--;
            else sum++;
	//存在和为sum的前缀子数组，保证一定是第一个记录的rindex
            if(map.containsKey(sum)){
                int preIndex = map.get(sum);
                max = max>i - preIndex?max:i-preIndex;
            }
	//否则记录该rindex
           else {
               map.put(sum,i);
           }
        }
        return max;
        
    }
}

题解

• 计算二维数组的前缀和

class NumMatrix {
    private int [][] sum;

    public NumMatrix(int[][] matrix) {
         int r = matrix.length;
         int l = matrix[0].length;
         sum = new int[r+1][l+1];
         for(int i=1;i<=r;i++){
             for(int j=1;j<=l;j++){
                 sum[i][j] = sum[i-1][j]+sum[i][j-1]-sum[i-1][j-1]+matrix[i-1][j-1];
                 //System.out.print(sum[i][j]+" ");
             }
             //System.out.println();
         }
    }
    
    public int sumRegion(int row1, int col1, int row2, int col2) {
        return sum[row2+1][col2+1] -sum[row1][col2+1]-sum[row2+1][col1]+sum[row1][col1];
    }
}

/**
 * Your NumMatrix object will be instantiated and called as such:
 * NumMatrix obj = new NumMatrix(matrix);
 * int param_1 = obj.sumRegion(row1,col1,row2,col2);
 */

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sHtKME8p-1690389392991)(https://s2.loli.net/2022/02/26/CLm2F6Qprdqyt1I.png)]

class Solution {
    public boolean checkInclusion(String s1, String s2) {
        //变位词判断 统计相同长度的字符串的字符串中 每个字符个数相等
        int l1 = s1.length();
        int l2 = s2.length();
        if(l1>l2) return false;

        int [] cnt1 = new int[26];
        int [] cnt2 = new int [26];
        int a=l1,b=-1;
        for(int i=0;i<l1;i++){
            int t = s1.charAt(i)-'a';
            int t2 = s2.charAt(i)-'a';
            cnt1[t]++;
            cnt2[t2]++;
            if(t<a) a = t;
            if(b<t) b = t;
        }

       int start =0,end = l1-1;
       while(end<l2){
           if(compare(cnt1,cnt2,a,b)) return true;
           if(end+1<l2){
                int t = s2.charAt(end+1)-'a';
                cnt2[t]++;
                t = s2.charAt(start)-'a';
                cnt2[t]--;
           }
           end++;
           start++;
       }
       return false;
    }

    //固定字母区间 a～b
    public boolean compare(int []a1,int []a2,int a,int b){
        for(int i=a;i<=b;i++){
            if(a1[i]!=a2[i]) return false;
        }
        return true;
    }
}

• 思路同上

class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        int l1= s.length();
        int l2 = p.length();
        if(l1<l2) return new ArrayList();
        List<Integer> res = new ArrayList<>();
        int []cnt1 = new int[26];
        int []cnt2 = new int[26];
        int a=0 ,b=0;
        for(int i =0;i<l2;i++) 
        {
            int t = p.charAt(i)-'a';
            cnt2[t]++;
            cnt1[s.charAt(i)-'a']++;
            if(t<a) a = t;
            if(t>b) b =t;
        }
        int start=0,end =l2-1;
        while(end<l1){
            if(compare(cnt1,cnt2,a,b)){
                res.add(start);
            }
            if(end+1<l1){
            int t = s.charAt(end+1)-'a';
            int t2 = s.charAt(start)-'a';
            cnt1[t]++;
            cnt1[t2]--;
            }
            end++;
            start++;
        }
        return res;

    }

    boolean compare(int []str1,int []str2,int a,int b){
        for(int i=a;i<=b;i++) {
            if(str1[i]!=str2[i]) return false;
        }
        return true;
    }
}

• 题解： 双指针+hashSet

  • 右指针元素放入set，如果能直接放就放入，不能放入说明有相同的元素，那么就讲左指针的元素一个个从set中删除，直到set能放入右指针的元素。

class Solution {
    public int lengthOfLongestSubstring(String s) {
        if(s==null||s.length()==0) return 0;
        if(s.length()==1) return 1;
        HashSet<Character> set = new HashSet<>();

        int max = 0,start=0,end=0,count=0;

        while(end<s.length()){
            char t = s.charAt(end);
            if(!set.contains(t)) 
            {
                set.add(t);
                count = end-start+1;
                end++;
                if(max<count) max= count;
            }
            else{
                t = s.charAt(start);
                set.remove(t);
                start++;
            }
        }
           return max;
    }
}

• 题解
  • 双指针滑动窗口+hash报表
  • 对s的每一个字符串计数每一个字母的数量
  • 当p的每一个字母计数数组 cnt1[i] 都小于 s的计数数组cnt2[i],那么就是满足题意，否则不满足，就有指针右移，添加元素。满足就左指针右移，删除元素，继续判断是否满足题意，满足就记录最小长度。

class Solution {
    public String minWindow(String s, String t) {
        int ls = s.length();
        int lt = t.length();
        if(ls<lt) return "";
        int cnt1 [] = new int[60];
        int cnt2[] = new int[60];
        int a=60,b=-1;
        for(int i=0;i<lt;i++){
            int r = t.charAt(i)-'A';
            cnt2[r]++;
            cnt1[s.charAt(i)-'A']++;
            if(a>r) a=r;
            if(b<r) b=r;
        }

        int left=0,right=lt-1,minLen=ls+1,rl=0,rr=0;
        while(right<ls){
            while(contains(cnt1,cnt2,a,b)){
                if(minLen>right-left+1){
                    minLen = right-left+1;
                    rl = left;
                    rr = right+1;
                }
                int r = s.charAt(left++)-'A';
                cnt1[r]--;
            }  
            if(right+1<ls){
                int r = s.charAt(right+1)-'A';
                cnt1[r]++;
            }
          right++;
        }
        return s.substring(rl,rr);
    }

    public boolean contains(int []cnt1,int []cnt2,int a,int b){
        for(int i=a;i<=b;i++){
            if(cnt1[i]<cnt2[i]) return false;
        }
        return true;
    }
}

• 双指针，首先首尾指针遍历哪出元素不等，没有的话直接回文
• 若有不等的，那就可以左指针跳过到下一个元素，或者右指针跳过到下一个元素。这两种结果综合得解。

class Solution {
    public boolean validPalindrome(String s) {
        if(s==null||s.length()==0) return true;
        int l = s.length();
        int left=0,right=l-1;
        while(left<right){
            char a = s.charAt(left);
            char b = s.charAt(right);
            if(a!=b){
                if(left+1==right) return true;
                else if(left+1<right) {
                    return compare(s,left,right-1)||compare(s,left+1,right);
                }
            }
            left++;
            right--;
        }
        return true;

    }

    public boolean compare(String s,int l,int r){
        while(l<r){
            char a = s.charAt(l);
            char b = s.charAt(r);
            if(a!=b) return false;
            l++;
            r--;
        }
        return true;
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aDgOPa1x-1690389392991)(https://s2.loli.net/2022/03/02/t4WUElNzd6ybwCS.png)]

• dp[j][j+i-1] 表示j～j +i-1之间的字符串为回文串（i==2的时候单独判断），那么当s[j-1]==s[j+i] 时候dp[j-1][j+i] 也是回文串。同时count计数

class Solution {
    public int countSubstrings(String s) {
        //dp dp[i][j] = (dp[i+1][j-1]&&i==j);
        if(s==null||s.length()<=1) return s.length();
       
        int l =s.length();
        boolean [][] dp = new boolean [l][l];
        int count = l;
        for(int i=0;i<l;i++) dp[i][i] =true;

        for(int i=2;i<=l;i++){
            for(int j=0;j+i-1<l;j++){
                char a = s.charAt(j);
                char b = s.charAt(j+i-1);
                if(i==2&&a==b){dp[j][j+i-1]=true;count++;}
                else if(i>2&&a==b&&dp[j+1][j+i-2]){
                    dp[j][j+i-1]=true;
                    count++;
                }
            }
        }
        return count;

    }
}

• dp+深搜

class Solution {
    public List<List<String>> partition(String s) {
        
        // dp parlind[i][j] 得到字符串i~j是否为回文串，进行剪枝
        boolean parlind [][]= new boolean[s.length()][s.length()];
        for(int i=0;i<s.length();i++) {
            parlind[i][i] = true;
            if(i>0&&s.charAt(i)==s.charAt(i-1)) parlind[i-1][i] =true;
        }

        for(int i=3;i<=s.length();i++){
            for(int j=0;j+i-1<s.length();j++){
                parlind[j][j+i-1] = parlind[j][j+i-1] || parlind[j+1][j+i-2]&&s.charAt(j)==s.charAt(i+j-1);
            }
        }
    
        ArrayList<List<String>> res =  new ArrayList<>();

        dfs(s,0,parlind,res,new ArrayList<String> ()); 
        return res; 
    }

    void dfs(String s,int index ,boolean parlind[][],ArrayList<List<String>> res,ArrayList<String> temp){
        if(index==s.length()){
            res.add(new ArrayList<String>(temp));
            return ;
        }
        for(int i=index;i<s.length();i++){
            if(parlind[index][i]){
                temp.add(s.substring(index,i+1));
                dfs(s,i+1,parlind,res,temp);
                temp.remove(temp.size()-1);
            }
        }

    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pw1Kjpn1-1690389392993)(https://s2.loli.net/2022/03/04/RO5CIhsa6NWbpc2.png)]

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode slow=head,fast=head;
        //a = c+(n-1)(b+c);
        while(fast!=null){
            slow = slow.next;
            if(fast.next==null) return null;
            fast = fast.next.next;
            if(slow==fast) break;
        } 
        if(fast==null) return null;
        //注意 当fast 2倍速于slow的时候，那么当a=0，一定会在head的时候相遇。
        if(fast==head) return head;
        int count=0;
        ListNode node=head; 
        while(node!=null){
            count++;
            node = node.next;
            slow=slow.next;
            if(node==slow) break;
        }
        return node; 
    }
}

• 双指针，控制两个指针在相交点或者最终为节点相遇，控制两者走完相同的距离，假设list1长m，list长n，那么让两指针都走 m+n距离或者更少有交点的情况在第一个交点出相遇。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        //双指针，让两个指针走相同的路程 最后就会相遇
        // if(headA==null||headB==null) return null;
        ListNode pa = headA,pb = headB;
        if(pa==null||pb==null) return null;
        //最后就是一种情况 pa=pb pa为空或者不为空
        while(pa!=pb){
            pa = pa==null?headB:pa.next;
            pb = pb==null?headA:pb.next;
        }
        return pa;
    }
}

• 反转链表，让最低位位头节点，然后相加。最后在反转即可。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        //反转最低位位于头节点
        ListNode L1 = reverse(l1);
        ListNode L2 = reverse(l2);
        int count =0;ListNode head  = null,node=null;
        while(L1!=null||L2!=null||count>0){
            int a =L1==null?0:L1.val,b = L2==null?0:L2.val;
            int v = (count+a+b)%10;
            count = (count+a+b)/10;
            if(head==null) {head = new ListNode(v);node = head;}
            else {
                node.next = new ListNode(v);
                node = node.next;
            }
            L1 =L1==null?null:L1.next;
            L2 =L2==null?null:L2.next;
        }
        return reverse(head);

    }

    ListNode reverse(ListNode l){
        ListNode pre = null,node = l;
        while(node!=null){
            ListNode temp = node.next;
            node.next = pre;
            pre = node;
            node = temp;
        }
        return pre;
    }
}

• 题解1 ，将链表存入数组，这样就可以快速访问指定位置的节点，然后再插入。

• 题解2: 时间复杂度O(n) 空间复杂度O（1）

  • 找到链表的中心节点，将中心节点后的节点反转链表l2
  • 然后讲两个链表的按位置间隔插入即可

  快慢指针快速找到链表中心节点fast2，slow1。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public void reorderList(ListNode head) {
        //寻找中间节点 fast slow指针 
        ListNode mid = middle(head);
        //反转右半边
        ListNode right = reverse(mid),left = head;

        //合并 right可能比left长
        ListNode rNext = null,lNext = null;
        while(left!=null){
            
            rNext = right.next;
            lNext =left.next;

            left.next = right;
            right.next=lNext;//可能提前为 lNext = null
            
            right=rNext;
            left = lNext;
        }
    }

    ListNode reverse(ListNode l){
        ListNode pre = null,node = l;
        while(node!=null){
            ListNode temp = node.next;
            node.next = pre;
            pre = node;
            node = temp;
        }
        return pre;
    }

    ListNode middle(ListNode head){
        ListNode fast = head,slow = head;
        while(fast.next!=null&&fast.next.next!=null){
            fast = fast.next.next;
            slow = slow.next;
        }
        return slow;
    }

   // void print()
}

• 题解同上，其中对于反转后得到的两个链表，如果一个链表多出一个元素，直接跳过不需要判断。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public boolean isPalindrome(ListNode head) {
        ListNode mid = middle(head);
        ListNode l2 = reverse(mid);
        while(l2!=null&&head!=null){
            if(head.val!=l2.val) return false;
            head = head.next;
            l2=l2.next;
        }
        return true;

    }

     ListNode middle(ListNode head){
         ListNode fast = head,slow = head;
         while(fast.next!=null&&fast.next.next!=null){
             fast=fast.next.next;
             slow = slow.next;
         }
         return slow;
     }

     ListNode reverse(ListNode l){
         ListNode pre=null,node = l;
         while(node!=null)