2019.10.18刷题小结

三道剑指offer一道LeetCode。

1.数组中超过一半的数。

申请两个变量，一个代表当前出现次数最多的数字，一个代表相对出现的次数。分别初始化为数组第一个数和1.如果下一个数和当前数相同，次数++，否则次数--。如果次数减为0，那么就把当前数更新为此时遍历的数，次数初始化为1.

最后再遍历一遍数组此时保存的数是否出现次数超过一半。

int MoreThanHalfNum_Solution(vector<int> numbers) {
        if(numbers.size()<=0)
        {
            return 0;
        }
        int curnumber=numbers[0];
        int count=1;
        for(int i=1;i<numbers.size();i++)
        {
            if(numbers[i]==curnumber)
            {
                count++;
            }
            else
            {
                count--;
            }
            if(count<=0)
            {
                curnumber=numbers[i];
                count=1;
            }
        }
        int num=0;
        for(int i=0;i<numbers.size();i++)
        {
            if(numbers[i]==curnumber)
            {
                num++;
            }
        }
        if(numbers.size()/2<num)
        {
            return curnumber;
        }
        return 0;
    }

2.最小的K个数。

两种做法。第一种利用快排的思想，找到第K个位置。则左边的数即为最小的K个数。

第二种利用最大堆的概念，适合数据流。首先存储一个包含K个元素的堆。然后再来一个元素的话与堆顶进行比较，比堆顶小的话删除堆顶，把当前数加入进去即可。

typedef multiset<int,greater<int>>::iterator setit;
typedef multiset<int, greater<int>> se;
class Solution {
public:
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        vector<int>res;
        if(k<=0||input.size()<=0||input.size()<k)
        {
            return res;
        }
        if(input.size()==k)
        {
            return input;
        }
        se s;
        for(int i=0;i<input.size();i++)
        {
            if(s.size()<k)
            {
                s.insert(input[i]);
            }
            else 
            {
                setit it=s.begin();
                if(input[i]<*it)
                {
                    s.erase(it);
                    s.insert(input[i]);
                }
            }
        }
        setit it=s.begin();
        for(;it!=s.end();it++)
        {
            res.push_back(*it);
        }
        return res;
    }
};

3.连续数字最大和。

注意点：申请两个变量，一个当前和，一个当前最大值，分别初始化为0和INT_MIN（应对全是负数的情况，不能初始化为0）.

如果当前和小于等于0的话，就把此时的数组值赋值给当前和。

int FindGreatestSumOfSubArray(vector<int> array) {
        int sum=0;
        int res=INT_MIN;
        for(int i=0;i<array.size();i++)
        {
            if(sum<=0)
            {
                sum=array[i];
            }
            else
            {
                sum+=array[i];
                
            }
            if(sum>res)
                {
                    res=sum;
                }
        }
        return res;
    }

4.判断链表是否有环（比昨天还简单一点，让我偷个懒吧，导师一直在边上转来转去，不敢写别的了）

bool hasCycle(ListNode *head) {
        if(!head||!head->next)
        {
            return false;
        }
        ListNode *slow=head;
        ListNode *fast=head;
        while(fast||fast->next)
        {
            slow=slow->next;
            fast=fast->next->next;
            if(!fast||!fast->next)
            {
                return false;
            }
            if(fast==slow)
            {
                return true;
            }
        } 
    }