剑指offer 算法 （时间效率）

题目描述

数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。

解析：保存数组首个数字，计数值置一，然后遍历整个数组。遇到相同的数组，计数值加一，遇到不同的数字，计数值减一，当计数值减到零时，用当前数组数字替换保存的数字，再继续进行比较，以此类推，比较直到数组尾。因为重复出现的数字次数超过数组长度一半，因此结果保存的数字即为所求数组数字

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
    	if(isValidArray(numbers))
            return 0;
        int num;//保存数
        int cnt;//计次数
        int length=numbers.size();
        num=numbers[0];
        cnt=1;
        for(int i=1;i<length;i++)
        {
            if(num==numbers[i])
                cnt++;
            else
            {
                cnt--;
                if(cnt==0)
                {
                    num=numbers[i];
                    cnt=1;
                }
            }
        }
        if(isHalfArray(numbers,num))
            return num;
        else
        	return 0;
    }
    bool isValidArray(vector<int> numbers)
    {
        if(numbers.size()==0)
            return true;
        else
            return false;
    }
    bool isHalfArray(vector<int> numbers,int num)
    {
        int length=numbers.size();
        int cnt=0;
        for(int i=0;i<length;i++)
        {
            if(num==numbers[i])
                cnt++;
        }
        if(cnt >= length/2)
            return true;
        else
            return false;
    }
};

题目描述

输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。

解析：以最小堆的方式调整数组排序，此时，树根节点即为最小值，每求出一个最小值，下次进行排序时去掉树根节点进行排序，以此类推，依次求出每一次的最小值

class Solution {
public:
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        vector<int> res;
        if(k > input.size()) 
            return res;
        for(int i = 0; i < k; i++){
            heapSort(input,i,input.size());
            res.push_back(input[i]);
        }
        return res;
    }
     
    void heapSort(vector<int> &input, int root, int end){//堆排序  
        for(int j = end - 1; j > root; j--)
        {
            int parent = (j - 1 - root) / 2 + root;//parent=（j-1）/2
            if(input[parent] > input[j])
            {//交换
                input[parent] += input[j];
                input[j] = input[parent] - input[j];
                input[parent] -= input[j];
            }
        }
    }
};

题目描述

HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。你会不会被他忽悠住？
解析：累加：若累加和小于当前值，说明应从当前值开始累加；每次累加时比较替换最大累加值

class Solution {
public:
    int FindGreatestSumOfSubArray(vector<int> array) {
    	int length=array.size();
        if(length > 0)
        {
            int sum=array[0];
            int max=array[0];
            for(int i=1;i<length;i++)
            {
         		sum+=array[i];
                if(sum<array[i])
                    sum=array[i];
                if(max<sum)
                    max=sum;
            }
            return max;
        }
        return 0;
    }
};

题目描述

求出1~13的整数中1出现的次数,并算出100~1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数。

解析：

方法一：末尾为1时对10取余等于1，因此，对每个数依次取余并除十再取余，直到为零。累加得结果

方法二：

同理分析4位数，5位数。。。。。
设N = abcde ,其中abcde分别为十进制中各位上的数字。
如果要计算百位上1出现的次数，它要受到3方面的影响：百位上的数字，百位一下（低位）上的数字，百位一上（高位）上的数字。
如果百位上数字为0，百位上可能出现1的次数由更高位决定。比如：12013，则可以知道百位出现1的情况可能是：100~199，1100~1199,2100~2199，，.........，11100~11199，一共1200个。可以看出是由更高位数字（12）决定，并且等于更高位数字（12）乘以 当前位数（100）。
如果百位上数字为1，百位上可能出现1的次数不仅受更高位影响还受低位影响。比如：12113，则可以知道百位受高位影响出现的情况是：100~199，1100~1199,2100~2199，，.........，11100~11199，一共1200个。和上面情况一样，并且等于更高位数字（12）乘以 当前位数（100）。但同时它还受低位影响，百位出现1的情况是：12100~12113,一共114个，等于低位数字（113）+1。
如果百位上数字大于1（2~9），则百位上出现1的情况仅由更高位决定，比如12213，则百位出现1的情况是：100~199,1100~1199，2100~2199，...........，11100~11199,12100~12199,一共有1300个，并且等于更高位数字+1（12+1）乘以当前位数（100）。                                                                                                                 综合以上三种情况，当百位对应0或>=2时，有(a+8)/10次包含所有100个点，还有当百位为1(a%10==1)，需要增加局部点b+1
 之所以补8，是因为当百位为0，则a/10==(a+8)/10，当百位>=2，补8会产生进位位，效果等同于(a/10+1)

class Solution {
public:
    int NumberOf1Between1AndN_Solution(int n)
    {
    	int sum=0;
        for(int i=1;i<=n;i++)
            sum+=count(i);
        return sum;
    }
    int count(int n)
    {
        int cnt=0;
        while(n)
        {
            if(n%10==1)
            	cnt++;
            n=n/10;
        }
        return cnt;
    }
};

class Solution {
public:
    int NumberOf1Between1AndN_Solution(int n)
    {
    	int cnt = 0;
    	int i = 1;
    	for(i = 1;i <= n;i = i*10)
    	{
        	int a = n / i , b = n % i ;
        	cnt = cnt + ( a + 8 ) / 10 * i + ( a % 10 == 1 ) * ( b + 1 ) ;
    	}
    	return cnt;
    }
};

题目描述

输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。

解析：把数组每个数字转换为字符串，比较后重新排序

class Solution {
public:
    static bool compare( const string &st1,const string &st2){
        string s1 = st1+st2;
        string s2 = st2+st1;
        return s1<s2;
    }
    string PrintMinNumber(vector<int> numbers) {
         string result;
        if(numbers.size()<=0){
            return result;
        }
        vector<string> strNum;
        for(int i=0;i<numbers.size();i++ ){
           stringstream ss;
            ss<<numbers[i];
            string s = ss.str();
            strNum.push_back(s);
        }
        sort(strNum.begin(),strNum.end(),compare);
        
        for(int i=0;i<strNum.size();i++){
            result.append(strNum[i]);
        }
        return result;
         
    }
};