ベクトルの使用とシミュレーションの実装
ベクトルの紹介
- 最初に説明した文字列とは異なり、vector はクラスではなくクラス テンプレートであり、<type> でインスタンス化された後のクラスです。
- ベクトルは、可変サイズの配列を表すシーケンス コンテナーです。
- array と同様に、vector も要素を格納するために連続的な記憶領域を使用しますが、その容量は動的に変更できます。
- 他のコンテナと比較して、要素へのベクターアクセス、末尾の挿入、末尾の削除は効率的ですが、末尾以外の挿入や削除の効率は相対的に低いため、頻繁に挿入や削除が必要な場合にはベクターの使用は推奨されません。
ベクトル共通インターフェース
1. 構造
関数宣言 | 関数 |
---|---|
Vector() (一般的に使用されます) | パラメータ構築なし |
ベクトル (size_type n, const value_type& val = value_type()) |
n 個の値を構築して初期化する |
ベクトル (const ベクトル& x)(常用) | コピー構築 |
ベクトル (InputIterator が最初、InputIterator が最後) | イテレータ範囲の初期化 (テンプレート、他のコンテナに渡せるイテレータ範囲) |
2. イテレータ
関数宣言 | 関数 |
---|---|
begin() と end() (一般的に使用されます) | 最初のデータ位置の iterator/const_iterator を取得、最後のデータの次の位置の iterator/const_iterator を取得 |
rbegin() と rend() | 逆反復子、最後のデータ位置の reverse_iterator を取得、最初のデータの前の位置の reverse_iterator を取得 |
3. 容量
関数宣言 | 関数 |
---|---|
size() (一般的に使用されます) | データ数を取得する |
容量() | コンテナ容量を取得する |
空の() | 空かどうかを判断します(サイズが0の場合は空、trueを返します) |
サイズ変更(サイズタイプ n, 値タイプ val = 値タイプ()) | 1. n>size() の場合、コンテナがいっぱいになるまで val を端から埋めます; 2. n> 容量の場合、最初に拡張してから埋めます; 3. n<size() の場合、size() を減らし、最初のN。 |
予約(size_t n = 0) | スペースを予約し、n が容量より大きい場合は拡張し、それ以外の場合は何も行わない |
4. 追加、削除、確認、変更
関数宣言 | 関数 |
---|---|
Push_back (const value_type& val)(常用) | テールプラグ |
Pop_back() (一般的に使用されます) | 末尾削除 |
find (InputIterator が最初、InputIterator が最後、const T& val) | これはベクトル インターフェイスではなく、アルゴリズム ライブラリのテンプレートです。反復子の範囲を渡すと、この範囲で val を検索できます。 |
insert (イテレータの位置、const value_type& val) | 位置の前に val を挿入します |
消去 (イテレータの位置) | その位置のデータを削除します |
スワップ (ベクトル& x) | 2 つのベクトルのデータ空間を交換する |
演算子[] (サイズタイプ n) | 配列のようにデータにアクセスする |
5. 練習する
トピックの要件:
答え:
class Solution
{
public:
int singleNumber(vector<int>& nums)
{
//这个题需要异或这个位运算
//异或是相同为0,不同为1。
//所以两个相同的数异或会得到0
//0和任何数异或都得到这个数本身
//题目明确了只有一个数出现一次,其它都出现两次
//因此我们可以把所有数异或一次,出现两次的数字会抵消变成0
//最后出现一次的数字一定可以留下来
int end = 0;
vector<int>::iterator it = nums.begin();
//auto it = nums.begin();
while(it != nums.end())
{
end ^= *it;
it++;
}
//范围for同理
// for(auto ch : nums)
// end ^= ch;
return end;
}
};
トピックの要件:
答え:
class Solution {
public:
int removeDuplicates(vector<int>& nums)
{
int sum = 1;
int slow = 1;
int fast = 1;
//快慢指针
while(fast < nums.size())
{
if(nums[fast] > nums[fast-1])
{
nums[slow++] = nums[fast++];
sum++;
}
else
{
fast++;
}
}
return sum;
}
};
トピックの要件:
答え:
class Solution {
public:
vector<vector<int>> generate(int numRows)
{
vector<vector<int>> vv;
//把size调整为numRows
vv.resize(numRows);
for(int i = 0; i < numRows; i++)
{
vv[i].resize(i+1,0);
//每一行最后一个和第一个初始为1
vv[i][0] = vv[i][vv[i].size()-1] = 1;
}
for(int i = 0; i < numRows; i++)
{
for(int j = 0; j < vv[i].size(); j++)
{
if(vv[i][j] == 0)
vv[i][j] = vv[i-1][j] + vv[i-1][j-1];
}
}
return vv;
}
};
ベクトルシミュレーションの実装
1. イテレータの無効化
イテレータの主な機能は、アルゴリズムが基礎となるデータ構造を考慮しないようにすることであり、ベクトル イテレータの基礎となる層は実際には ポインタ です。コンテナに対する操作 (挿入、削除、変更など) の後、以前に取得したイテレータは変更される可能性があります。
その反復子を無効にする可能性のある操作は次のとおりです。
- サイズ変更、予約、挿入、プッシュバックなど、基になる空間に変更を引き起こす操作 (拡張) によりイテレータが失敗する可能性があります。
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
#include <vector>
int main()
{
vector<int> v{
1,2,3,4,5,6 };
auto it = v.begin();
// 将有效元素个数增加到100个,多出的位置使用8填充,操作期间底层会扩容
// v.resize(100, 8);
// reserve的作用就是改变扩容大小但不改变有效元素个数,操作期间可能会引起底层容量改变
// v.reserve(100);
// 插入元素期间,可能会引起扩容,而导致原空间被释放
// v.insert(v.begin(), 0);
// v.push_back(8);
// 给vector重新赋值,可能会引起底层容量改变
v.assign(100, 8);
/*
出错原因:以上操作,都有可能会导致vector扩容,也就是说vector底层旧空间被释放掉,
而在打印时,it还使用的是释放之间的旧空间,在对it迭代器操作时,实际操作的是一块已经被释放的
空间,而引起代码运行时崩溃。
解决方式:在以上操作完成之后,如果想要继续通过迭代器操作vector中的元素,只需给it重新
赋值即可。
*/
while (it != v.end())
{
cout << *it << " ";
++it;
}
cout << endl;
return 0;
}
- 指定した位置の要素の削除操作–erase
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
#include <vector>
int main()
{
vector<int> v{
1,2,3,4,5,6 };
//earse不会影响底层的空间(不进行扩容和缩容)
//但是也存在迭代器失效的问题
//下面这段代码用来删除v中的偶数
auto it = v.begin();
while (it != v.end())
{
if (*it % 2 == 0)
{
//把这个位置数据删除掉
v.erase(it);
}
it++;
}
//结果:程序崩溃
//原因:看图解,erase是会改变end()的
//解决方法:每次erase操作后都及时更新迭代器
//erase会返回被删除数据下一位置的迭代器
//auto it = v.begin();
//while (it != v.end())
//{
// if (*it % 2 == 0)
// {
// //把这个位置数据删除掉
// it = v.erase(it);
// }
// else
// {
// it++;
// }
//}
return 0;
}
2. 逆反復子
ベクトルの逆反復子の実現は難しくなく、通常の反復子を再利用するだけでよく、++ 演算は通常の反復子の ++ を呼び出す –, – になります。
// 反向迭代器需要进行封装,其实就是复用普通迭代器,然后++和--操作反过来
//这里设计模板参数除了迭代器,还有Ref(引用)和Ptr(指针)
//这样设计是为了同时生成普通迭代器和const对象的迭代器
//普通对象(可读可写):Reverse_iterator<iterator,T&,T*>
//const对象(可读不可写):Reverse_iterator<const_iterator,const T&,const T*>
template<class Iterator, class Ref, class Ptr>
struct Reverse_iterator
{
//给自己也重命名一下,方便用
typedef Reverse_iterator<Iterator, Ref, Ptr> self;
Iterator _it;
Reverse_iterator(Iterator it)
:_it(it)
{
}
self& operator++()
{
_it--;
return *this;
}
self operator++(int)
{
self tmp(*this);
_it--;
return tmp;
}
self& operator--()
{
_it++;
return *this;
}
self operator--(int)
{
self tmp(*this);
_it++;
return tmp;
}
Ref operator*()
{
return *_it;
}
//返回指针可以让自定义类型自行打印,访问成员
//->操作符,比较特殊,it->_num转换出来其实是it.operator->()->_num
Ptr operator->()
{
return _it;
}
bool operator!=(const self& s)
{
return _it != s._it;
}
bool operator==(const self& s)
{
return _it == s._it;
}
};
3. 完全なコード
基になる空間を維持するために 3 つの反復子 (ポインター) が使用されます。
private:
iterator _start = nullptr;
iterator _finish = nullptr;
iterator _endofstorage = nullptr;
#pragma once
#include<iostream>
#include<assert.h>
//#include<vector>
using namespace std;
//和库里面的区分开
namespace MyVector
{
// 反向迭代器需要进行封装,其实就是复用普通迭代器,然后++和--操作反过来
//这里设计模板参数除了迭代器,还有Ref(引用)和Ptr(指针)
//这样设计是为了同时生成普通迭代器和const对象的迭代器
//普通对象(可读可写):Reverse_iterator<iterator,T&,T*>
//const对象(可读不可写):Reverse_iterator<const_iterator,const T&,const T*>
template<class Iterator, class Ref, class Ptr>
struct Reverse_iterator
{
//给自己也重命名一下,方便用
typedef Reverse_iterator<Iterator, Ref, Ptr> self;
Iterator _it;
Reverse_iterator(Iterator it)
:_it(it)
{
}
self& operator++()
{
_it--;
return *this;
}
self operator++(int)
{
self tmp(*this);
_it--;
return tmp;
}
self& operator--()
{
_it++;
return *this;
}
self operator--(int)
{
self tmp(*this);
_it++;
return tmp;
}
Ref operator*()
{
return *_it;
}
//返回指针可以让自定义类型自行打印,访问成员
//->操作符,比较特殊,it->_num转换出来其实是it.operator->()->_num
Ptr operator->()
{
return _it;
}
bool operator!=(const self& s)
{
return _it != s._it;
}
bool operator==(const self& s)
{
return _it == s._it;
}
};
//vector类模板
template <typename T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
typedef Reverse_iterator<iterator, T&, T*> reverse_iterator;
typedef Reverse_iterator< const_iterator, const T&,const T*> reverse_const_iterator;
iterator begin()
{
//隐式类型转换
return _start;
}
iterator end()
{
return _finish;
}
const_iterator begin()const
{
return _start;
}
const_iterator end()const
{
return _finish;
}
reverse_iterator rbegin()
{
return _finish-1;
}
reverse_iterator rend()
{
return _start-1;
}
reverse_const_iterator rbegin()const
{
return _finish-1;
}
reverse_const_iterator rend()const
{
return _start-1;
}
//
/
//无参构造
vector()
{
}
//函数模板,传入容器的一段迭代器区间
template <typename InputIterator>
vector(InputIterator first, InputIterator last)
{
while (first != last)
{
push_back(*first);
first++;
}
}
//构造
vector(const vector<T>& v)
{
//提前开好空间
reverse(v.capacity());
for (auto& e : v)
{
push_back(e);
}
}
vector(size_t n, const T& val = T())
{
reverse(n);
for (size_t i = 0; i < n; i++)
{
push_back(val);
}
}
//重载给内置类型使用
//没有的话vector<int> v(5,0)会优先和vector(InputIterator first, InputIterator last)匹配
//对整形解引用会报错
vector(int n, const T& val = T())
{
reverse(n);
for (int i = 0; i < n; i++)
{
push_back(val);
}
}
~vector()
{
delete[] _start;
_start = _finish = _endofstorage = nullptr;
}
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_endofstorage, v._endofstorage);
}
//传值传参,拷贝一份,直接交换操作的空间即可
vector<T>& operator=(vector<T> v)
{
swap(v);
return *this;
}
///
///
void reverse(size_t n)
{
if (n > capacity())
{
//这里扩容空间会变化,先记录size
//这里扩容空间会变化,先记录size
//这里扩容空间会变化,先记录size
size_t sz = size();
T* tmp = new T[n];
//这里涉及到深浅拷贝
for (size_t i = 0; i < sz; i++)
{
tmp[i] = _start[i];
}
delete[] _start;
_start = tmp;
_finish = _start + sz;
_endofstorage = _start + n;
}
}
void resize(size_t n, const T& val = T())
{
if (n <= size())
{
_finish = _start + n;
}
else
{
//先扩容
reverse(n);
while (_finish < _start + n)
{
*_finish = val;
_finish++;
}
}
}
T& operator[](size_t pos)
{
assert(pos < size());
return _start[pos];
}
const T& operator[](size_t pos)const
{
assert(pos < size());
return _start[pos];
}
size_t capacity()const
{
return _endofstorage - _start;
}
size_t size()const
{
return _finish - _start;
}
/// ///
void push_back(const T& x)
{
//复用即可
insert(end(), x);
}
void insert(iterator pos, const T& x)
{
assert(pos <= _finish && pos >= _start);
if (_finish == _endofstorage)
{
size_t gap = pos - _start;
//初始扩容需要指定给
reverse(capacity() == 0 ? 4 : 2 * capacity());
pos = _start + gap;
}
iterator end = _finish;
while (end > pos)
{
*end = *(end - 1);
end--;
}
*pos = x;
_finish++;
}
iterator erase(iterator pos)
{
assert(pos < _finish&& pos >= _start);
iterator it = pos + 1;
while (it < _finish)
{
*(it - 1) = *it;
it++;
}
_finish--;
return pos;
}
private:
iterator _start = nullptr;
iterator _finish = nullptr;
iterator _endofstorage = nullptr;
};
}