个人中心
gpt4 book ai didi

C++求两数之和并返回下标详解

转载 作者：qq735679552 更新时间：2022-09-27 22:32:09 29 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章C++求两数之和并返回下标详解由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

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

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

你可以按任意顺序返回答案.

示例:

输入：nums = [2,7,11,15], target = 9 。

输出：[0,1] 。

解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] .

ACM模式

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;
int main(){
     vector< int > nums{ 2, 7, 11, 13 }; //原数组
     vector< int > vec; //存放结果
     int target = 18;
     unordered_map< int , int > ump;
     for ( int i = 0; i < nums.size(); ++i){
         auto it = ump.find(target - nums[i]);
         if (it != ump.end()){
             vec.push_back(it->second); //将值插入vec中
             vec.push_back(i);
         }
         ump[nums[i]] = i; //键值对的存入
     }
     for ( int i = 0; i < vec.size(); ++i){
         cout << vec[i] << endl;
     }
}

核心代码模式

方法一：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Solution
{
public :
     vector< int > TwoSum(vector< int >&nums, int target)
     {
         int n = nums.size;
         for ( int i = 0; i < n - 1; ++i)
         {
             for ( int j = i + 1; j < n; ++j)
             {
                 if (nums[i] + nums[j] == target)  
                     return { i, j };
             }
         }
         return {};  //空的{}表示一个空的vector<int>
     }
};

使用vector需要添加头文件 。

?
1
2
#include <vector>
using namespace std;

创建vector

?
1
2
3
4
vector< int > nums; //不指定长度：
vector< int > nums(n); //指定长度为n：
vector< int > nums(10,1); //定义具有10个整型元素的向量，且给出的每个元素初值为1
                        //nums后面是括号()不是大括号{}

添加元素

直接从数组末端添加:

?
1
nums.push_back(1);

直接赋值给第i个位置:

?
1
nums[i] = 1;

删除元素

直接将数组长度减小，某种方式上删掉了后面i个:

?
1
nums.resize(nums.size-i);

删掉最后一个元素:

?
1
nums.pop_back();

其他

?
1
2
3
nums.size(); //获得长度
sort(nums.begin(),nums.end()); //排序(O(nlogn))
reverse(nums.begin(), nums.end()); //翻转
?
1
2
3
4
5
合并两个vector：合并nums1和nums2，并将合并后的数组赋值给nums
vector< int > nums1(m),nums2(n);
vector< int > nums;
nums.resize(m+n);
merge(nums1.begin(), nums1.end(),nums2.begin(),nums2.end(),nums);

方法二：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Solution {
public :
     vector< int > twoSum(vector< int >& nums, int target) {
         unordered_map< int , int >hashtable;    // 建立哈希表
         for ( int i=0;i<nums.size();++i){     //nums.size后面要带括号()
         // for(auto i:nums)  错误，因为只有知道i的类型才可以用auto
             auto it=hashtable.find(target-nums[i]); //返回类型是iterator迭代器
             if (it!=hashtable.end()){     // 查找it是否在hashtable里
                 return {it->second,i};   //first是键(key)，second是值(value)
                                         //hashtable[nums[i]]=i,first就是nums[i],second就是i
             }
             hashtable[nums[i]]=i;   //存入键值对。 hashtable(nums[i])=i;错误，是[]不是()
         }
         return {};
     }
};

C++求两数之和并返回下标详解

auto的使用

C++11中引入的auto主要有两种用途：自动类型推断和返回值占位.

1.自动类型推断 。

?
1
2
3
4
5
auto a;                 错误，没有初始化表达式，无法推断出a的类型
auto int a = 10;        错误，auto临时变量的语义在C++11中已不存在, 这是旧标准的用法。
auto a = 10;
auto c = 'A' ;
auto s( "hello" );

2.返回值占位 。

?
1
auto v = compose(2, 3.14);    v 的类型是 double

unordered_map

unordered_map的头文件 。

?
1
#include <unordered_map>

创建unordered_map容器:

?
1
2
3
4
unordered_map<string,string>umap;
//创建好了一个可存储 <string,string> 类型键值对的 unordered_map 容器
unordered_map< int , int >umap;
//第一个int是键，第二个int是值

unordered_map容器的成员方法 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
begin() //返回指向容器中第一个键值对的正向迭代器。
end()   //返回指向容器中最后一个键值对之后位置的正向迭代器。
find(key)   //查找以 key 为键的键值对，如果找到，则返回一个指向该键值对的正向迭代器；反之，则返回一个指向容器中最后一个键值对之后位置的迭代器（如果 end() 方法返回的迭代器）。
cbegin()和 begin() //功能相同，只不过在其基础上增加了 const 属性，即该方法返回的迭代器不能用于修改容器内存储的键值对。
cend()和 end() //功能相同，只不过在其基础上，增加了 const 属性，即该方法返回的迭代器不能用于修改容器内存储的键值对。
empty() //若容器为空，则返回 true；否则 false。
size()  //返回当前容器中存有键值对的个数。
max_size()  //返回容器所能容纳键值对的最大个数，不同的操作系统，其返回值亦不相同。
operator[key]   //该模板类中重载了 [] 运算符，其功能是可以向访问数组中元素那样，只要给定某个键值对的键 key，就可以获取该键对应的值。注意，如果当前容器中没有以 key 为键的键值对，则其会使用该键向当前容器中插入一个新键值对。
at(key) //返回容器中存储的键 key 对应的值，如果 key 不存在，则会抛出 out_of_range 异常。
count(key)  //在容器中查找以 key 键的键值对的个数。
equal_range(key)    //返回一个 pair 对象，其包含 2 个迭代器，用于表明当前容器中键为 key 的键值对所在的范围。
emplace()   //向容器中添加新键值对，效率比 insert() 方法高。
emplace_hint()  //向容器中添加新键值对，效率比 insert() 方法高。
insert()    //向容器中添加新键值对。
erase() //删除指定键值对。
clear()     //清空容器，即删除容器中存储的所有键值对。
swap()  //交换 2 个 unordered_map 容器存储的键值对，前提是必须保证这 2 个容器的类型完全相等。
bucket_count()  //返回当前容器底层存储键值对时，使用桶（一个线性链表代表一个桶）的数量。
max_bucket_count()  //返回当前系统中，unordered_map 容器底层最多可以使用多少桶。
bucket_size(n)  //返回第 n 个桶中存储键值对的数量。
bucket(key) //返回以 key 为键的键值对所在桶的编号。
load_factor()   //返回 unordered_map 容器中当前的负载因子。负载因子，指的是的当前容器中存储键值对的数量（size()）和使用桶数（bucket_count()）的比值，即 load_factor() = size() / bucket_count()。
max_load_factor()   //返回或者设置当前 unordered_map 容器的负载因子。
rehash(n)   //将当前容器底层使用桶的数量设置为 n。
reserve()   //将存储桶的数量（也就是 bucket_count() 方法的返回值）设置为至少容纳count个元（不超过最大负载因子）所需的数量，并重新整理容器。
hash_function() //返回当前容器使用的哈希函数对象。

查找元素是否存在

若有unordered_map <int, int> mp;查找x是否在map中

?
1
2
方法1:  若存在   mp.find(x) != mp.end()
方法2:  若存在   mp.count(x) != 0

类

c++中当定义类对象是指针对象时候，就需要用到 -> 指向类中的成员； 当定义一般对象时候时就需要用到 “.” 指向类中的成员。 例如:

?
1
2
3
4
class A
{　　
     public play();
}

如果定义如下:

A *p则使用：p->play(); 左边是结构指针.

A p 则使用：p.paly(); 左边是结构变量.

总结：

箭头（->）：左边必须为指针； 。

点号（.）：左边必须为实体.

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注我的更多内容！ 。

原文链接：https://blog.csdn.net/weixin_49358890/article/details/119118567 。

最后此篇关于C++求两数之和并返回下标详解的文章就讲到这里了,如果你想了解更多关于C++求两数之和并返回下标详解的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

29 4 0
文章推荐： 使用python 写一个静态服务(实战)
文章推荐： python适合人工智能的理由和优势
文章推荐： php 实现账号不能同时登陆的方法分析【当其它地方登陆时,当前账号失效】
文章推荐： python画图的函数用法以及技巧
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com