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

编辑: admin 分类: c#语言 发布时间: 2022-03-15 来源:互联网
目录
  • 给定一个整数数组 nums 和一个整数目标值 target,请你在该数组中找出 和为目标值 target 的那 两个 整数,并返回它们的数组下标。
  • ACM模式
  • 核心代码模式
    • 方法一:
      • 创建vector
      • 添加元素
      • 删除元素
      • 其他
    • 方法二:
      • auto的使用
      • unordered_map
      • 查找元素是否存在
  • 总结:

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

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

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

    示例:

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

    输出:[0,1]

    解释:因为 nums[0] + nums[1] == 9 ,返回 [0, 1] 。

    ACM模式

    #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;
    	}
    }
    

    核心代码模式

    方法一:

    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需要添加头文件

    #include <vector> 
    using namespace std;
    

    创建vector

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

    添加元素

    直接从数组末端添加:

    nums.push_back(1);
    

    直接赋值给第i个位置:

    nums[i] = 1;
    

    删除元素

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

    nums.resize(nums.size-i);
    

    删掉最后一个元素:

    nums.pop_back();
    

    其他

    nums.size(); //获得长度
    sort(nums.begin(),nums.end()); //排序(O(nlogn))
    reverse(nums.begin(), nums.end()); //翻转
    
    合并两个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);
    

    方法二:

    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{};
        }
    };
    

    在这里插入图片描述

    auto的使用

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

    1.自动类型推断

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

    2.返回值占位

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

    unordered_map

    unordered_map的头文件

    #include <unordered_map>
    

    创建unordered_map容器:

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

    unordered_map容器的成员方法

    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:  若存在   mp.find(x) != mp.end()
    方法2:  若存在   mp.count(x) != 0
    

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

    class A
    {  
        public play();
    }
    

    如果定义如下:

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

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

    总结:

    箭头(->):左边必须为指针;

    点号(.):左边必须为实体。

    本篇文章就到这里了,希望能给你带来帮助,也希望您能够多多关注海外IDC网的更多内容!

    【转自:外国服务器 http://www.558idc.com/shsgf.html转载请说明出处】