java leetCode1-5

1.TwoSum

 

暴力搜索

   public static int[]  twoSum(int [] arr,int target){ //leeCode中必须将方法也命令为twosum
        int[] result = new int[2];
        if(arr.length>1){
            for(int i=0;i<arr.length;i++){
                for(int j=i+1;j<arr.length;j++){  //遍历后的元素不需要在做遍历 因此j=i+1
                    if(arr[i]+arr[j]==target){
                        result[0]=i;
                        result[1]=j;
                    }
                }
            }
        }
        return result;
    }

map实现：

   public static int[]  twoSum(int [] arr,int target){ //leeCode中必须将方法也命令为twosum
        int[] result = new int[2];
        Map<Integer,Integer> map = new HashMap<Integer,Integer>();
        for(int i=0;i<arr.length;i++){
            if(map.containsKey(target-arr[i])){//map中是否包含对应的键如果有就找到了为目标数两个下标 此时间复杂最好为1最坏为n hashcode发生冲突时
                result[0]=i;
                result[1]=map.get(target-arr[i]);
                break;
            }else{                               //没有找到将数组中的数加入map中为下一个数提供对比条件
                map.put(arr[i],i);
            }
        }
        return result;
    }

2.addTwoNumbers

 

 public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
             ListNode firstNode = new ListNode(-1);  //java创建链表
             ListNode listNode = firstNode;          //指向链表的首结点
             int carry = 0;
             while (l1 != null || l2 != null) {
                 int sum = 0;
                 sum += l1 != null ? l1.val : 0;
                 sum += l2 != null ? l2.val : 0;
                 sum += carry;
                 carry = sum / 10;
                 listNode.next = new ListNode(sum % 10);
                 listNode=listNode.next;
                 if(l1!=null) l1=l1.next;
                 if(l2!=null) l2=l2.next;
             }
             if (carry == 1) listNode.next = new ListNode(1); //java中只有boolean 才能用if(carry)
             return firstNode.next; //返回首结点的下一个结点
         }

     }

 

3.lengthOfLongestSubstring

暴力

class Solution {
 public int lengthOfLongestSubstring(String s) {
        int sum=0;
        int max=0;
        int m=0;
        for(int i=0;i<s.length();i++) {
            for (int j = m; j < i; j++) {        //第二个for循环判断的是 是否有重复元素
                if (s.charAt(i) == s.charAt(j)) {
                    sum = 0;
                    i=j+1;                       //当失配时i回到适配的前一个位置
                    m = j+1;
                    break;

                }
            }                               //判断完了才能使子串长度+1
            sum++;
            if(max<sum){
                max=sum;
            }
        }
        return max;
    }
}

 

使用hashMap 滑动窗口解决问题：

// char的包装类 Character
public class Solution {
    public int lengthOfLongestSubstring(String s) {
        int ans=0;//记录最长的子串
        int length=s.length();
        Map<Character,Integer> map = new HashMap<Character,Integer>();
        for(int i=0,j=0;i<length;i++){
            if(map.containsKey(s.charAt(i))){ //时间复杂度为o（1） 最坏为o(n)产生冲突
                //必须做一次max判断 因为相同的元素可能会
                //在窗口（此时进行比较的字符串）的后面 而在窗口的后面就不会
                //当遇到相同的字符，如果字符在窗口在窗口前方就需要更新j指针，否则不用管
                  j=Math.max(map.get(s.charAt(i)),j);
            }
            ans=Math.max(ans,i-j+1);
            //将元素的下一个索引处放入map中
            map.put(s.charAt(i),i+1);
        }
        return ans;
        
        }
        
    
}

4.findMedianSortedArrays

此处 关于java double

result=(arr[length/2-1]+arr[length/2])/2 ; 没有返回小数部分 只有分开写才能保留小数部分

class Solution {
   public static double findMedianSortedArrays(int[] nums1, int[] nums2) {
        double result=0.0;
        int start=0;
        int left_length=nums1.length;
        int right_length=nums2.length;
        int[] arr=new int[left_length+right_length];
        int i=0,j=0,k=start;
        while(i<left_length && j<right_length){
            if(nums1[i]<nums2[j]){
                arr[k++]=nums1[i++];
            }else{
                arr[k++]=nums2[j++];
            }
        }
        while(i<left_length){
            arr[k++]=nums1[i++];
        }
        while(j<right_length){
            arr[k++]=nums2[j++];
        }
        int length=arr.length;
        if(length%2==0){
            System.out.println((arr[length/2-1]+arr[length/2]));
            result=(arr[length/2-1]+arr[length/2]);
            result=result/2;

        }else{
            result=arr[length/2];
        }
        return result;
    }
}

5.

longestPalindrome 

求字符串的最长回文串（字符串的从右向左和从左向右都相同） 并返回最长回文串  

暴力算法实现 设定两个游标m,n 指向字符串，当遇到两个字符相同时 m++ n-- 判断字符串是否相同

class Solution{ //暴力算法  改进 用了（没有用java 的substring() 超时
    public String longestPalindrome(String s) {
        if(s==null||s.length()<1) return "";  //此处要多加判断条件s.length（）<1
        String smax="";
        int ans=0;
        int length=s.length();
        for(int i=0;i<length;i++){
            for(int j=i+1;j<length;j++){
                if(s.charAt(i)==s.charAt(j))
                    if(ans<j-i+1){
                        int m=i,n=j;
                        while(m!=n){
                            m++;
                            n--;
                            if(m>=n){ //此处的判断条件要不能写为m==n 因为忽视了为偶数的情况
                                ans=j-i+1;
                                smax=s.substring(i,j+1);
                                break;
                            }
                            if(s.charAt(m)!=s.charAt(n)){
                                break;
                            }
                        }
                    }
            }
        }
        if(ans==0){
            return ""+s.charAt(0);
        }
        return smax;
    }
}

动态规划实现 ：

下一个状态和前一个状态有关，要找到下一个状态需要知道前一个状态

从最初的状态开始找：边界条件

找到状态方程 :

https://blog.csdn.net/shineboyxxb/article/details/52079360

 

一个字符串满足回文串时 它的子串也是回文串：上面的第三个状态方程

当 只有两个字符(只要两个字符对应相等 就是回文串) 与

只有一个字符（直接是回文串）时 是边界条件

class Solution {
    public String longestPalindrome(String s) {
        int left=0,right=0;
        int max=0;
        int length=s.length();
        boolean flag[][]=new boolean[length][length];
        for(int i=0;i<length;i++){
            for(int j=0;j<=i;j++){
                if(i-j==0 ||(i-j==1 && s.charAt(i)==s.charAt(j))){
                    flag[j][i]=true;
                }else if(s.charAt(i)==s.charAt(j)&&flag[j+1][i-1]){
                    flag[j][i]=true;
                }

                if(max<i-j+1&&flag[j][i]){
                    max=i-j+1;
                    left=j;
                    right=i+1;
                }

            }
        }
        return s.substring(left,right);
    }
}