LeetCode in Python 200. Number of islands (岛屿数量)

mafa1993

 关注

阅读 8

2024-04-20

 向量（Vector）是一个封装了动态大小数组的顺序容器（Sequence Container）。跟任意其它类型容器一样，它能够存放各种类型的对象。可以简单的认为，向量是一个能够存放任意类型的动态数组。 

Vector的特点：

  • vector是表示可变大小数组的序列容器。
  • vector就像数组一样，也采用的连续空间来存储元素，这也意味着可以采用下标对vector的元素进行访问。
  • 普通数组相比，vector的大小可以在运行时自动调整，根据需要增加或减少容量。

  • 当vector需要重新分配大小时，其做法是，分配一个新的数组，然后将全部元素移到这个数组当中，并释放原来的数组空间。
  • vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因此存储空间比实际需要的存储空间一般更大。不同的库采用不同的策略权衡空间的使用和重新分配，以至于在末尾插入一个元素的时候是在常数的时间复杂度完成的。
  • 与其它动态序列容器相比（deque, list and forward_list）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起list和forward_list统一的迭代器和引用更好

需要包含头文件：#include<vector>

vector的构造

explicit vector (const allocator_type& alloc = allocator_type());	
explicit vector (size_type n, const value_type& val = value_type(),
                 const allocator_type& alloc = allocator_type());	
vector (InputIterator first, InputIterator last,
       const allocator_type& alloc = allocator_type());
vector (const vector& x);
//alloc: 分配器对象。容器保留并使用一个这种分配器的内部拷贝。成员类型allocator_type是容器使用的内部分配器类型，定义在vector中作为其第二个模板参数（Alloc）的别名。如果allocator_type是默认分配器的一个实例化（默认分配器没有状态），这不相关。
//n: 初始容器大小（即，在构造时容器中的元素数量）。成员类型size_type是一个无符号整型类型。
//val: 用来填充容器的值。容器中的每一个n元素将会初始化为这个值的一个拷贝。成员类型value_type是容器中元素的类型，定义在vector中作为其第一个模板参数（T）的别名。
//first, last: 指向范围内初始和最终位置的输入迭代器。使用的范围是[first, last]，其中包括所有first和last之间的元素，包括由first指向的元素但不包括由last指向的元素。函数模板参数InputIterator应该是一个输入迭代器类型，它指向可以构建value_type对象的元素类型。
//x: 另一个相同类型的vector对象（具有相同的类模板参数T和Alloc），其内容被复制或获取。
int main()
{   
    vector<int> v1; //构造int类型的空容器
    vector<int> v2(10, 2); //构造含有10个2的int类型容器
    vector<int> v3(v2); //拷贝构造int类型的v2容器的复制品
	vector<int> v4(v2.begin(), v2.end());//自己类型的迭代器进行初始化
	for (auto e : v4)
	{
		cout << e << " ";
	}
	cout << endl;
  string s1 = "GalaxyPokemon"; //其他容器的迭代器进行初始化
	vector<char> v5(s1.begin(), s1.end());
	for (auto e : v5)
	{
		cout << e << " ";
	}
	cout << endl;

	//还能用数组进行初始化，本质是指针，数组名代表首元素的地址
	int arr[] = { 1,2,3,4 };
	vector<int> v6(arr,arr+4);
	for (auto e : v6)
	{
		cout << e << " ";
	}
    return 0;
}

 

vector里面能存string吗？

单参数的构造函数支持隐式类型的转换

explicit vector (const allocator_type& alloc = allocator_type());	
explicit vector (size_type n, const value_type& val = value_type(),
                 const allocator_type& alloc = allocator_type());
vector (InputIterator first, InputIterator last,
                 const allocator_type& alloc = allocator_type());
vector (const vector& x);


// 创建一个空的vector。
std::vector<int> v;
//创建一个给定大小的vector，使用元素的默认构造函数初始化所有元素。
std::vector<int> v(10);
//创建一个给定大小的vector，并初始化所有元素为指定的值。
std::vector<int> v(10, 5); // 10个元素，每个都是5
//通过一对迭代器给定范围创建vector。
std::array<int, 5> arr = {1, 2, 3, 4, 5};
std::vector<int> v(arr.begin(), arr.end());
//通过另一个同类型vector创建一个新的vector的副本。
std::vector<int> original(10, 5);
std::vector<int> v(original);

不仅可以用自己类型的迭代器，还能用其他能匹配上的类型的迭代器，比如说string

int main()
{
	string s1 = "GalaxyPokemon";
	vector<int> v3(s1.begin(), s1.end());
	for (auto e : v3)
	{
		cout << e << " ";
	}
	return 0;
}

 

所以这样才是最准确的

int main()
{
	string s1 = "GalaxyPokemon";
	vector<char> v3(s1.begin(), s1.end());
	for (auto e : v3)
	{
		cout << e << " ";
	}
	return 0;
}

vector的元素访问

接口名称使用说明

operator[]

访问元素  下标 + [ ]

at

访问元素  下标 + ( )

front

访问第一个元素

back

访问最后一个元素

  operator[ ] 

reference operator[] (size_type n);
const_reference operator[] (size_type n) const;
//n：容器中元素的位置。注意，第一个元素的位置为0（不是1）。成员类型size_type是一个无符号整数类型。


int main()
{
	vector<int> v(5, 1);
	//使用“下标+[]”的方式遍历容器
	for (size_t i = 0; i < v.size(); i++)
	{
		cout << v[i] << " ";
	}
	cout << endl;
	return 0;
}

对于oparator[]来说，若是产生了一个越界访问的话就直接报出【断言错误】了 

at

reference operator[] (size_type n);
const_reference operator[] (size_type n) const;
//n：容器中元素的位置。注意，第一个元素的位置为0（不是1）。成员类型size_type是一个无符号整数类型。

int main()
{
	vector<int> v(5, 1);
	//使用“下标+()”的方式遍历容器
	for (size_t i = 0; i < v.size(); i++)
	{
		cout << v.at(i) << " ";
	}
	cout << endl;
	return 0;
}

 

front

reference operator[] (size_type n);
const_reference operator[] (size_type n) const;
//n：容器中元素的位置。注意，第一个元素的位置为0（不是1）。成员类型size_type是一个无符号整数类型。

int main()
{
	vector<int> v(5, 1);
	cout << v.front() << endl;
	return 0;
}

back 

 

reference operator[] (size_type n);
const_reference operator[] (size_type n) const;
//n：容器中元素的位置。注意，第一个元素的位置为0（不是1）。成员类型size_type是一个无符号整数类型。

int main()
{
	int arr[] = { 1,2,3,4 };
	vector<int> v(arr, arr + 4);
	cout << v.back() << endl;
	return 0;
}

范围for

vector是支持迭代器的，所以我们还可以用范围for对vector容器进行遍历。（支持迭代器就支持范围for，因为在编译时编译器会自动将范围for替换为迭代器的形式）

int main()
{
	vector<int> v(2, 10);
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;
	return 0;
}

 

vector及迭代器的操作

迭代器：

接口名称使用说明

       begin

返回指向第一个元素的迭代器

        end

返回指向最后一个元素的下一个位置的迭代器

      rbegin

返回指向最后一个元素的反向迭代器

       rend

返回指向第一个元素的前一个位置的反向迭代器

 这些接口的用法和迭代器用法类似，如果想了解更多可以去迭代器文章里面查看

begin和end

通过begin函数可以得到容器中第一个元素的正向迭代器，通过end函数可以得到容器中最后一个元素的后一个位置的正向迭代器。
正向迭代器遍历容器：

int main()
{
	vector<int> v(10, 2);
	//正向迭代器遍历容器
	vector<int>::iterator it = v.begin();
	while (it != v.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
	return 0;
}

rbegin和rend

通过rbegin函数可以得到容器中最后一个元素的反向迭代器，通过rend函数可以得到容器中第一个元素的前一个位置的反向迭代器。
反向迭代器遍历容器：

int main()
{
	vector<int> v(10, 2);
	//反向迭代器遍历容器
	vector<int>::reverse_iterator rit = v.rbegin();
	while (rit != v.rend())
	{
		cout << *rit << " ";
		rit++;
	}
	cout << endl;
	return 0;
}

二者都会对越界进行检查，at是抛异常，[]是断言， 断言更暴力一点

使用find查找3，并删除，如果有多个3应该怎么搞？

迭代器失效的问题，删除了第一个3之后，就会失效

在C++中，迭代器失效（Iterator invalidation）是指当容器发生某些修改操作（如添加、删除元素等）后，其迭代器不再指向有效的容器元素，或者不再有有效的行为。迭代器失效可能会导致未定义行为，包括访问无效内存，这在程序中可能会导致错误或崩溃。不同类型的容器对迭代器的失效规则各有不同：

1. vector和string

  • 添加元素：当通过push_back()或insert()向vector添加元素时，如果引发了重新分配（即容器当前的容量不足以容纳更多元素），则所有指向元素的迭代器、引用和指针都将失效。如果没有重新分配，那么只有指向插入点及之后元素的迭代器失效。
  • 删除元素：使用erase()删除vector或string中的元素会使从删除点开始到末尾的所有迭代器失效。

vector的常见容量接口 

函数名称

功能

       size

返回字符串有效字符长度

     resize

扩容+初始化

   capacity

返回分配的存储容量大小（即有效元素的最大容量）

     empty

检测字符串是否为空串，是返回true,否则返回false

    reserve

对容量进行改变

size

int main()
{
	vector<int> v(10, 1);
	cout << v.size() << endl;

    return 0;
}

 

resize

void resize (size_type n, value_type val = value_type());

【resize】的功能则是 开空间 + 初始化，并且填上默认值

 这一块我们要通过调试来进行观察

接着调用resize，看到调试窗口中的size发生了变化，而且新增了3个为0的数据值 

 

 

capacity

size_type capacity() const;

对于capacity来说，就是容量大小，这里可以看到其与capacity是一同增长的，也为10

int main()
{
	vector<int> v(10, 1);
	cout << v.size() << endl;
	cout << v.capacity() << endl;

	return 0;
}

下面我们来看一下【vector】的默认扩容机制

// 测试vector的默认扩容机制
void TestVectorExpand()
{
	size_t sz;
	vector<int> v;
	sz = v.capacity();
	cout << "making v grow:\n";
	for (int i = 0; i < 100; ++i)
	{
		v.push_back(i);
		if (sz != v.capacity())
		{
			sz = v.capacity();
			cout << "capacity changed: " << sz << '\n';
		}
	}
}

通过运行结果我们可以发现，在VS下的扩容机制是呈现 1.5 进行增长的

但是呢，在 Linux 下却始终是呈现的一个2倍的扩容机制 

empty

bool empty() const;
int main()
{
	vector<int> v;
	cout << v.empty() << endl;

	v.push_back(1);
	v.push_back(2);
	cout << v.empty() << endl;

	return 0;
}

当一开始进在初始化后是为空，但是在插入数据后就不为空了 

当size为 0 时，返回 1 

当size为 非0 时，返回 0

reserve

void reserve (size_type n);

它的主要功能是 开空间，避免频繁扩容 

int main()
{
	vector<int> v;
	size_t sz = v.capacity();
	v.reserve(100); // 提前将容量设置好，可以避免一遍插入一遍扩容
	cout << "making bar grow:\n";
	for (int i = 0; i < 100; ++i)
	{
		v.push_back(i);
		if (sz != v.capacity())
		{
			sz = v.capacity();
			cout << "capacity changed: " << sz << '\n';
		}
	}
	return 0;
}

 

 

相关推荐

[leetcode] 200. Number of Islands

孟佳 62 0 0

LeetCode: 200. Number of Islands

安七月读书 86 0 0

【LeetCode】200. 岛屿数量

水墨_青花 42 0 0

LeetCode 200. 岛屿数量

产品喵dandan米娜 36 0 0

LeetCode 200.岛屿数量

RJ_Hwang 47 0 0

200. Number of Islands

Sophia的玲珑阁 115 0 0

[LeetCode] Number of Islands 岛屿的数量

新鲜小饼干 61 0 0

200. 岛屿数量

外贸达人小峻先森 54 0 0

LeetCode 200. Number of Islands(并查集)

你的益达233 249 0 0

【图论】Leetcode 200. 岛屿数量【中等】

日月同辉9908 5 0 0

精彩评论（0）

0 0 举报