刷题数组

最新推荐文章于 2022-08-21 12:56:09 发布

我秃了，也变强了

最新推荐文章于 2022-08-21 12:56:09 发布

阅读量177

点赞数 1

分类专栏：刷题

本文链接：https://blog.csdn.net/qq_31467305/article/details/99706249

版权

刷题专栏收录该内容

9 篇文章 0 订阅

订阅专栏

文章目录

1.数组中出现次数超过一半的数字（剑指offer 39）

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

解题思路：
1.采用直观遍历数组的解法O(N) 当要求不修改数组时采用此方法

首选假如有一个数字的次数超过数组长度的一半，则其出现的次数比其他所有元素次数和要多。故记录两个值：一个是遍历数组的元素数字，一个是次数。
当数字改变时，次数减一，当次数减为0时，将数字改变为当前指针指向的元素并初始化次数为1，一直到数组遍历结束，得到一个次数大于等一的元素数字。
最终对该数字检验是否出现次数大于一半，再次遍历数组统计出现次数与数组长度比较即可。

2.当没有要求不能修改数组时可以采用快速排序partition的思路。数组某数字出现次数超过一半，则已排序数组的中值一定为该数字。将每次返回的元素下标与数组中间下标比较，当相等时，即找到该数字。参考下一题

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        if(numbers.size()==0)
            return 0;
        int n=numbers.size();
        int res,times=0;
        for(int i=0;i<n;i++)
        {
            if(times==0)
            {
                res=numbers[i];
                times=1;
            }
            else if(res==numbers[i])
                times++;
            else 
                times--;
        }
        int max_len=0;
        for(int i=0;i<n;i++)
        {
            if(numbers[i]==res)
                max_len++;
        }
        if(2*max_len>n)
             return res;
        return 0;
    }
};

2.数组中的第K个最大元素（leetcode 215）

题目描述：
在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。
解题思路：
采用快速排序partition思路，数组第K个最大的元素，将每次返回的元素下标与（数组元素个数-k）比较，缩短搜索范围。
当partition返回的下标等于（数组元素个数-k）时，即找到该元素。
最优时间复杂度O(N) 最坏O(N^2)
空间复杂度O(1)

class Solution {
public:
    int partition(vector<int>& nums,int start,int end)
    {
        if(start>end)
            return -1;
        int tmp=start;
        int i=start;
        int j=start+1;
        for(;j<=end;j++)
        {
            if(nums[j]<nums[tmp])
            {
                swap(nums[i+1],nums[j]);
                ++i;
            }
        }
        swap(nums[tmp],nums[i]);
        return i;
    }
    
    
    int findKthLargest(vector<int>& nums, int k) {
        if(nums.size()==0)
            return -1;
        int start=0;
        int end=nums.size()-1;
        int index=partition(nums,start,end);
        while(index!=(nums.size()-k) && start<=end)
        {
            if(index>(nums.size()-k))
            {
                end=index-1;
                index=partition(nums,start,end);
            }
            else
            {
                start=index+1;
                index=partition(nums,start,end);
            }
        }
        if(index==(nums.size()-k))
           return nums[index];
        
        return -1;

    }
};

3.最小的k个数（剑指offer 40）

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

思路1：
同上partation思路。

class Solution {
public:
    int partition(vector<int>& nums,int start,int end)
    {
        int tmp=start;
        int i=start;
        int j=start+1;
        for(;j<=end;j++)
        {
            if(nums[j]<nums[tmp])
            {
                swap(nums[i+1],nums[j]);
                ++i;
            }
        }
        swap(nums[tmp],nums[i]);
        return i;
    }
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        if(input.size()==0 || k<0 ||k>input.size())
            return {};
        vector<int> res;
        int start=0;
        int end=input.size()-1;
        int index=partition(input,start,end);
        while(index!=k && start<=end)
        {
            if(index>k)
            {
                end=index-1;
                index=partition(input,start,end);
            }
            else
            {
                start=index+1;
                index=partition(input,start,end);
            }
        }
        for(int i=0;i<k;i++)
        {
            res.push_back(input[i]);
        }
        return res;
    }
};

思路2
利用红黑树的查找特性 O(logK) multiset实现总时间复杂度O(Nlongk)

此解法适合海量数据的输入（由于内存有限不可能将所有数据都存入内存而此方法只要保证内存足够容纳k即可而无需考虑n的大小）
且此解法不改变数组的结构

当multiset容器内部元素个数小于k时，向里面insert数据，直到数据个数为k。C++ multiset可以通过greater、less指定排序方式，实现最大堆、最小堆功能，在头文件#include< functional > 中。
采用greater方式排序后，数据由大到小排列，最大值在容器头部。每遍历一个数据，就与头部最大值比较，若小于该最大值，就该头部数据去除，并将遍历到的数据insert容器，直到最后遍历结束，容器中保存最小的k个数。

class Solution {
public:
	vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
		if (input.size() == 0 || k<0 || k > input.size())
			return{};
		multiset<int,greater<int>> k_nums;
		for (int i = 0; i<input.size(); i++)
		{
			if (k_nums.size()<k)
			{
				k_nums.insert(input[i]);
			}
			else{
				multiset<int>::iterator iter = k_nums.begin();
				if (input[i]<*iter)
				{
					k_nums.erase(iter);
					k_nums.insert(input[i]);
				}
			}
		}
		vector<int> res(k);
		multiset<int>::iterator iter = k_nums.begin();
		for (int i = 0; i<k; i++)
		{
			cout << *iter << endl;
			res[i] = *iter;
			iter++;
		}
		return res;
	}
};

4.最长连续序列（leetcode 128）

题目描述：给定一个未排序的整数数组，找出最长连续序列的长度。要求算法的时间复杂度为 O(n)。
在这里插入图片描述
解题思路：

方法一：排序解法。时间复杂度O(NlogN)

将nums排序后。
依次遍历，若上一个值与当前值相等，继续遍历；若不相等，如果二值连续，计数值加一，否则跳出循环比较是否大于记录的最大序列值并更新。

class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
        if(nums.size()==0)
            return 0;
        sort(nums.begin(),nums.end());
        int longest=1;
        int current=1;
        for(int i=1;i<nums.size();i++)
        {
            if(nums[i]!=nums[i-1])
            {
                if(nums[i]-1==nums[i-1])
                    ++current;
                else
                {
                    longest= current>longest? current : longest;
                    current=1;
                }
            }
        }
        return max(longest,current);
        
    }
};

方法二：哈希表。

采用unorder_set记录所有nums中的值。
遍历数组，如果比当前值小于1的值不在数组中，搜索从该值开始是否有连续序列，while循环，采用count计数值来实现。
更新最长连续序列的值。

class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
        if(nums.size()==0)
            return 0;
        unordered_set<int> st(nums.begin(),nums.end());
        int res=1;
        for(auto c : nums)
        {
            if(st.find(c-1)==st.end())
            {
                int num=c+1;
                while(st.count(num))
                {
                    num++;
                }
                 res=max(num-c,res);    
            }  
        }

        return res;
    }
};

5.只出现一次的数字（leetcode 136）

在这里插入图片描述
解法一：哈希表，删除操作O(1) ，故总时间复杂度O(N)

将出现的数字插入哈希表
出现重复的删除
最终剩下只出现一次的

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        unordered_set<int> st;
        int ans;
        for(auto i : nums){
            if(st.count(i))  st.erase(i);
            else    st.insert(i);
        }
        for(auto j : st)  ans = j;
        return ans;
    }
};

解法二：排序+双指针 sort O(nlog(n)) 遍历 O(n) 总时间复杂度O(nlog(n))
排序后，移动双指针每次+2，若相邻两个数不相等则返回第一个数。

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

解法三：异或时间复杂度O（n）
任何数与自己相异或均为0，且存在可加性 (a+b)^(a+b)=(a ^a) ^(b ^ b) =0

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int res=nums[0];
        for(int i=1;i<nums.size();i++)
        {
            res^=nums[i];
        }
        return res;
    }
};