两数之和

题目描述：

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

 

示例：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]

输入：nums = [3,2,4], target = 6
输出：[1,2]

 

题解代码：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) 
    {
        int i, j;
        for(i = 0; i < nums.size(); ++i)
            for(j = i + 1; j < nums.size(); ++j)
                if(nums[i] + nums[j] == target)
                    return {i, j};

        return {};
    }
};　　　　//C++版本

int* twoSum(int* nums, int numsSize, int target, int* returnSize)
{
    int i, j;
    *returnSize = 2;
    int* result = (int*)malloc(sizeof(int)*2);
    for(i = 0; i < numsSize - 1; ++i)
        for(j = i + 1; j < numsSize; ++j)
        {
            if(nums[i] + nums[j] == target)
            {
                result[0] = i;
                result[1] = j;
                return result;
            }
        }

    return result;
}　　　　//C版本

 

遇到的一些问题：

（C版本）

　　之前创建动态数组的时候用new习惯了，不太熟悉malloc的用法。

　　其实不太明白为什么函数的参数中要给出returnSize（但发现如果将*returnSize=2注释掉后，会出错）（看了一些博文，returnSize其实就是返回数组的元素个数，至于为什么要用指针，是为了传递一个地址，把调用这个函数的原函数的相应参数做修改...后续应该会有更深入的认识）。

（C++版本）-----主要想了解一下vector的用法

 

简单了解vector

　　1.1 vector说明

• vector是向量类型，可以容纳许多类型的数据，因此也被称为容器
• （可以理解为动态数组，是封装好了的类）
• 进行vector操作前应添加头文件 #include <vector>

 

 

　　1.2 vector初始化

　　方式1

//定义具有10个整型元素的向量（尖括号为元素类型名，它可以是任何合法的数据类型），不具有初值

vector<int>a(10);

　　方式2

//定义具有10个整型元素的向量，且给出的每个元素初值为1

vector<int>a(10, 1);

　　方式3

//用向量b给向量a赋值，a的值完全等价于b的值

vector<int>a(b);

　　方式4

 //将向量b中从0-2（共三个）的元素赋值给a，a的类型为int型
 
 vector<int>a(b.begin(), b.begin()+3);

　　方式5

//从数组中获得初值

int b[7] = {1, 2, 3, 4, 5, 6, 7};
vector<int>a(b, b+7);

/*这里觉得很奇怪
        为什么是b.begin()+3而不是b.begin()+2？？
        为什么是b+7而不是b+6*/

//又查了一些博文，发现大家都是这么写的...或许以后会理解吧

int main()
{        
    int arr[] = {11, 32, 41, 25, 67, 100, 88, 233};
    vector<int> iv(arr+2, arr+7);
    for(auto c : iv)        //不会的知识点又增加了
        cout << c << " ";
    cout << endl;

    return 0;
}
　　//执行结果是41 25 67 100 88

　　

　　1.3 vector对象的常用内置函数使用

#include <vector>
vector<int> a, b;

//b为向量，将b的0-2个元素赋值给向量a
a.assign(b.begin(), b.begin()+3);

//a含有4个值为2的元素（会改变a的size,但capacity不会变）
a.assign(4, 2);

//返回a的最后一个元素
a.back();

//返回a的第一个元素
a.front();

//这里简单查了一下，back与end、front与begin的区别在于前者是引用，后者不是引用，但自己没有验证过

//返回a的第i个元素，当且仅当a存在
a[i]

//清空a中的元素
a.clear();

//判断a是否为空，空则返回true，非空则返回false
a.empty();

//删除a向量的最后一个元素
a.pop_back();

//删除a中第一个（从第0个算起）到第二个元素，共两个
a.erase(a.begin()+1, a.begin()+3);

//在a的最后一个向量后插入一个元素，其值为5
a.push_back(5);

//在a的第一个元素（从第0个算起）位置插入数值5
a.insert(a.begin()+1, 5);

//在a的第一个元素（从第0个算起）位置插入3个数，其值都为5
a.insert(a.begin()+1, 3, 5);

//b为数组，在a的第一个元素（从第0个元素算起）的位置插入b的第三个元素到第五个元素，不包括b+6
a.insert(a.begin()+1, b+3, b+6);

//返回a中元素的个数
a.size();

//返回a在内存中总共可以容纳的元素个数
a.capacity();

//将a的现有元素个数调整至10个，多则删，少则补，其值随机
a.resize(10);

//将a的现有元素个数调整至10个，多则删，少则补，其值为2
a.resize(10, 2);

//将a的容量扩容至100
a.reserve(100);

//b为向量，将a中的元素和b中的元素整体交换
a.swap(b);

//b为向量，向量的比较操作还有!= > >= <= <
a==b

　　学会区分size和capacity，简单理解貌似可以为 一个是实际size，一个是总size

 

　　2.顺序访问vector的几种方式

　　2.1对向量a添加元素的几种方式

　　方式1 向向量a中添加元素

vector<int> a;
for(int i = 0; i < 10; ++i)
    a.push_back(i);

　　

　　方式2 从数组中选择元素向向量中添加

int a[6] = {1, 2, 3, 4, 5, 6};
vector<int> b;
for(int i = 0; i <= 4; ++i)
    b.push_back(a[i]);

 

　　方式3 从现有向量中选择元素向向量中添加

int a[6] = {1, 2, 3, 4, 5, 6};
vector<int> b;
vector<int> c(a, a+4);
for(vector<int>::iterator it = c.begin(); it<c.end(); ++it)
    b.push_back(*it);

 

　　方式4 从文件中读取元素向向量中添加

ifstream in("data.txt");
vector<int> a;
for(int i; in >> i)
    a.push_back(i);

 

　　常见错误赋值方式

vector<int> a;
for(int i = 0; i < 10; ++i)
    a[i] = i;    //下标只能用来获取已经存在的元素，有评论说，失效的原因是没有分配空间，写成vector<int> a(10);就可以了，自己没试过

 

　　2.2 从向量中读取元素

　　方式1 通过下标方式获取

int a[6] = {1, 2, 3, 4, 5, 6};
vector<int> b(a, a+4);
for(int i = 0; i <= b.size()-1; ++i)
    cout << b[i] << endl;

　　

　　方式2 通过迭代器方式读取

int a[6] = {1, 2, 3, 4, 5, 6};
vector<int> b(a, a+4);
for(vector<int>::iterator it = b.begin(); it != b.end(); it++)
    cout << *it << endl;

 

　　3.几个常用的算法

#include <algorithm>

//对a中的从a.begin()（包括它）到a.end()（不包括它）的元素从小到大排列
/*如果要是从大到小排列，可以通过重写排序比较函数实现，如：
定义排序比较函数 bool Comp(const int& a, const int& b){return a>b;}
调用时，sort(a.begin(), a.end(), Comp);

sort(a.begin(), a.end());

//对a中的从a.begin()（包括它）到a.end()（不包括它）的元素倒置，但不排列，如a中元素为1,3,2,4,倒置后为4,2,3,1
reverse(a.begin(), a.end());

//把a中的从a.begin()（包括它）到a.end()（不包括它）的元素复制到b中，从b.begin()+1的位置（包括它）开始复制，覆盖掉原有元素
copy(a.begin(), a.end(), b.begin()+1);

//在a中的从a.begin()（包括它）到a.end()（不包括它）的元素中查找10，若存在返回其在向量中的位置
find(a.begin(), a.end(), 10);
/*这里有一个自己琢磨出来的用法
int main()
{
    int arr[] = { 11, 32, 41, 25, 67, 100, 88, 233 };
    vector<int> iv(10);
    iv.assign(arr, arr + 3);
    vector<int>::iterator m = find(iv.begin(), iv.end(), 32);
    cout << m[0] << endl;

    return 0;
}
输出结果为32，但这怎么知道它在向量中的位置呢？
不是很懂...
*/

 

好累o(╥﹏╥)o

2022-02-13