劍指offer（九）

41. 把數組排成最小的數

方法的本質是排序，但是排序標準改爲在前面的做高位得到的數小；由於冒泡寫起來簡單就用了冒泡，就時間複雜度而言還是應該用快排。

class Solution {
public:
    string PrintMinNumber(vector<int> numbers) {
        if(numbers.size()<=0) return "";
        vector<string> str;
        for(int i=0;i<numbers.size();i++)
            str.push_back(to_string(numbers[i]));
        
        for(int i=str.size()-1;i>0;i--){
            for(int j=0;j<i;j++){
                if(compare(str[j]+str[j+1],str[j+1]+str[j]))
                    swap(str,j,j+1);
            }
        }
        string res="";
        for(int i=0;i<str.size();i++){
            res=res+str[i];
        }
        return res;
    }
private:
    int compare(string str1,string str2){
        for(int i=0;i<str1.size();i++){
            if((str1[i]-'0')>(str2[i]-'0'))
                return 1;
            else if((str1[i]-'0')<(str2[i]-'0'))
                return 0;
        }
        return 0;
    }
    void swap(vector<string>& str,int i,int j){
        string temp=str[i];
        str[i]=str[j];
        str[j]=temp;
    }
};

調用sort的方法，一樣的方法，只是這個排序函數自己不用寫。

class Solution {
public:
    string PrintMinNumber(vector<int> numbers) {
        if(numbers.size()<=0) return "";
        vector<string> str;
        for(int i=0;i<numbers.size();i++)
            str.push_back(to_string(numbers[i]));

        sort(str.begin(),str.end(),compare);
        string res="";
        for(int i=0;i<str.size();i++){
            res=res+str[i];
        }
        return res;
    }
private:
    static bool compare(string str01,string str02){
        string str1=str01+str02;
        string str2=str02+str01;
        for(int i=0;i<str1.size();i++){
            if((str1[i]-'0')>(str2[i]-'0'))
                return false;
            else if((str1[i]-'0')<(str2[i]-'0'))
                return true;
        }
        return true;
    }
};

42. 醜數

書上的方法，使得每次判斷的都是醜數，省去大量無用判斷

class Solution {
public:
    int GetUglyNumber_Solution(int index) {
        if(index<1) return 0;
        if(index==1) return 1;
        vector<int> ugly={1};

        int x2=0,x3=0,x5=0;
        while(index>1 ){
            int min=Min(ugly[x2]*2,ugly[x3]*3,ugly[x5]*5);
            ugly.push_back(min);
            while(ugly[x2]*2<=ugly.back()) x2++;
            while(ugly[x3]*3<=ugly.back()) x3++;
            while(ugly[x5]*5<=ugly.back()) x5++;
            index--;
        }
        return ugly.back(); 
    }
private:
    int Min(int num1,int num2,int num3){
        int min=(num1<num2)?num1:num2;
        min=(min<num3)?min:num3;
        return min;
    }
};

43. 第一個只出現一次的字符

哈希表的方法，map和unordered map的用法一樣，目前不清楚兩者的區別，只知道map是紅黑樹，會自動排序。

class Solution {
public:
    int FirstNotRepeatingChar(string str) {
        if(str.size()<=0) return -1;
        unordered_map<char, int> mp;
        for(int i=0;i<str.size();i++)
            mp[str[i]]++;

        for(int i=0;i<str.size();i++){
            if(mp[str[i]]==1) return i;
        }
        return -1;
    }
};

44. 字符流中第一個不重複的字符

class Solution
{
public:
  //Insert one char from stringstream
    void Insert(char ch)
    {
        //保存順序，保證按順序讀取。
        if(mp[ch]==0) ins.push_back(ch);
        mp[ch]++;
    }
  //return the first appearence once char in current stringstream
    char FirstAppearingOnce()
    {
        for(int i=0;i<ins.size();i++){
            if(mp[ins[i]]==1) return ins[i];
        }
        return '#';
    }
private:
    map<char,int> mp;
    vector<char> ins;
};

45. 數組中的逆序對

歸併算法的思路，在歸併的過程中計算逆序對。
剛開始不通過，以爲是代碼的問題，看了他人的代碼後發現是將count 定義爲int，而數據量過大超出了它的範圍，改爲long型就可以運行通過了

class Solution {
public:
    int InversePairs(vector<int> data) {
        if(data.size()<=1) return 0;
        merge(data,0,data.size()-1);
        return count%1000000007;
    }
private:
    long count=0;
    void merge(vector<int>& data,int begin,int end){
        if(begin>=end) return;
        int mid=begin+(end-begin)/2;
        merge(data,begin,mid);
        merge(data,mid+1,end);
        helper(data,begin,mid,end);
        
    }
    void helper(vector<int>& data,int begin,int mid,int end){
        int lefts=mid-begin+1,rights=end-mid;
        const int N=2147483647;
        vector<int> left;
        vector<int> right;
        for(int i=begin;i<=mid;i++) left.push_back(data[i]);
        left.push_back(N);
        for(int i=mid+1;i<=end;i++) right.push_back(data[i]);
        right.push_back(N);
        int i=0,j=0;
        for(int m=begin;m<=end;m++){
            if(left[i]<=right[j])
                data[m]=left[i++];

            else{
                data[m]=right[j++];
                count+=lefts-i;
            }
        }
    }
};