剑指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;
            }
        }
    }
};