LeetCode笔记

1. 题号1013：能否分成连续的三等分

思维方式真的重要，分成三等分，不能被三整除的数自然排除；
每一份为sum/3，只需累加到该数值，count计数加一，累加归零，当i<length-1时，count>2即可；
要更加虚心的学习；

sum归零时要在上层循环归零

2. 题号7：整数倒置

int取值范围【-2的31次方，2的31次方-1】
-2147483648 ~ 2147483647
4个字节,即32个二进制位

 while(x!=0){
        i=i*10+x%10;
        x/=10;
 }
 解法一： 直接用long定义再判断是否溢出，十分方便
 if(i>Integer.MAX_VALUE || i<Integer.MIN_VALUE) return 0;

 解法二：比较i%10与Integer.MAX_VALUE/10的关系，若相等再判断x%10是否大于7或小于-8

 解法三： 今天发现的神仙方法，真简便
 return (int)n==n? (int)n:0;

3. 题号1071：两个字符串的最大公约数

// 假设str1是N个x，str2是M个x，那么str1+str2肯定是等于str2+str1的。

class Solution {
   public String gcdOfStrings(String str1, String str2) {
       if (!(str1 + str2).equals(str2 + str1)) {
           return "";
       }
      
       return str1.substring(0, gcd(str1.length(), str2.length()));
       //切割并反回字符串，从0到二者最大公约数
   }
      // 辗转相除法求gcd(最大公约数)
   private int gcd(int a, int b) {       
       return b == 0? a: gcd(b, a % b);
   }
}

4. 题号169：数组中数量大于n/2的数

解法一：
排序后，返回中位数
解法二：
摩尔投票法

5. 题号229：大于n/3的数

 摩尔投票法（用于求众数）：
 设置f-1个候选人（cand），遍历数组，如果数字相同count++，不同count--，count==0时更换候选人
 最后判断候选人票数是否大于n/f，返回满足条件的元素
    //投票过程（精髓continue和else if细节）
    for (int num : nums) {
        //如果是候选者1，票数++
        if (num == cand1) {
            cnt1++;
            continue;
        }
        //如果是候选者2，票数++
        if (num == cand2) {
            cnt2++;
            continue;
        }
        //既不是cand1也不是cand2，如果cnt1为0，那它就去做cand1
        if (cnt1 == 0) {
            cand1 = num;
            cnt1++;
            continue;
        }
        //如果cand1的数量不为0但是cand2的数量为0，那他就去做cand2
        if (cnt2 == 0) {
            cand2 = num;
            cnt2++;
            continue;
        }
        //如果cand1和cand2的数量都不为0，那就都-1
        cnt1--;
        cnt2--;
    }
    //检查两个票数符不符合
    cnt1 = cnt2 = 0;
    for (int num : nums) {
        if (num == cand1) {
            cnt1++;
        } else if (num == cand2) {  
    //这里一定要用else if，因为可能出现[0,0,0]这种用例，导致两个cand是一样的，写两个if结果就变为[0,0]了
            cnt2++;
        }
    }
    int n = nums.length;
    if (cnt1 > n / 3) {
        res.add(cand1);
    }
    if (cnt2 > n / 3) {
        res.add(cand2);
    }
    return res;
    }

6. 题号9：回文数

解法一：
转成字符串，反转字符串，与与原字符串进行比较
或用atChar【】
解法二：
计算长度，x/长度，得到首位数字，与x%10得到的末尾数字进行比较，不一样就返回false
解法三：
精髓 while (x > revertedNumber)，提升运行速度与节省空间
class Solution {
   public boolean isPalindrome(int x) {
       //思考：这里大家可以思考一下，为什么末尾为 0 就可以直接返回 false
       if (x < 0 || (x % 10 == 0 && x != 0)) return false;
       int revertedNumber = 0;
       while (x > revertedNumber) {
           revertedNumber = revertedNumber * 10 + x % 10;
           x /= 10;
       }
       长度为单数/10，去除中位数，长度偶数直接比较即可
       return x == revertedNumber || x == revertedNumber / 10;
   }
}

7. 题号27：移除元素

双指针，快慢指针
本质将所有符合条件的数放到最前面
方法一：
快慢指针都从索引0开始，快指针遍历数组，每找到一个要保留的的元素，将值赋给慢指针，慢指针+1
public int removeElement(int[] nums, int val) {
    int i = 0;
    for (int j = 0; j < nums.length; j++) {
        if (nums[j] != val) {   //如果不删除
            nums[i] = nums[j];
            i++;
        }
    }
    return i;
}
方法二：
一个指针从0开始，另一个指针从数组末尾开始，如果第一个指针元素要删除，将末尾指针值赋给首指针，尾指针-1。再次判断首指针是否符合条件。
注意边界条件！！！首指针小于尾指针，不是小于length
class Solution {
    public int removeElement(int[] nums, int val) {
        int n = nums.length;
        int i = 0;
         while(i<n){
             if(nums[i] == val){
                 nums[i] = nums[n-1];
                 n--;
             }else{
                 i++;
             }
         }
         return i;
    }
}

8. 题号12：整数转罗马数字

贪心算法，选尽可能大的罗马数字。
方法一：
将每个数字用罗马数字表现出来，当num大于当前罗马数字，加入StringBuilder中，直至小于当前罗马数字，与下个罗马数字进行比较。
int[] values = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};    
String[] symbols = {"M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"};

public String intToRoman(int num) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < values.length && num >= 0; i++) {
        while (values[i] <= num) {
            num -= values[i];
            sb.append(symbols[i]);
        }
    }
    return sb.toString();
}
方法二：
将100-900,1-9用罗马数字表示出来，直接选取对应的罗马数字
public String intToRoman(int num) {
    
    String[] thousands = {"", "M", "MM", "MMM"};
    String[] hundreds = {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"}; 
    String[] tens = {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"};
    String[] ones = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
    
    return thousands[num / 1000] + hundreds[num % 1000 / 100] + tens[num % 100 / 10] + ones[num % 10];
}

9. 题号13：罗马数字转整数

左边数字小于右边为减，大于为加。s.charAt(i)，选取对应索引的字符串，利用switch找出对应的数据大小。
import java.util.*;

class Solution {
    public int romanToInt(String s) {
        int sum = 0;
        int preNum = getValue(s.charAt(0));
        for(int i = 1;i < s.length(); i ++) {
            int num = getValue(s.charAt(i));
            if(preNum < num) {
                sum -= preNum;
            } else {
                sum += preNum;
            }
            preNum = num;
        }
        sum += preNum;
        return sum;
    }
    
    private int getValue(char ch) {
        switch(ch) {
            case 'I': return 1;
            case 'V': return 5;
            case 'X': return 10;
            case 'L': return 50;
            case 'C': return 100;
            case 'D': return 500;
            case 'M': return 1000;
            default: return 0;
        }
    }
}

10. 题号121：买卖股票的最佳时机

min记录历史最低点，max记录最大收益，遍历数组，如果当天价格小于最低点就替换，如果大于最低值就计算收益，再与最大值比较决定的是否替换最大值

public int maxProfit(int prices[]) {
        int minprice = Integer.MAX_VALUE;
        int maxprofit = 0;
        for (int i = 0; i < prices.length; i++) {
            if (prices[i] < minprice) {
                minprice = prices[i];
            } else if (prices[i] - minprice > maxprofit) {
                maxprofit = prices[i] - minprice;
            }
        }
        return maxprofit;
    }