leetcode 部分题解(1)

1.转变数组后最接近目标值的数组和
import java.util.Arrays;
public class text {
    
    
    public int findBestValue(int[] arr, int target) {
    
    
        int sum = 0;
        int i = 0;
        for (i = 0; i < arr.length; i++) {
    
    
            sum += arr[i];
        }
        if (sum <= target) {
    
    
            Arrays.sort(arr);
            return arr[arr.length - 1];
        }
        int left = 0;
        int right = arr[arr.length - 1];
        while (left <= right) {
    
    
            int mid = (left + right) / 2;
            sum = judge(arr, mid);
            if (sum == target) return mid;
            else if (sum > target) right = mid - 1;
            else left = mid + 1;
        }
        //当结束二分查找还没找到目标值时，left值在right右边，即left比right大1，我们判断这两个值哪个最接近target。
        if (Math.abs(judge(arr, left) - target) < Math.abs(judge(arr, left - 1) - target)) return left;
        else return left - 1;
    }

    public int judge(int [] arr,int value){
    
    
        int sum = 0;
        int i= 0;
        for (i=0;i<arr.length;i++){
    
    
            if (arr[i]<value){
    
    
                sum += arr[i];
            }
            else
                sum += value;
        }
        return sum;
}

}

2. 两数之和
//第一想法肯定是通过for遍历数组
class Solution {
    
    
      public int[] twoSum(int[] nums, int target) {
    
    
            int i , j;
            for (i = 0;i<nums.length;i++){
    
    
                for(j = nums.length-1;j>i;j--){
    
    
                    if (target==nums[i]+nums[j]){
    
    
                        return new int[] {
    
    i,j};
                    }
                }
            }
            return null;
}
}

//利用HashMap
class Solution {
    
    
       public int[] twoSum(int[] nums, int target) {
    
    
            HashMap<Integer,Integer> hashMap = new HashMap<Integer, Integer>();
            int i ;
            for(i=0;i<nums.length;i++){
    
    


                if(hashMap.containsKey(nums[i])){
    
    
                    return new int[]{
    
    hashMap.get(nums[i]),i};
                }
//              把值放入hashMap中
                hashMap.put(target-nums[i],i);

            }
            return null;
            }
}

3.最长公共前缀

//横向扫描
public class text {
    
    

    public String longestCommonPrefix(String[] strs) {
    
    
        //这个判断必须要加，例子中有str=null的情况
        if (strs.length == 0 || strs == null) {
    
    
            return "";
        }
        //让第一个值全部成为最长前缀，然后一个个比较
        String Prefix = strs[0];
        int j;
        int len = 0;
        for (j = 1; j < strs.length; j++) {
    
    
            Prefix = longestCommonPrefix(Prefix, strs[j]);
            if (Prefix.length() == 0)
                return "";
        }
        return Prefix;
    }

    private String longestCommonPrefix(String prefix, String str) {
    
    
        int len = Math.min(prefix.length(), str.length());
        int index = 0;
        while (index < len && prefix.charAt(index) == str.charAt(index)) {
    
    
            index++;
        }
        return prefix.substring(0, index);
    }
}

//分治法
class Solution {
    
    
 public String longestCommonPrefix(String[] strs) {
    
    
        if (strs.length == 0 || strs == null) {
    
    
            return "";
        }else{
    
    
            return longestCommonPrefix(strs,0,strs.length-1);
        }

    }

    private String longestCommonPrefix(String[] strs, int begin, int end) {
    
    
        if (begin==end){
    
    
            return strs[begin];
        }else{
    
    
            int mid = (begin+end)/2;
            String left = longestCommonPrefix(strs,begin,mid);
            String right = longestCommonPrefix(strs,mid+1,end);
            return longestCommonPrefix(left,right);
        }
    }

    private String longestCommonPrefix(String prefix, String str) {
    
    
        int len = Math.min(prefix.length(), str.length());
        int index = 0;
        while (index < len && prefix.charAt(index) == str.charAt(index)) {
    
    
            index++;
        }
        return prefix.substring(0, index);
    }
}

4.整数反转（借鉴大神)
intmax=2147483647
intmin=-2147483648(java)

public class text {
    
    
    public int reverse(int x) {
    
    
        int sum = 0;
        while(x!=0){
    
    
            //当sum*10溢出时，/10就不等于原来的数
            if ((sum*10)/10!=sum){
    
    
                return 0;
            }
            sum = sum*10+x%10;
            x = x/10;
        }
        return sum;
    }
}

5.回文数
//菜鸡做法，利用一个数组作为媒介
public class text {
    
    
    public boolean isPalindrome(int x) {
    
    
        if (x<0){
    
    
            return false;
        }
        if (x==0){
    
    
            return true;
        }
        int temp = x;
        int num = 0;
        while (temp!=0){
    
    
            temp=temp/10;
            num++;
        }
        int[] a = new int[num];
        int i = 0;
        for(i=0;i<num;i++){
    
    
            a[i] = x%10;
            x = x/10;
        }
        for(i=0;i<num/2;i++){
    
    
            if (a[i]!=a[num-i-1]){
    
    
                return false;
            }
        }
        return true;
    }
}


//官方做法
public class text {
    
    
    public boolean isPalindrome(int x) {
    
    
        //当x小于0，或者x的个位数为0，但x！=0时，x不可能为回文数
        if (x < 0 || (x % 10 == 0 && x != 0)) {
    
    
            return false;
        }
        //设置x的一半相反数，当x<reversenum时停止，当x为回文数时，x的后半部分会与前半部分相等
        int reversenum = 0;
        while (x > reversenum) {
    
    
            reversenum = reversenum * 10 + x % 10;
            x = x / 10;
        }
        return reversenum == x || reversenum / 10 == x;
    }
}

6.罗马数字转整数
//观察罗马数字特点，当左边的数比右边的数大时，符号为+，反之为-
  public static int romanToInt(String s) {
    
    
        char[] chars = s.toCharArray();
        int num = 0;
        int i;
        HashMap<Character,Integer> hashMap = new HashMap<Character, Integer>();
        hashMap.put('I', 1);
        hashMap.put('V', 5);
        hashMap.put('X', 10);
        hashMap.put('L', 50);
        hashMap.put('C', 100);
        hashMap.put('D', 500);
        hashMap.put('M', 1000);
        for (i=0;i<chars.length-1;i++){
    
    
            if (hashMap.get(chars[i])<hashMap.get(chars[i+1])){
    
    
                num-=hashMap.get(chars[i]);
            }else{
    
    
                num+=hashMap.get(chars[i]);
            }
        }
        return num+hashMap.get(chars[i]);
    }

7.最佳观光组合
//关键：将A[i] + A[j] + i - j转变为 (A[i]+i)+(A[j]-j)
public class text {
    
    
    public int maxScoreSightseeingPair(int[] A) {
    
    
        int maxScore = 0;
        int i = 0;
        //利用临时值存储选定的一个地点
        int temp = A[0]+0;
        for (i=0;i<A.length;i++){
    
    
            //选择大的分数
            maxScore = Math.max(maxScore, temp+A[i]-i);
            //及时更新地点
            temp = Math.max(temp, A[i]+i);
        }
        return maxScore;
    }
}

8.有效的括号
class Solution {
    
    
 public static boolean isValid(String s) {
    
    
        if (s.length()==0){
    
    
            return true;
        }
       //为奇数立马返回false
        if (s.length()%2!=0){
    
    
            return false;
        }
     
       //利用栈来判断（书本上的原知识）
        Stack st = new Stack() ;
        int i ;
        for (i=0;i<s.length();i++){
    
    
            char a = s.charAt(i);
            switch (a){
    
    
                case '(':
                    st.push(a);
                    break;
                case '{':
                    st.push(a);
                    break;
                case '[':
                    st.push(a);
                    break;
                case ')':
                    if (st.empty()||!st.peek().equals('(')){
    
    
                        return false;
                    }
                    else st.pop();break;
                case ']':
                    if (st.empty()||!st.peek().equals('[')){
    
    
                        return false;
                    }
                    else st.pop();break;
                case '}':
                    if (st.empty()||!st.peek().equals('{')){
    
    
                        return false;
                    }
                    else st.pop();break;

            }
        }
        return st.empty();
    }

}

9.合并两个有序列表
/**
 * 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 mergeTwoLists(ListNode l1, ListNode l2) {
    
    
        ListNode l = new ListNode(0);
        ListNode l3 = l;
        while (l1!=null&&l2!=null){
    
    
            if (l1.val<=l2.val){
    
    
                l3.next=l1;
                l1=l1.next;
            }
            else {
    
    
                l3.next=l2;
                l2=l2.next;
            }
            l3=l3.next;
        }
        l3.next= l1==null?l2:l1;
        return l.next;
    }

}

10.删除排序数组中的重复项
class Solution {
    
    
    public int removeDuplicates(int[] nums) {
    
    
        int i = 0;
        int j;
        for (j=1;j<nums.length;j++){
    
    
            if (nums[i]!=nums[j]){
    
    
                i++;
                nums[i]=nums[j];
            }
        }
        //这里i+1是指有多少不重复的数字。
        return i+1;

    }
}

11.移除元素
class Solution {
    
    
    public int removeElement(int[] nums, int val) {
    
    
        int i =0 ;
        int j;
        for (j=0;j<nums.length;j++){
    
    
            if (nums[j]!=val){
    
    
                nums[i]=nums[j];
                i++;
            }
        }
        return i;
    }
}

12.实现 strStr
class Solution {
    
    
    public static int strStr(String haystack, String needle) {
    
    
        //当haystack的长度小于needle的长度时，直接返回false
        if (haystack.length()==0&&needle.length()!=0||haystack.length()<needle.length()){
    
    
            return -1;
        }


        if (haystack.length()==0&&needle.length()==0){
    
    
            return 0;
        }

        if (needle.length()==0){
    
    
            return 0;
        }

        int i ;
        //找到haystack中与needle第一元素相同的位置，通过judge函数比较后面的是否一致。
        for (i=0;i<haystack.length();i++){
    
    
            if (needle.charAt(0)==haystack.charAt(i)){
    
    
                //当haystack剩下的数量小于needle的长度时，直接返回false
                if (haystack.length()-i<needle.length()){
    
    
                    return -1;
                }else {
    
    
                    if(judge(haystack,needle,i)){
    
    
                        return i;
                    }
                }

            }
        }
        return -1;
    }

        private static boolean judge(String haystack, String needle, int j) {
    
    
        int i;
        for (i=0;i<needle.length();i++){
    
    
            if (haystack.charAt(j+i)!=needle.charAt(i)){
    
    
                return false;
            }
        }
        return true;
    }
}

13.搜索插入位置
//for循环
class Solution {
    
    
    public int searchInsert(int[] nums, int target) {
    
    
        int i;
        int temp = 0;
        for(i=nums.length-1;i>=0;i--){
    
    
            if(nums[i]==target){
    
    
                temp=i;
                break;
            }else if(nums[i]<target){
    
    
                temp = i+1;
                break;
            }
        }
        return temp;
    }
}

//二分搜索
class Solution {
    
    
    public int searchInsert(int[] nums, int target) {
    
    
        int left=0;
        int right = nums.length-1;
        while(left<=right){
    
    
            int mid = (left+right)/2;
            if(nums[mid]==target){
    
    
                return mid;
            }
            else if(nums[mid]>target){
    
    
                right = mid-1;
            }
            else{
    
    
                left = mid+1;
            }
        }
        return left;
}
}