C++学习笔记（十四）（stack容器,queue容器,list容器）

最新推荐文章于 2021-07-29 10:06:25 发布

「已注销」

最新推荐文章于 2021-07-29 10:06:25 发布

阅读量352

点赞数

分类专栏： C++学习笔记文章标签： c++

本文链接：https://blog.csdn.net/qq_40694605/article/details/104579666

版权

C++学习笔记专栏收录该内容

16 篇文章 2 订阅

订阅专栏

本笔记主要来源于教程https://www.bilibili.com/video/av41559729?p=1

3.5 stack容器

3.5.1 stack 基本概念

概念：stack是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口（栈容器）

栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为
在这里插入图片描述

栈中进入数据称为 — 入栈 push

栈中弹出数据称为 — 出栈 pop

生活中的栈：
弹匣，地铁

3.5.2 stack 常用接口

功能描述：栈容器常用的对外接口

构造函数：

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

赋值操作：

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

数据存取：

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

大小操作：

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

示例：

#include 

//栈容器常用接口
void test01()
{
    //特点：符合先进后出数据结构
    stack s;

    //向栈中添加元素，叫做 压栈 入栈
    s.push(10);
    s.push(20);
    s.push(30);
    s.push(40);

    cout << "栈的大小为：" << s.size() << endl;
    //只要栈不为空，查看栈顶，并且执行出栈操作
    while (!s.empty()) {
        //输出栈顶元素
        cout << "栈顶元素为： " << s.top() << endl;
        //弹出栈顶元素
        s.pop();
    }
    cout << "栈的大小为：" << s.size() << endl;

}

int main() {

    test01();

    system("pause");

    return 0;
}

总结：

入栈 --- push
出栈 --- pop
返回栈顶 --- top
判断栈是否为空 --- empty
返回栈大小 --- size

3.6 queue 容器

3.6.1 queue 基本概念

概念：Queue是一种先进先出(First In First Out,FIFO)的数据结构，它有两个出口（队列容器）

队列容器允许从一端新增元素，从另一端移除元素

队列中只有队头和队尾才可以被外界使用，因此队列不允许有遍历行为

队列中进数据称为 — 入队 push

队列中出数据称为 — 出队 pop
在这里插入图片描述

生活中的队列：
排队买票

3.6.2 queue 常用接口

功能描述：栈容器常用的对外接口

构造函数：

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

赋值操作：

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

数据存取：

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

大小操作：

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

示例：

#include 
#include 


class Person
{
public:
    Person(string name, int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }

    string m_Name;
    int m_Age;
};

//队列 Queue
void test01() {

    //创建队列
    queue q;

    //准备数据
    Person p1("唐僧", 30);
    Person p2("孙悟空", 1000);
    Person p3("猪八戒", 900);
    Person p4("沙僧", 800);

    //向队列中添加元素  入队操作
    q.push(p1);
    q.push(p2);
    q.push(p3);
    q.push(p4);

    //队列不提供迭代器，更不支持随机访问 
    while (!q.empty()) {
        //输出队头元素
        cout << "队头元素-- 姓名： " << q.front().m_Name
            << " 年龄： " << q.front().m_Age << endl;

        cout << "队尾元素-- 姓名： " << q.back().m_Name
            << " 年龄： " << q.back().m_Age << endl;

        cout << endl;
        //弹出队头元素
        q.pop();
    }

    cout << "队列大小为：" << q.size() << endl;
}

int main() {

    test01();

    system("pause");

    return 0;
}

总结：

入队 --- push
出队 --- pop
返回队头元素 --- front
返回队尾元素 --- back
判断队是否为空 --- empty
返回队列大小 --- size

3.7 list容器

3.7.1 list基本概念

功能：将数据进行链式存储

链表（list）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的

链表的组成：链表由一系列结点组成

结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域

STL中的链表是一个双向循环链表

由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器

list的优点：

采用动态存储分配，不会造成内存浪费和溢出
链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素

list的缺点：

链表灵活，但是空间(指针域) 和时间（遍历）额外耗费较大

List有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的。

总结：STL中List和vector是两个最常被使用的容器，各有优缺点

3.7.2 list构造函数

功能描述：

创建list容器

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

示例：

//list容器的构造
void printList(const list& L) {

    for (list::const_iterator it = L.begin(); it != L.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
}

void test01()
{
    //创建list容器
    listL1;//默认构造

    //添加数据
    L1.push_back(10);
    L1.push_back(20);
    L1.push_back(30);
    L1.push_back(40);

    printList(L1);

    //区间方式
    listL2(L1.begin(), L1.end());
    printList(L2);

    //拷贝构造
    listL3(L2);
    printList(L3);

    //n个elem
    listL4(10, 1000);
    printList(L4);
}

int main() {

    test01();

    system("pause");

    return 0;
}

总结：list构造方式同其他几个STL常用容器，熟练掌握即可

3.7.3 list 赋值和交换

功能描述：

给list容器进行赋值，以及交换list容器

函数原型：

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

示例：

void printList(const list& L) {

    for (list::const_iterator it = L.begin(); it != L.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
}

//赋值和交换
void test01()
{
    listL1;
    L1.push_back(10);
    L1.push_back(20);
    L1.push_back(30);
    L1.push_back(40);
    printList(L1);

    //赋值
    listL2;
    L2 = L1;
    printList(L2);

    listL3;
    L3.assign(L2.begin(), L2.end());
    printList(L3);

    listL4;
    L4.assign(10, 100);
    printList(L4);

}

//交换
void test02()
{

    listL1;
    L1.push_back(10);
    L1.push_back(20);
    L1.push_back(30);
    L1.push_back(40);

    listL2;
    L2.assign(10, 100);

    cout << "交换前： " << endl;
    printList(L1);
    printList(L2);

    cout << endl;

    L1.swap(L2);

    cout << "交换后： " << endl;
    printList(L1);
    printList(L2);

}

int main() {

    test01();

    test02();

    system("pause");

    return 0;
}

总结：list赋值和交换操作能够灵活运用即可

3.7.4 list 大小操作

功能描述：

ul>

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

示例：

void printList(const list& L) {

    for (list::const_iterator it = L.begin(); it != L.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
}

//list容器大小操作
void test01()
{
    listL1;
    L1.push_back(10);
    L1.push_back(20);
    L1.push_back(30);
    L1.push_back(40);

    if (L1.empty())
    {
        cout << "L1为空" << endl;
    }
    else
    {
        cout << "L1不为空" << endl;
        cout << "L1的大小为： " << L1.size() << endl;
    }

    //重新指定大小
    L1.resize(10,1000);
    printList(L1);

    L1.resize(2);
    printList(L1);
}

int main() {

    test01();

    system("pause");

    return 0;
}

总结：

判断是否为空 --- empty
返回元素个数 --- size
重新指定个数 --- resize

3.7.5 list 插入和删除

功能描述：

对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值匹配的元素。

示例：

void printList(const list& L) {

    for (list::const_iterator it = L.begin(); it != L.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
}

//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值匹配的元素。
*/
void test01()
{
    list L;
    //尾插
    L.push_back(10);
    L.push_back(20);
    L.push_back(30);
    //头插
    L.push_front(100);
    L.push_front(200);
    L.push_front(300);

    //300 200 100 10 20 30
    printList(L);

    //尾删
    //300 200 100 10 20
    L.pop_back();
    printList(L);

    //头删
    // 200 100 10 20
    L.pop_front();
    printList(L);

    //insert插入
    // 200 1000 100 10 20
    list::iterator it = L.begin();
    L.insert(++it, 1000);
    printList(L);

    //删除
    //200 100 10 20
    it = L.begin();
    L.erase(++it);
    printList(L);

    //移除
    L.push_back(10000);
    L.push_back(10000);
    L.push_back(10000);
    printList(L);
    L.remove(10000);
    printList(L);

    //清空
    L.clear();
    printList(L);
}

int main() {

    test01();

    system("pause");

    return 0;
}

总结：

尾插 --- push_back
尾删 --- pop_back
头插 --- push_front
头删 --- pop_front
插入 --- insert
删除 --- erase
移除 --- remove
清空 --- clear

3.7.6 list 数据存取

功能描述：

对list容器中数据进行存取

不支持[ ]和at的方式，因为list链表存储方式不是连续的，它的迭代器不支持随机访问，是双向迭代器，只能前移后移，无法跳跃式访问。

函数原型：

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

//数据存取
void test01()
{
    list<int>L1;
    L1.push_back(10);
    L1.push_back(20);
    L1.push_back(30);
    L1.push_back(40);


    //cout << L1.at(0) << endl;//错误 不支持at访问数据
    //cout << L1[0] << endl; //错误  不支持[]方式访问数据
    cout << "第一个元素为： " << L1.front() << endl;
    cout << "最后一个元素为： " << L1.back() << endl;

    //list容器的迭代器是双向迭代器，不支持随机访问
    list<int>::iterator it = L1.begin();
    it++;//只能++，--
    //it = it + 1;//错误，不可以跳跃访问，即使是+1
}

int main() {

    test01();

    system("pause");

    return 0;
}

总结：

list容器中不可以通过[]或者at方式访问数据
返回第一个元素 --- front
返回最后一个元素 --- back

3.7.7 list 反转和排序

功能描述：

将容器中的元素反转，以及将容器中的数据进行排序

函数原型：

reverse(); //反转链表
sort(); //链表排序

示例：

void printList(const list<int>& L) {

    for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
}

bool myCompare(int val1, int val2)
{
    //降序，就让第一个数大于第二个数
    return val1 > val2;
}

//list容器反转和排序
//反转
void test01()
{
    list<int> L;
    L.push_back(90);
    L.push_back(30);
    L.push_back(20);
    L.push_back(70);
    cout << "反转前： " << endl;
    printList(L);

    //反转容器的元素
    L.reverse();
    cout << "反转后： " << endl;
    printList(L);

}
//排序
void test02()
{
    list<int> L;
    L.push_back(90);
    L.push_back(30);
    L.push_back(20);
    L.push_back(70);
    cout << "排序前： " << endl;
    printList(L);

    //所有不支持随机访问迭代器的容器，不可以用标准算法
    //不支持随机访问迭代器的容器，内部会提供对应一些算法

    L.sort();//默认排序规则从小到大
    cout << "排序后：" << endl;
    printList(L);

    L.sort(myCompare);
    printList(L);

}
int main() {

    test01();
    test02();

    system("pause");

    return 0;
}

总结：

反转 --- reverse
排序 --- sort （成员函数）

3.7.8 排序案例

案例描述：将Person自定义数据类型进行排序，Person中属性有姓名、年龄、身高

排序规则：按照年龄进行升序，如果年龄相同按照身高进行降序

示例：

#include<iostream>
using namespace std;
#include <list>
#include <string>

//list排序案例 对于自定义数据类型做排序

//按照年龄进行升序，如果年龄相同按照身高进行降序
class Person {
public:
	Person(string name, int age, int height) {
		m_Name = name;
		m_Age = age;
		m_Height = height;
	}

public:
	string m_Name;  //姓名
	int m_Age;      //年龄
	int m_Height;   //身高
};

//指定排序规则
bool ComparePerson(Person& p1, Person& p2)
{
	//年龄相同，按身高排序
	if (p1.m_Age == p2.m_Age) {
		return p1.m_Height > p2.m_Height;
	}
	else
	{
		return  p1.m_Age < p2.m_Age;//前一个小于第二个，升序
	}

}

void test01() {

	list<Person> L;//创建容器

	Person p1("刘备", 35, 175);
	Person p2("曹操", 45, 180);
	Person p3("孙权", 40, 170);
	Person p4("赵云", 25, 190);
	Person p5("张飞", 35, 160);
	Person p6("关羽", 35, 200);

	L.push_back(p1);
	L.push_back(p2);
	L.push_back(p3);
	L.push_back(p4);
	L.push_back(p5);
	L.push_back(p6);

	for (list<Person>::iterator it = L.begin(); it != L.end(); it++) {
		cout << "姓名： " << it->m_Name << " 年龄： " << it->m_Age
			<< " 身高： " << it->m_Height << endl;
	}

	cout << "---------------------------------" << endl;
	L.sort(ComparePerson); //排序

	for (list<Person>::iterator it = L.begin(); it != L.end(); it++) {
		cout << "姓名： " << it->m_Name << " 年龄： " << it->m_Age
			<< " 身高： " << it->m_Height << endl;
	}
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：

对于自定义数据类型，必须要指定排序规则，否则编译器不知道如何进行排序
高级排序只是在排序规则上再进行一次逻辑规则制定，并不复杂

最后欢迎大家访问我的个人博客青蛙听禅的个人博客

「已注销」

关注

0
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
C++学习笔记（十四）（stack容器,queue容器,list容器）

本笔记主要来源于教程https://www.bilibili.com/video/av41559729?p=13.5 stack容器3.5.1 stack 基本概念概念：stack是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口（栈容器）栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为栈中进入数据称为 — 入栈 push栈中弹出...
复制链接

扫一扫