leecode172 -217

172. 阶乘后的零

class Solution {
public:
    int trailingZeroes(int n) {
       long int i=0;
        while(n)
        {
            i+=n/5;
            n=n/5;
        }
        return i;
    }
};

这里根据数据归纳法，发现10只能由2和5相乘得到，所以只需要数2和5得个数就可以了，但是又发现2得个数肯定是比5要大得，所以 我们只需要数5得个数就可以了，最重要得是i+=n/5这个是直接数的个数的。
189. 旋转数组

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int i,j;
        j=nums.size();
        reverse(nums.begin(),nums.end()-k%j);
        reverse(nums.end()-k%j,nums.end());
        reverse(nums.begin(),nums.end());
    }
};

这道题想法是自己想的，但是代码的实现还是看了discuss。第一步是吧移的个数之前的数字反装，第二部是将移动的数字反转，第三部是整体反转就可以了。

198. 打家劫舍

class Solution {
public:
    int rob(vector<int>& nums) {
        if(nums.size()==0)
        return 0;
        if(nums.size()==1)
        return nums[0];
        int n=nums.size();
        vector<int>dp (nums.size(), 0);
        dp[0]=nums[0];
        dp[1]=max(nums[0],nums[1]);
        for(int i=2;i<nums.size();i++)
        {
            dp[i]=max(dp[i-2]+nums[i],dp[i-1]);
        }
        return dp[nums.size()-1];
    }
};

显然的动态规划，因为还要考虑后面的问题，贪心算法在这里并不适应。

202. 快乐数``

class Solution {
public:
    bool isHappy(int n){
	int ans;
	for(int i=0;i<8;i++)
	{
		ans=0;
		while(n)
		{
			ans+=(n%10)*(n%10);
			n=n/10;
		}
		n=ans;
		if(n==1)
		return true;
	}
	return false;
}

这道题用了暴力的思想，每次循环的ans=0注意每次要清零。

203. 移除链表元素

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        if(head==NULL)
        return head;
         while (head != NULL && head->val == val)
            head = head->next;
        ListNode *p=head;
        if(p)    //每次循环之前要判断p是不是空的。
        {
            while(p->next)
            {
                if(p->next->val==val)
                {
                    p->next= p->next->next;
                }
                else
                p=p->next;
            }
        }
        return head;
    }
};

204. 计数质数

class Solution {
public:
   int countPrimes(int n) {
    int count = 0;
    //初始默认所有数为质数
    vector<bool> signs(n, true);
    for (int i = 2; i < n; i++) {
        if (signs[i]) {
            count++;
            for (int j = i + i; j < n; j += i) {
                //排除不是质数的数
                signs[j] = false;//这里false得值为1
            }
        }
    }
    return count;
}
};

这道题用了厄拉多塞筛法，没啥好说的学习就行了。

205. 同构字符串

class Solution {
public:
    bool isIsomorphic(string s, string t) {
        vector<int>a(256,-1);
        vector<int>b(256,-1);
       for(int i=0;i<s.size();i++)
       {
           a[s[i]]=i;
           b[t[i]]=i;
       }
       for(int i=0;i<s.size();i++)
       {
           if(a[s[i]]!=  b[t[i]])
           return false; 
       }
       return true;
    }
};

记录重复字母的最后一次出现的位置，这种方法需要思考一会，方法很巧妙。还有一种方法。

class Solution {
public:
    bool isIsomorphic(string s, string t) {
        int i;
        for(i=0;i<s.size();i++)
        {
            if(s.find(s[i])!=t.find(t[i]))
            return false;
        }
        return true;
    }
};

用了c++的find函数不过这种代码看似简介，不过是用时间换空间。
206. 反转链表

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
       ListNode *p=head;
       ListNode *q=NULL;
       while(p)
       {
           ListNode *r=p;
           p->next=q;
           q=r;
           p=r;
       }
       return q;
    }
};

用了头插的方法重新构建了一个链表。

217. 存在重复元素

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
       sort(nums.begin(),nums.end());
       if(nums.size()==0)
       return false;
       {
           for(int i=0;i<nums.size()-1;i++)
           {
               if(nums[i]==nums[i+1])
               return true;
           }
       }
       return false;
    }
};

排序然后再判断。
总结
leecode刷了也已经有了50道题了，已经对代码有了初步的感觉，还需要再接再厉，明天去搞懂哈希表。奥里给！