力扣.5.最长回文子串力扣.14最长公共前缀力扣219.存在重复元素II力扣.67二进制求和

目录

力扣.5.最长回文子串

力扣.14最长公共前缀

力扣219.存在重复元素II

力扣.67二进制求和

---

力扣.5.最长回文子串

中心拓展算法，假设以i位置为中心两边可以扩展到多少，所以当对应一个中间位置的时候，可以定义两个指针，对应一个前和一个后，然后中心扩展面临的问题就是可能回文是奇数，可能是偶数，所以需要进行两次中心扩展，

class Solution {
    public String longestPalindrome(String s) {
        //中心拓展算法
        int n=s.length();
        char[]a=s.toCharArray();
        String c="";
        int max=0;
        for(int i=0;i<n;i++){
            int left=i-1;
            int right=i+1;
            while(left>=0&&right<n){
                if(a[left]==a[right]){
                    left--;
                    right++; 
                }else{
                    break;
                }
            }
            
            if(right-left-1>max){
                c=s.substring(left+1,right);
                max=right-left-1;

            }
            left=i;
            right=i+1;
             while(left>=0&&right<n){
                if(a[left]==a[right]){
                    left--;
                    right++; 
                }else{
                    break;
                }
            }
           
            if(right-left-1>max){
                c=s.substring(left+1,right);
                max=right-left-1;
            }
        }
            return c;
    }
}

力扣.14最长公共前缀

我起初的想法十分混乱，压根没往什么两个比较上想，我还是想用哈希表统计次数，但是越统计发现糊涂，有点懵了，(然后看是简单题，我就这么一个调试，快完事了后，告诉我，最后几个用例过不去，直接放弃看题解的思路，没想到这么简单，说个思路就写出来了。 

​​​​​​​

可以定义一个指针，相同的情况右移动，相同右移动，蛮考验代码实力

class Solution {
public static String longestCommonPrefix(String[] strs) {
    int []hash=new int[26];
    int n=strs.length;
    //两个两个比较
    String common=strs[0];
    for(int i=1;i<n;i++) {
        char[]a=common.toCharArray();
        String ret="";
        char[] b = strs[i].toCharArray();
        for (int j = 0; j < Math.min(b.length, a.length); j++) {
            if (a[j] == b[j]) {
                ret += a[j];
            } else {
                break;
            }
        }
        common=ret;
    }

    return common;
}
}

这个解法的优化代码版本:思路是一致的

class Solution {
 public  String longestCommonPrefix(String[] strs) {
      //两个两个比较
      String ret=strs[0];
      //先记录第一个字符串，然后依次比较即可
      for(int i=1;i<strs.length;i++){
        ret=findCommon(strs[i],ret);
      }
      return ret;
    }
    public String findCommon(String s1,String s2){
        int i=0;
//记录后统计i的位置，然后如果s1和s2相等，i往后移动
        while(i<Math.min(s1.length(),s2.length())&&s1.charAt(i)==s2.charAt(i))
        i++;
//这样就返回0-i位置的字符串
        return s1.substring(0,i);
    }
}

解法二:统一比较，就是我上面的那个最初想法，但是还略微不同

class Solution {
 public static String longestCommonPrefix(String[] strs) {
        int []hash=new int[26];
        int n=strs.length;
        //两个两个比较
        String common="";
        int min=9999;
        int count=0;
        for(int i=0;i<n;i++){
            min=Math.min(min,strs[i].length());
        }
        for(int j=0;j<min;j++){
            char[]a=strs[0].toCharArray();
            char tmp=a[j];
            for(int i=0;i<n;i++){
                char[]b=strs[i].toCharArray();
                if(tmp!=b[j]){
                    count=1;
                    break;
                }
            }
            if(count==1){
                break;
            }
            common+=tmp;
        }

        return common;
    }
}

力扣219.存在重复元素II

使用哈希表的同时我们还需要注意，他的存储下标，假如她出现第二种情况

1 0 1 1，当我们发现重复元素，看他是不是满足<=k,假如满足直接返回k,假如不满足，我们默认更新后面的重复值，因为假如后面还有重复值，那肯定是离他最近的相同的元素，是我们这个想更新的元素，而不是最远的那个，因为我们是想返回true，那肯定先找能满足这个小于的情况的(意思就是找近的)。

class Solution {
    public boolean containsNearbyDuplicate(int[] nums, int k) {
        HashMap<Integer,Integer>a=new HashMap<>();
        for(int i=0;i<nums.length;i++){
            if(!a.containsKey(nums[i])){
            a.put(nums[i],i);
            }else{
               if(Math.abs(a.get(nums[i])-i)<=k)  return true;
                 a.put(nums[i],i);
            }
        }
        return false;
    }
}

力扣.67二进制求和

这个代码感觉有点冗余，就是典型的莽夫算法

class Solution {
       //a和b两个字符串，我们想要求出两个的和
   public static String addBinary(String a, String b) {
       char[]aa=a.toCharArray();
       char[]bb=b.toCharArray();
       int i=aa.length-1;
       int j=bb.length-1;
       StringBuffer ret=new StringBuffer();
       int count=0;
       while(i>=0&&j>=0) {
           //两个都是1，然后进位有一个0
          if(aa[i]=='1'&&bb[j]=='1'&&count==0){
            ret.append(0);
            count++;
           }//两个1，并且进位是1
          else if(aa[i]=='1'&&bb[j]=='1'&&count==1){
            ret.append(1);
          }
          //假如说有一个为0，一个为1的情况，进位为1
          else if((aa[i]=='1'||bb[j]=='1')&&count==1){
              ret.append(0);
          }else if((aa[i]=='1'||bb[j]=='1')&&count==0){
              ret.append(1);
          }//两个都是0的情况
          else if(aa[i]=='0'&&bb[j]=='0'&&count==0){
              ret.append(0);
          }else if(aa[i]=='0'&&bb[j]=='0'&&count==1){
              count--;
              ret.append(1);
          }
         i--; j--;
       }

        while(i>=0){
            //两个都是1，然后进位有一个0
            if(aa[i]=='1'&&count==0){
                ret.append(1);
            }//两个1，并且进位是1
            else if(aa[i]=='1'&&count==1){
                ret.append(0);
            }else if(aa[i]=='0'&&count==1){
                count--;
                ret.append(1);
            }
            else if(aa[i]=='0'&&count==0){
                ret.append(0);
            }
            i--;
        }
        while(j>=0){
            //两个都是1，然后进位有一个0
            if(bb[j]=='1'&&count==0){
                ret.append(1);
            }//两个1，并且进位是1
            else if(bb[j]=='1'&&count==1){
                ret.append(0);
            }else if(bb[j]=='0'&&count==1){
                count--;
                ret.append(1);
            }
            else if(bb[j]=='0'&&count==0){
                ret.append(0);
            }
            j--;
        }
        if(count==1){
            ret.append(count);
            count--;
        }
       return ret.reverse().toString();
    }
}

实际上高精度是想考