【STL】线性容器与非线性容器

最新推荐文章于 2024-05-09 18:02:09 发布

打打打劫

最新推荐文章于 2024-05-09 18:02:09 发布

阅读量454

点赞数

分类专栏：开发语言文章标签： c++

本文链接：https://blog.csdn.net/weixin_45093118/article/details/103261164

版权

开发语言专栏收录该内容

19 篇文章 1 订阅

订阅专栏

1. stack容器

1.1 基本概念

stack是一种先进后出(First In Last Out,FILO)的数据结构。
stack容器允许新增元素，移除元素，取得栈顶元素，但是除了最顶端外，没有任何其他方法可以存取stack的其他元素。即stack不允许有遍历行为。
由于无法遍历，只能访问栈顶元素，因此不提供迭代器。

1.2 常用API

stack构造函数

stack<T> stkT;//stack采用模板类实现， stack对象的默认构造形式： 
stack(const stack &stk);//拷贝构造函数

stack赋值操作

stack& operator=(const stack &stk);//重载等号操作符

stack数据存取操作

push(elem);//向栈顶添加元素
pop();//从栈顶移除第一个元素
top();//返回栈顶元素

stack大小操作

empty();//判断堆栈是否为空
size();//返回堆栈的大小

void test01()
{
	//1.容器构造
	stack<int> s1;
	stack<int> s2(s1);
	//2.赋值操作
	s1 = s2;
	//3.数据存取及大小
	s1.push(10);
	s1.push(20);
	s1.push(30);
	s1.push(40);
	s1.push(50);

	cout << s1.size() << endl;

	while (s1.empty() != 1)
	{
		cout << s1.top() <<" ";
		s1.pop();
	}
	cout << endl;
	cout << s1.size() << endl;
}

2. queue容器

2.1 基本概念

Queue是一种先进先出(First In First Out,FIFO)的数据结构
queue容器有两个出口，queue容器允许从一端新增元素，从另一端移除元素。只能访问头部和尾部数据，因此无法遍历。
由于无法遍历，只能访问队列头部和尾部元素，因此不提供迭代器。

2.2 常用API

queue构造函数

queue<T> queT;//queue采用模板类实现，queue对象的默认构造形式：
queue(const queue &que);//拷贝构造函数

queue存取、插入和删除操作

push(elem);//往队尾添加元素
pop();//从队头移除第一个元素
back();//返回最后一个元素
front();//返回第一个元素

queue赋值操作

queue& operator=(const queue &que);//重载等号操作符

queue大小操作

empty();//判断队列是否为空
size();//返回队列的大小

void test02()
{
	//1.构造容器
	queue<int> q1;
	queue<int> q2(q1);
	//2.赋值
	q1 = q2;
	//3.数据插入
	q1.push(10);
	q1.push(20);
	q1.push(30);
	q1.push(40);
	q1.push(50);
	cout << q1.size() << endl;
	//4.数据存区及大小
	while (q1.empty() != 1)
	{
		cout << q1.front() << " ";
		cout << q1.back() << " ";
		q1.pop();
	}
	cout << endl;
	cout << q1.size() << endl;
}

3. list容器

3.1 基本概念

list容器本质就是双向循环链表链表，其含有链表的所有属性。
list迭代器：由于list容器本质是链表，因此无法实现随机访问。
（1）List容器不能像vector一样以普通指针作为迭代器，因为其节点不能保证在同一块连续的内存空间上。
（2）List迭代器必须有能力指向list的节点，并有能力进行正确的递增、递减、取值、成员存取操作。

3.2 常用API

list构造函数

list<T> lstT;//list采用采用模板类实现,对象的默认构造形式：
list(beg,end);//构造函数将[beg, end)区间中的元素拷贝给本身。
list(n,elem);//构造函数将n个elem拷贝给本身。
list(const list &lst);//拷贝构造函数。

list数据元素插入和删除操作

push_back(elem);//在容器尾部加入一个元素
pop_back();//删除容器中最后一个元素
push_front(elem);//在容器开头插入一个元素
pop_front();//从容器开头移除第一个元素
insert(pos,elem);//在pos位置插elem元素的拷贝，返回新数据的位置。
insert(pos,n,elem);//在pos位置插入n个elem数据，无返回值。
insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值。
clear();//移除容器的所有数据
erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。
erase(pos);//删除pos位置的数据，返回下一个数据的位置。
remove(elem);//删除容器中所有与elem值匹配的元素。

list大小操作

size();//返回容器中元素的个数
empty();//判断容器是否为空
resize(num);//重新指定容器的长度为num，
//若容器变长，则以默认值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除。
resize(num, elem);//重新指定容器的长度为num，
//若容器变长，则以elem值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除。

list赋值操作

assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将n个elem拷贝赋值给本身。
list& operator=(const list &lst);//重载等号操作符
swap(lst);//将lst与本身的元素互换。

list数据的存取

front();//返回第一个元素。
back();//返回最后一个元素。

list的反转与排序与删除
（1）排序时须自定义排序顺序。
（2）删除时须重载==操作符。


class Person 
{
public:
	string name;
	int age;
	int hignt;
	Person(string name, int age, int height)
	{
		this->name = name;
		this->age = age;
		this->hignt = height;
	}
	bool operator== (const Person& p)
	{
		if (this->name == p.name && this->age == p.age && this->hignt == p.hignt)
		{
			return true;
		}
		return false;
	}
};

void foreachList(list<Person> & p)
{
	for (list<Person>::iterator it = p.begin(); it != p.end(); it++)
	{
		cout << "name: " << (*it).name << "age:" << (*it).age << "hignt" << (*it).hignt << endl;
	}
}

bool myCompare(Person& p1, Person& p2)
{
	if (p1.age == p2.age)
	{
		return p1.hignt > p2.hignt;
		
	}
	return p1.age > p2.age;
}
void test01()
{
	//1.建立容器
	list<Person> p;
	Person p1 = { "aaa", 10, 200 };
	Person p2 = { "bbb", 30, 300 };
	Person p3 = { "ccc", 20, 500 };
	Person p4 = { "ddd", 20, 300 };
	Person p5 = { "eee", 50, 100 };
	//2.插入
	p.push_back(p1);
	p.push_back(p2);
	p.push_back(p3);
	p.push_back(p4);
	p.push_back(p5);

	//3.遍历
	foreachList(p);
	cout << "---------------------" << endl;
	//4.反转
	p.reverse();
	foreachList(p);
	//5.排序
	p.sort(myCompare);
	foreachList(p);
	//6.删除
	p.remove(p1);
	foreachList(p);
}

4. set容器

4.1 基本概念

set容器的特点是，在数据插入set容器时都会自动的根据键(key)值自动的排序.
（1）set的元素既是键值又是实值，因此Set不允许两个元素有相同的键值，否则将无法区别键值；
（2）set迭代器也不允许修改数据，因为会破坏已经排好的顺序；
set容器的数据进行删除和插入时，同list容器相同，即操作之前所有的迭代器在操作完成之后依然有效。
multiset容器特性及用法和set完全相同，唯一的差别在于它允许键值重复。

4.2 平衡二叉树

set和multiset的底层实现是红黑树，红黑树为平衡二叉树的一种。
搜索二叉树：是指二叉树中的节点按照左-根-右的升序规则进行排序，使得对二叉树中元素访问更加高效。
平衡二叉树：树的左子树与右子树高度之差不大于1，树的子数也需要满足该规则。

4.3 常用API

set构造函数

set<T> st;//set默认构造函数：
mulitset<T> mst; //multiset默认构造函数: 
set(const set &st);//拷贝构造函数

set赋值操作

set& operator=(const set &st);//重载等号操作符
swap(st);//交换两个集合容器

set大小操作

size();//返回容器中元素的数目
empty();//判断容器是否为空

set插入和删除操作

insert(elem);//在容器中插入元素。
clear();//清除所有元素
erase(pos);//删除pos迭代器所指的元素，返回下一个元素的迭代器。
erase(beg, end);//删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
erase(elem);//删除容器中值为elem的元素。

set查找操作

find(key);//查找键key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
count(key);//查找键key的元素个数
lower_bound(keyElem);//返回第一个key>=keyElem元素的迭代器。
upper_bound(keyElem);//返回第一个key>keyElem元素的迭代器。
equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器。

void foreachSet(set<int> s)
{
	for (set<int>::iterator it = s.begin(); it != s.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	//1.创建迭代器
	set<int> s;
	//2.插入数据
	s.insert(10);
	s.insert(30);
	s.insert(20);
	s.insert(50);
	s.insert(40);
	//3.遍历数据
	foreachSet(s);
	//4.删除数据
	s.erase(10);
	foreachSet(s);
	//5.查找数据
	set<int>::iterator pos = s.find(20);
	if (pos == s.end())
	{
		cout << "未找到" << endl;
	}
	cout << "已找到" << endl;

	cout << s.count(30) << endl;

	set<int>::iterator pos1 = s.lower_bound(30);
	if (pos1 == s.end())
	{
		cout << "未找到" << endl;
	}
	cout << *pos1 << endl;

	set<int>::iterator pos2 = s.upper_bound(30);
	if (pos2 == s.end())
	{
		cout << "未找到" << endl;
	}
	cout << *pos2 << endl;

	pair<set<int>::iterator, set<int>::iterator> ret = s.equal_range(30);
	if (ret.first == s.end())	
	{
		cout << "ret.first未找到" << endl;
	}
	cout << *(ret.first) << endl;
	if (ret.second == s.end())
	{
		cout << "ret.second未找到" << endl;
	}
	cout << *(ret.second) << endl;
}

改变插入时的顺序
（1）改变普通数据类型顺序

class myCompare 
{
public:
	bool operator()(int v1, int v2)
	{
		return v1 > v2;
	}
};

void test04()
{
	//1.创建迭代器
	set<int, myCompare> s;
	//2.插入数据
	s.insert(10);
	s.insert(30);
	s.insert(20);
	s.insert(50);
	s.insert(40);
	//3.遍历数据
	for (set<int, myCompare>::iterator it = s.begin(); it != s.end(); it++)
	{
		cout << *it << endl;
	}
}

（2）改变自定义类型顺序

class Person
{
public:
	string name;
	int age;
	Person(string name1, int age1) 
	{
		this->name = name1;
		this->age = age1;
	}
};
class myCompare1 
{
public:
	bool operator()(const Person& p1, const Person& p2)
	{
		return p1.age > p2.age;
		//p1.name > p2.name;
	}
};
void test05()
{
	//通过仿函数 改变set容器的排序规则
	set<Person, myCompare1>s;
	Person p1 = { "aaa", 10 };
	Person p2 = { "bbb", 20 };
	Person p3 = { "ccc", 30 };
	Person p4 = { "ddd", 40 };

	s.insert(p1);
	s.insert(p2);
	s.insert(p3);
	s.insert(p4);

	//printSet(s);

	for (set<Person, myCompare1>::iterator it = s.begin(); it != s.end(); it++)
	{
		cout << (*it).name << " " << (*it).age << endl;
	}
}

对组的创建
（1）类模板：template <class T1, class T2> struct pair
（2）参数：T1是第一个值的数据类型，T2是第二个值的数据类型。
（3）功能：pair将一对值组合成一个值，这一对值可以具有不同的数据类型（T1和T2），两个值可以分别用pair的两个公有函数first和second访问。

void test02()
{
	pair<string, int>p1("abc", 123);
	cout << p1.first << " " << p1.second << endl;
	pair<string, int>p2 = make_pair("abc", 123);
	cout << p2.first << " " << p2.second << endl;
}

4.4 set与multiset容器的区别

set容器中的数据不能有重复值，而multiset对此无限制。
（1）因为set容器的insert函数原型为
pair<iterator, bool> insert(value_type&& _Val)，pair的中的两个元素iterator代表插入的迭代器，bool代表插入是否成功。

void test03()
{
	//1.创建迭代器
	set<int> s;
	//2.插入数据
	pair<set<int>::iterator, bool> p1 = s.insert(10);	//插入第一个10
	pair<set<int>::iterator, bool> p2 = s.insert(10);	//插入第二个10
	if (p1.second)	//若第一个插入成功
	{
		cout << "p1成功" << endl;
	}
	else
	{
		cout << "p1失败" << endl;
	}
	if (p2.second)	//若第二个插入成功
	{
		cout << "p2成功" << endl;
	}
	else
	{
		cout << "p2失败" << endl;
	}
}

因为multiset容器的insert函数原型为
iterator insert(value_type&& _Val)，iterator代表插入的迭代器

void test01()
{
	//1.创建迭代器
	multiset<int> s1;
	//2.插入数据
	s1.insert(10);	//插入第一个10
	s1.insert(10);	//插入第二个10
	for (multiset<int>::iterator it = s1.begin(); it != s1.end(); it++)
	{
		cout << *it << endl;
	}
}

5. map容器

5.1 基本概念

map容器的特征是，其同set容器一样在向容器中存入数据时会自动排序，但与set容器的区别在于，map容器的键与数据分开，而set容器的元素值本身就是键。
map容器的元素是pair，第一元素（first）是键值，第二元素（second）是实值。
由于map容器的存入时也是按顺序存储，因此无法改变元素的键值，但可以改变实值
map容器同样可以删除和插入数据而不影响其他的迭代器。
Multimap和map的操作类似，唯一区别multimap键值可重复。

5.2 常用API

map构造函数

map<T1, T2> mapTT;//map默认构造函数: 
map(const map &mp);//拷贝构造函数

map赋值操作

map& operator=(const map &mp);//重载等号操作符
swap(mp);//交换两个集合容器

map大小操作

size();//返回容器中元素的数目
empty();//判断容器是否为空

map插入数据元素操作

map.insert(...); //往容器插入元素，返回pair<iterator,bool>
map<int, string> mapStu;
// 第一种 通过pair的方式插入对象
mapStu.insert(pair<int, string>(3, "小张"));
// 第二种 通过pair的方式插入对象
mapStu.inset(make_pair(-1, "校长"));
// 第三种 通过value_type的方式插入对象
mapStu.insert(map<int, string>::value_type(1, "小李"));
// 第四种 通过数组的方式插入值
mapStu[3] = "小刘";
mapStu[5] = "小王";

map删除操作

clear();//删除所有元素
erase(pos);//删除pos迭代器所指的元素，返回下一个元素的迭代器。
erase(beg,end);//删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
erase(keyElem);//删除容器中key为keyElem的对组。

map查找操作

find(key);//查找键key是否存在,若存在，返回该键的元素的迭代器；/若不存在，返回map.end();
count(keyElem);//返回容器中key为keyElem的对组个数。对map来说，要么是0，要么是1。对multimap来说，值可能大于1。
lower_bound(keyElem);//返回第一个key>=keyElem元素的迭代器。
upper_bound(keyElem);//返回第一个key>keyElem元素的迭代器。
equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器。


void test01()
{
	//1.构造容器
	map<int, int> m;
	//2.插入数据
	pair<int, int> p1(1, 10);
	m.insert(p1);
	m.insert(make_pair(2, 20));
	m.insert(make_pair(3, 30));
	m.insert(make_pair(4, 40));
	//3.遍历容器
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << (*it).first << " " << (*it).second << endl;
	}
	//4.删除数据
	m.erase(1);
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << (*it).first << " " << (*it).second << endl;
	}
	//5.查找数据
	map<int, int>::iterator ret = m.find(3);
	if (ret != m.end())
	{
		cout << "找到了" << endl;
		cout << (*ret).first << " " << (*ret).second << endl;
	}
	else 
	{
		cout << "未找到" << endl;
	}
	ret = m.lower_bound(3);
	if (ret != m.end())
	{
		cout << "找到了" << endl;
		cout << (*ret).first << " " << (*ret).second << endl;
	}
	else
	{
		cout << "未找到" << endl;
	}
	pair<map<int, int>::iterator , map<int, int>::iterator > it = m.equal_range(3);
	if (it.first != m.end())
	{
		cout << "找到了equal_range中的 lower_bound的值 ，key = " << it.first->first << " value = " << it.first->second << endl;
	}
	else
	{
		cout << "未找到" << endl;
	}

	if (it.second != m.end())
	{
		cout << "找到了equal_range中的 upper_bound的值 ，key = " << it.second->first << " value = " << it.second->second << endl;
	}
	else
	{
		cout << "未找到" << endl;
	}
}