今天刷了4道 LeetCode題，分別是：

1. 1-bit and 2-bit Characters ：

   We have two special characters. The first character can be represented by one bit 0. The second character can be represented by two bits (10 or 11).

   Now given a string represented by several bits. Return whether the last character must be a one-bit character or not. The given string will always end with a zero.
2. Add Strings ：bigInteger
3. Array Partition I ： Given an array of 2n integers, your task is to group these integers into n pairs of integer, say (a1, b1), (a2, b2), ..., (an, bn) which makes sum of min(ai, bi) for all i from 1 to n as large as possible.
4. Backspace String Compare ：Given two strings S
    and T, return if they are equal when both are typed into empty text editors. # means a backspace character.

對於第一題  1-bit and 2-bit Characters，難點在於需要仔細的分析問題的關鍵（思考過程需要從最後向前算，而且著重點在於找規律，如果找不出規律可以先舉例子再歸納; 思考過程也可以從頭向後看，需要分析的是，只要有1一定是2bit;）。

Solution1:從尾到頭開始分析。需要注意的是不會存在01的組合，因此和末尾的0相鄰的1出現的奇偶次數格外重要。

class Solution {
    public boolean isOneBitCharacter(int[] bits) {
        int length=bits.length;
        int count=0;
        if(bits[length-1]!=0){
            return false;
        }else{
            for(int i=length-2;i>=0 && bits[i]==1;i--){
                count++;
            }
        }
        if(count % 2 == 0){
            return true;
        }else{
            return false;
        }
    }
}
 

Solution2:從頭到尾分析，可以發現從頭起第一個0肯定是1bit，因為不會有01組合，那麼接下來出現的1肯定是2bit。那麼有一個方法就是設定一個指標來從頭開始，遇到0就向前走1步，遇到1就向前走2步。如果最後一個0是1bit，那麼指標會恰好停在0的index，如果最後一個0是2bit，那麼指標會大於最後一個0的index，即index+1；

class Solution {
    //這種方法很巧妙，需要在程式設計中學習並思考這種方法，pointer
    public boolean isOneBitCharacter(int[] bits) {
        int pointer=0;
        while(pointer<bits.length-1){
            pointer+=bits[pointer]+1;
        }
        return pointer==(bits.length-1);     
    }
}

對於第二題，Add Strings，大數加法；

Tip:如果直接輸出str.charAt(),可以正常輸出char字元，而不是ASCII碼；如果和字串相接，也是可以正常輸出char字元，而不是ASCII；只有一種情況，但是如果把str.charAt()即char型別當成int進行計算，那麼它將自動使用對應的ASCII來進行計算；比如'0'的ASCII為48；

Solution1:常規思維，先把兩個陣列倒序，長度短的後面補0。然後按index把每一位相加，結果保留，有進位的話在下一位相加時多加1，最後把這些字串連起來就是結果。

Solution2: 思維方法和上面相似，程式碼上可以更加精簡。不需要倒序，直接使用for迴圈倒著遍歷，並且合併兩個for迴圈到一個for迴圈上。最後有一點注意的是，每一位相加的結果  result%10 就是需要儲存的，result / 10就是代表是否需要進位的。

class Solution {
    public String addStrings(String num1, String num2) {
        int overFlow=0;
        StringBuffer res= new StringBuffer();
        for(int i=num1.length()-1,j=num2.length()-1;i>=0 || j>=0 || overFlow==1; i--,j--){
            int wei1= i<0 ? 0: num1.charAt(i)-'0';
            int wei2= j<0 ? 0: num2.charAt(j)-'0';
            int append= (wei1 + wei2 + overFlow) % 10;
            res.append(append);
            overFlow= (wei1 + wei2 + overFlow) / 10;
        }
        return res.reverse().toString();
        
    }
}

對於第三題，Array Partition I，實際上就是排序演算法，先把陣列排序後，取奇數index所對應的值的和就是最終結果。

我使用了快排。

class Solution {
    public int arrayPairSum(int[] nums) {
        quickSort(nums);
        int sum=0;
        for(int i=0;i<nums.length;i+=2){
            sum+=nums[i];
        }
        return sum;
    }
    public static void quickSort(int[] arr){
    qsort(arr, 0, arr.length-1);
}
private static void qsort(int[] arr, int low, int high){
    if (low < high){
        int pivot=partition(arr, low, high);        //將陣列分為兩部分
        qsort(arr, low, pivot-1);                   //遞迴排序左子陣列
        qsort(arr, pivot+1, high);                  //遞迴排序右子陣列
    }
}
private static int partition(int[] arr, int low, int high){
    int pivot = arr[low];     //樞軸記錄
    while (low<high){
        while (low<high && arr[high]>=pivot) --high;
        arr[low]=arr[high];             //交換比樞軸小的記錄到左端
        while (low<high && arr[low]<=pivot) ++low;
        arr[high] = arr[low];           //交換比樞軸小的記錄到右端
    }
    //掃描完成，樞軸到位
    arr[low] = pivot;
    //返回的是樞軸的位置
    return low;
}
}

對於第四題，Backspace String Compare ， 自己的想法是可以用棧的結構來做，但是結果執行速度不夠理想。然後使用了暴力法，發現速度比棧的做法快。

List<Character>  是char型別的List，List中的型別都必須是包裝類，不能為原始型別如char，int；
如果用原始型別會報錯：Syntax error, insert "Dimensions" to complete ReferenceType；

class Solution {
    
    public boolean backspaceCompare(String S, String T) {
        StringBuffer str1= new StringBuffer();
        StringBuffer str2= new StringBuffer();
        List<Character> results1=new ArrayList<Character>();
        List<Character> results2=new ArrayList<Character>();

        for(int i=0;i<S.length();i++){
            if(S.charAt(i) == '#'){
                pop(results1);
            }else{
                push(S.charAt(i),results1);
            }
        }
        for(int i=0;i<T.length();i++){
            if(T.charAt(i) == '#'){
                pop(results2);
            }else{
                push(T.charAt(i),results2);
            }
        }
        for(char c:results1){
            str1.append(c);
        }
        for(char c:results2){
            str2.append(c);
        }
        
        return str1.toString().equals(str2.toString());
    }
    
    public void push(char c,List results){
        results.add(c);
    }
    
    public void pop(List results){
        if(results.size()==0)
            return;
        results.remove(results.size()-1);
    }
    
}

方法2

class Solution {
    
    public boolean backspaceCompare(String S, String T) {
        int maxLength= S.length()>T.length() ? S.length() : T.length();
        StringBuffer str1=new StringBuffer();
        StringBuffer str2=new StringBuffer();

        for(int i=0;i<maxLength;i++){
            if(i<S.length()){
            if(S.charAt(i)=='#'){
                if(str1.length()!=0){
                  str1.deleteCharAt(str1.length()-1);
                }
            }else{
                str1.append(S.charAt(i));
            }
            }
            if(i<T.length()){
            if(T.charAt(i)=='#'){
                if(str2.length()!=0){
                  str2.deleteCharAt(str2.length()-1);
                }
            }else{
                str2.append(T.charAt(i));
            }
            }
        }
        
        return str1.toString().equals(str2.toString());
       
    }
    
}