算法题汇总

主要用c++实现

vector函数：

1.push_back 在数组的最后添加一个数据
2.pop_back 去掉数组的最后一个数据
3.at 得到编号位置的数据
4.begin 得到数组头的指针
5.end 得到数组的最后一个单元+1的指针
6.front 得到数组头的引用
7.back 得到数组的最后一个单元的引用
8.max_size 得到vector最大可以是多大
9.capacity 当前vector分配的大小
10.size 当前使用数据的大小
11.resize 改变当前使用数据的大小，如果它比当前使用的大，则填充默认值
12.reserve 改变当前vecotr所分配空间的大小
13.erase 删除指针指向的数据项
14.clear 清空当前的vector
15.rbegin 将vector反转后的开始指针返回(其实就是原来的end-1)
16.rend 将vector反转构的结束指针返回(其实就是原来的begin-1)
17.empty 判断vector是否为空
18.swap 与另一个vector交换数据

一、数组

旋转数组

将包含 n 个元素的数组向右旋转 k 步。

例如，如果 n = 7 , k = 3，给定数组 [1,2,3,4,5,6,7] ，向右旋转后的结果为 [5,6,7,1,2,3,4]。

思路：一是需要申请一个新的数组存数据，二是要取余，确定前进步数。

代码：

#include <iostream>
#include <vector>
using namespace std;


class Solution {
public:
    void solution(vector<int>& nums, int k) {
        vector<int> t=nums;
        for(int i=0;i<nums.size();i++){
            nums[(i+k)%nums.size()] =t[i];
        }
    }
};

int main(){
    Solution solution1;
    vector<int> arr={1,2,3,4,5,6,7};
    solution1.solution(arr,3);

    vector<int>::iterator it;//声明一个迭代器，来访问vector容器，作用：遍历或者指向vector容器的元素
    for(it=arr.begin();it!=arr.end();it++)
    {
        cout<<*it<<" ";
    }
    return 0;

}

从排序数组中删除重复项

给定一个有序数组，你需要原地删除其中的重复内容，使每个元素只出现一次,并返回新的长度。

不要另外定义一个数组，您必须通过用 O(1) 额外内存原地修改输入的数组来做到这一点。

思路：判断是否重复，没有重复的数据放在原数组，并重新定义下标。最后重置数组大小。

代码：

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        if(nums.empty())  
        {  
            return 0;  
        }
          
        int n = nums.size(),k=0;  
        for(int i=1;i<n;++i)  
        {  
            if(nums[i] != nums[k])  
            {  
                nums[++k] = nums[i];  
            }//if  
        }//for  
        nums.resize(k+1);  
        return k+1;  
    }
}

买卖股票的最佳时机 II

假设有一个数组，它的第 i 个元素是一个给定的股票在第 i 天的价格。

设计一个算法来找到最大的利润。你可以完成尽可能多的交易（多次买卖股票）。然而，你不能同时参与多个交易（你必须在再次购买前出售股票）。

思路:因为必须买和卖才能获取利润，所以只需确保买卖的时候有利润，就可以实现利润最大

class Solution {
public:
    int maxProfit(vector<int>& prices) {
   int t = prices.size(),nums=0,d;
            for(int j=0;j<t;j++){
                d =prices[j+1] - prices[j];
               if(d>0){
                   nums +=d;
               }
            }

        return nums;
    }
};

存在重复

给定一个整数数组，判断是否存在重复元素。

如果任何值在数组中出现至少两次，函数应该返回 true。如果每个元素都不相同，则返回 false。

思路：循环判断

#include <iostream>
#include <vector>
using namespace std;


class Solution {
public:
    bool solution(vector<int>& nums) {
        for(int i = 0;i<nums.size()-1;++i){
            for(int j = i;j<nums.size();++j){
                if(i!=j){
                    if(nums[i]==nums[j]){
                        return true;
                    }
                }
            }
        }
        return false;
    }
};

int main(){
    Solution solution1;
    vector<int> arr={1,2,1,4,5,6,7};
    bool res =solution1.solution(arr);

    cout <<res;
    return 0;

}

只出现一次的数字

给定一个整数数组，除了某个元素外其余元素均出现两次。请找出这个只出现一次的元素。

思路：复制一个数组，循环比较，如不相同的次数是长度-1，那这个就是唯一的，否则不相同次数应该为长度-2。。。。

代码：

#include <iostream>
#include <vector>
using namespace std;


class Solution {
public:
    int solution(vector<int>& nums) {
        vector<int> t=nums;
        for(int i =0;i<nums.size();++i){
            int sum = 0;
            for(int j=0;j<nums.size();++j){
                    if(nums[i]!=t[j]){
                        sum++;
                    }
            }
            if(sum ==nums.size()-1){
                return nums[i];
            }

        }
    }
};

int main(){
    Solution solution1;
    vector<int> arr={2,4,6,6,2,7,7};
    int res =solution1.solution(arr);

    cout<<res;
    return 0;

}

科学算法：

要用到异或.

思路：遍历数组，异或得到的就是与其他都不一样的数

代码：

#include <iostream>
#include <vector>
using namespace std;


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

int main(){
    Solution solution1;
    vector<int> arr={2,4,6,6,2,7,7};
    int res =solution1.solution(arr);

    cout<<res;
    return 0;

}

两个数组的交集 II

给定两个数组，写一个方法来计算它们的交集。

例如:
给定 nums1 = [1, 2, 2, 1], nums2 = [2, 2], 返回 [2, 2].

注意：

输出结果中每个元素出现的次数，应与元素在两个数组中出现的次数一致。
我们可以不考虑输出结果的顺序。
跟进:

如果给定的数组已经排好序呢？你将如何优化你的算法？
如果 nums1 的大小比 nums2 小很多，哪种方法更优？
如果nums2的元素存储在磁盘上，内存是有限的，你不能一次加载所有的元素到内存中，你该怎么办？

思路：遍历数组，以某个数组为标准，当相同的时候，把数据放入新数组，将有交集的数从另外一个数组删除掉，然后继续比较。

代码：

#include <iostream>
#include <vector>

using namespace std;

template <class T>
int getArrayLen(T& array)  //使用模板定义一个函数getArrayLen,该函数将返回数组array的长度
{
    return (sizeof(array) / sizeof(array[0]));
}
class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        vector<int> nums3;
        int k=0,i=0,j=0;
        vector<int>::iterator it;
        for(i=0;i<nums1.size();i++){
                for(it=nums2.begin();it!=nums2.end();it++)
                {
                    if(nums1[i] == *it){
                        nums3.push_back(nums1[i]);
                        nums2.erase(it);
                        break;
                    }
                }
        }
        return nums3;
    }
};

int main(){
    Solution solution;
    vector<int> arr1={1,2,2,1};
    vector<int> arr2={2,2};
    vector<int> res =solution.intersect(arr1,arr2);
    vector<int>::iterator it;
    for(it=res.begin();it!=res.end();it++)
    {
        cout<<*it<<" ";
    }
    return 0;

}

加一

给定一个非负整数组成的非空数组，在该数的基础上加一，返回一个新的数组。

最高位数字存放在数组的首位， 数组中每个元素只存储一个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

示例 1:

输入: [1,2,3]
输出: [1,2,4]
解释: 输入数组表示数字 123。

示例 2:

输入: [4,3,2,1]
输出: [4,3,2,2]
解释: 输入数组表示数字 4321。

一开始没看懂题目的意思，，就是一个整数，按高位到低位（百十个），比如123,1是百位，由它开始，放入数组，组成
[‘1’,2,3],然后这个整数加1，得到124，[1,2,4],然后返回[1,2,4]。感觉这道题有点怪。

思路：

代码：