剑指offer 算法 （时间空间效率的平衡）

题目描述

把只包含因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。

解析：根据丑数的定义，丑数应该是另一个丑数乘以2、3或者5的结果（1除外）。因此我们可以创建一个数组，里面的数字是排好序的丑数。里面的每一个丑数是前面的丑数乘以2、3或者5得到的。那关键就是确保数组里的丑数是有序的了。我们假设数组中已经有若干个丑数，排好序后存在数组中。我们把现有的最大丑数记做M。现在我们来生成下一个丑数，该丑数肯定是前面某一个丑数乘以2、3或者5的结果。我们首先考虑把已有的每个丑数乘以2。在乘以2的时候，能得到若干个结果小于或等于M的。由于我们是按照顺序生成的，小于或者等于M肯定已经在数组中了，我们不需再次考虑；我们还会得到若干个大于M的结果，但我们只需要第一个大于M的结果，因为我们希望丑数是按从小到大顺序生成的，其他更大的结果我们以后再说。我们把得到的第一个乘以2后大于M的结果，记为M2。同样我们把已有的每一个丑数乘以3和5，能得到第一个大于M的结果M3和M5。那么下一个丑数应该是M2、M3和M5三个数的最小者

class Solution {
public:
    int GetUglyNumber_Solution(int index) {
    	if(index<=0)
            return 0;
        int numUgly=1;
        vector<int> ugly;
        ugly.push_back(1);
        int u2=0,u3=0,u5=0;
        vector<int> *ugly2=&ugly;
        vector<int> *ugly3=&ugly;
        vector<int> *ugly5=&ugly;
        while(numUgly<index)
        {
            ugly.push_back(min((*ugly2)[u2]*2,(*ugly3)[u3]*3,(*ugly5)[u5]*5));
            while((*ugly2)[u2]*2 <= ugly[numUgly])
                u2++;
            while((*ugly3)[u3]*3 <= ugly[numUgly])
                u3++;
            while((*ugly5)[u5]*5 <= ugly[numUgly])
                u5++;
            numUgly++;
        }
        return ugly[index-1];
    }
    int min(int num1,int num2,int num3)
    {
        num1=num1<num2?num1:num2;
        return num1<num3?num1:num3;
    }
};

题目描述

在一个字符串(1<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符的位置。若为空串，返回-1

解析：建立简单的哈希表，存每个字符出现的次数，之后遍历求出首个符合要求位置

class Solution {
public:
    int FirstNotRepeatingChar(string str) {
        if(str.empty())
		return -1;
        int const num=256;
        //int *cnt=new int[num];//很奇怪 不知道为什么这样动态建立数组就不对？？
        //memset(cnt,0,256);
        int cnt[256]={0};
        int cur=0;
        while(str[cur] != '\0')
        {
            cnt[str[cur++]]++;
        }
        cur=0;
        while(str[cur] != '\0')
        {
            if(cnt[str[cur++]] == 1)
                return --cur;
        }
        //delete []cnt;
        return -1;
    }
};

题目描述

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。

解析：用一个辅助数组保存比0~8大的数的数量。遍历每个数时累加既得结果

class Solution {
public:
    int InversePairs(vector<int> data) {
        //针对的数据为0~9之间
        vector<int> a(9,0);
        int cnt=0;
        for(int i=0;i<data.size();i++)
        {
            cnt+=a[data[i]];
            for(int j=data[i]-1;j>=0;j--)
            {
                a[j]++;
            }
        }
        return cnt;
    }
};

题目描述

输入两个链表，找出它们的第一个公共结点。

解析：由于两个链表有公共结点，两条链必从公共结点开始合并为一链。即从链尾开始的话两链表重合到公共结点。即去除两链表长度差开始遍历的话，当两节点相等，即为公共结点。

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    int lengthList(ListNode* head)
    {
        ListNode* node=head;
        int length=0;
        while(node!=NULL)
        {
            length++;
            node=node->next;
        }
        return length;
    }
    ListNode* FindFirstCommonNode( ListNode *pHead1, ListNode *pHead2) {
        int length1=lengthList(pHead1);
        int length2=lengthList(pHead2);
        if(length1==0 || length2==0)
            return NULL;
        ListNode* longList=pHead1;
        ListNode* shortList=pHead2;
        int diflength=length2>length1?length2-length1:length1-length2;
        if(length1<length2)
        {
            longList=pHead2;
            shortList=pHead1;
        }
        //长链表先走diflength步
        while(diflength--)
        {
            longList=longList->next;
        }
        while(shortList!=NULL)
        {
            if(longList ==shortList)
                return longList;
            longList=longList->next;
            shortList=shortList->next;
        }
        return NULL;

    }
};