vector,deque,list相关操作

1、vector的基本操作

(1)、对动态数组元素的添加和删除、获取

代码如下:

#include<iostream>
#include<vector>
using namespace std;

//数组元素的添加和删除、获取
int main(void){
    vector<int> v1; 

    v1.push_back(1);
    v1.push_back(2);
    v1.push_back(3);

    cout<<"len:"<<v1.size()<<endl;
    cout<<"获取头部元素:"<<v1.front()<<endl;

    //修改头部、尾部元素的值
    //函数返回值当左值,应该返回一个引用;
    v1.front() = 11; 
    v1.back() = 55; 

    while(v1.size() > 0){ 
        cout<<v1.back()<<" ";    //获取尾部元素;
        v1.pop_back(); //删除尾部元素
     }   
    cout<<endl;

}

(2)、vector的初始化

代码如下:

#include<iostream>
#include<vector>
using namespace std;

void printV(vector<int> &v){
    for(int i = 0; i < v.size(); i++){
        cout<<v[i]<<" ";
    }
    cout<<endl;
}

int main(void){
    //vector类
    vector<int> v1;

    v1.push_back(1);
    v1.push_back(3);
    v1.push_back(5);
    v1.push_back(7);

    vector<int> v2 = v1; //对象初始化
    vector<int> v3(v1.begin(), v1.begin()+2); //对象初始化
/*
    //vector的遍历
    for(i =a 0; i < v1.size(); i++){
        v1[i] = i + 1;
    }
    int i;
    for(i = 0; i < v1.size(); i++){
        cout<<v1[i]<<" ";
    }
    cout<<endl;
*/
    printV(v1);

    //push_back()的强化记忆;
    vector<int> v5(10); //前10个元素初始化为0;
    v5.push_back(100);
    v5.push_back(200);
    printV(v5);
    return 0;    
}

(3)、vector中迭代器的正向和反向遍历

代码如下:

#include<iostream>
#include<vector>
using namespace std;

int main(void){
    vector<int> v1(10); //初始化空间的值都为0;
    for(int i = 0; i < 10; i++){
        v1[i] = i+1;
    }   
//迭代器
//1(begin)、3、5 、(end) 当it = v1.end()的时候,说明这个容器已经遍历完了;
//end()的位置,应该是5的后面;
    //正向遍历
    vector<int>::iterator it; 
    for(it = v1.begin(); it != v1.end(); it++){
        cout<<*it<<" ";
    }   
    cout<<endl;

    //反向遍历
    vector<int>::reverse_iterator rit;
    for(rit = v1.rbegin(); rit != v1.rend(); rit++){
        cout<<*rit<<" ";
    }   
    cout<<endl;

    return 0;
}

(4)、vector中的元素删除操作

代码如下:

#include<iostream>
#include<vector>
using namespace std;

void printV(vector<int> &v){
    for(int i = 0; i < v.size(); i++){
        cout<<v[i]<<" ";
    }   
    cout<<endl;
}

//删除
int main(void){
    vector<int> v1(10);

    for(int i = 0; i < 10; i++){
        v1[i] = i + 1;
    }   
    //区间删除
    v1.erase(v1.begin(), v1.begin()+3); //删除开始的3个元素
    //指定(元素)位置删除
    v1.erase(v1.begin()); //在头部删除一个

    //根据元素的值
    v1[1] = 2;
    v1[3] = 2;

    vector<int>::iterator it;
    for(it = v1.begin(); it != v1.end(); it++){
        if(*it == 2){
            v1.erase(it); //删除的是元素,参数是迭代器
        }
    }

    v1.insert(v1.begin(), 100);
    v1.insert(v1.end(), 200);
    printV(v1);
    return 0;
}

2、deque的基本操作

双端数组的基本操作;

代码如下:

#include<iostream>
#include<deque>
#include<algorithm>
using namespace std;

void printD(deque<int> &d){
    deque<int>::iterator it; 
    for(it = d.begin(); it != d.end(); it++){
        cout<<*it<<" ";
    }   
    cout<<endl;
}

int main(void){
    deque<int> d1; 
    d1.push_back(1);
    d1.push_back(3);
    d1.push_back(5);

    d1.push_front(-11);
    d1.push_front(-33);
    d1.push_front(-55);

    cout<<"头部元素:"<<d1.front()<<endl;
    cout<<"尾部元素:"<<d1.back()<<endl;
    printD(d1);
    d1.pop_front();
    d1.pop_back();
    printD(d1);

    //查找-33在数组中的下标
    deque<int>::iterator it;
    it = find(d1.begin(), d1.end(), -33);
    if(it != d1.end()){
        cout<<"-33数组的下标是:"<<distance(d1.begin(), it)<<endl; //查找下标;
    }else{
        cout<<"没有找到值为-33"<<endl;
    }

    return 0;
}

3、stack的基本操作

代码如下:

#include<iostream>
#include<stack>
using namespace std;

class Teacher{
    public:
        void printS(){
            cout<<"age :"<<age<<endl;
        }
    public:
        int age;
        char name[15];
};

int main(void){
    Teacher t1,t2,t3;

    t1.age = 31;
    t2.age = 32;
    t3.age = 33;

    stack<Teacher *> s;
    s.push(&t1);
    s.push(&t2);
    s.push(&t3);

    while(!s.empty()){
        Teacher *tmp = s.top();
        tmp->printS();
        s.pop();
    }

    return 0;
}

/*
int main(void){
    Teacher t1,t2,t3;

    t1.age = 31;
    t2.age = 32;
    t3.age = 33;

    stack<Teacher> s;
    s.push(t1);
    s.push(t2);
    s.push(t3);

    while(!s.empty()){
        Teacher tmp = s.top();
        tmp.printS();
        s.pop();    
    }

    return 0;
}
*/
/*
int main(void){
    stack<int> s;

    //入栈
    for(int i = 0; i < 10; i++){
        s.push(i+1);
    }

    cout<<s.size()<<endl; //栈的大小
    //出栈
    while(!s.empty()){
        int tmp = s.top(); //获取栈顶元素
        cout<<tmp<<" ";
        s.pop();
    }
    cout<<endl;

    return 0;
}
*/

4、queue的基本操作

代码如下:

#include<iostream>
#include<queue>
using namespace std;

class Teacher{
    public:
        int age;
        char name[25];
    public:
        void printQ(){
            cout<<"age :"<<age<<endl;
        }
};

int main(void){
    Teacher q1, q2, q3;

    q1.age = 31;
    q2.age = 32;
    q3.age = 33;

    queue<Teacher *> q;
    q.push(&q1);
    q.push(&q2);
    q.push(&q3);

    while(!q.empty()){
        Teacher *tmp;
        tmp = q.front(); //获取队列头的元素
        tmp->printQ();
        q.pop();
    }

    return 0;
}

/*
//队列中的基础数据类型,
int main(void){
    queue<int> q;

    q.push(1);
    q.push(2);
    q.push(3);

    cout<<"对头元素:"<<q.front()<<endl;
    cout<<"队列的大小"<<q.size()<<endl;

    while(!q.empty()){
        cout<<q.front()<<" ";    
        q.pop();
    }
    cout<<endl;
    return 0;
}
*/

5、priority_queue的基本操作

代码如下:

#include<iostream>
#include<queue>
using namespace std;

int main(void){
    priority_queue<int> p1; //默认的情况下:是最大优先级队列;
    priority_queue<int, vector<int>, less<int> > p2; 
    priority_queue<int, vector<int>, greater<int> > p3; //是最小的优先级队列

    p1.push(33);
    p1.push(11);
    p1.push(22);
    p1.push(77);
    p1.push(55);
    p1.push(99);

    cout<<"队头元素:"<<p1.top()<<endl;
    cout<<"队列的大小:"<<p1.size()<<endl;

    while(!p1.empty()){
        cout<<p1.top()<<" "; //获取队头的是top();
        p1.pop();
    }   
    cout<<endl;

    cout<<"--------------------测试最小值优先级队列---------------------"<<endl;
    p3.push(33);
    p3.push(11);
    p3.push(22);
    p3.push(77);
    p3.push(55);
    p3.push(99);

    cout<<"队头元素:"<<p3.top()<<endl;
    cout<<"队列的大小:"<<p3.size()<<endl;

    while(!p3.empty()){
        cout<<p3.top()<<" "; //获取队头的是top();
        p3.pop();
    }
    cout<<endl;

    return 0;
}

6、list的基本操作

(1)、list的遍历

代码如下:

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

void printL(list<int> &l){
    list<int>::iterator it; 
    for(it = l.begin(); it != l.end(); it++){
        cout<<*it<<" ";
    }   
    cout<<endl;    
}

//迭代器中的begin()和end()代表的含义:begin代表的是第一个元素的位置,end代表的是最后一个元素的下一个元>
素的位置;
int main(void){
    list<int> l;

    cout<<"list的大小:"<<l.size()<<endl;
    for(int i = 0; i < 10; i++){
        l.push_back(i);
    }   

    printL(l);
    //list不能随即访问;
    list<int>::iterator it = l.begin();
    it++;
    it++;
    it++;
    l.insert(it, 100); //STL中的插入默认是前插;
    printL(l);

//1、list链表的节点的index是从0位置开始的
//2、insert方法都是默认的前插
    return 0;
}

(2)、list的删除

代码如下:

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

void printL(list<int> &l){
    list<int>::iterator it;
    for(it = l.begin(); it != l.end(); it++){
        cout<<*it<<" ";
    }
    cout<<endl;
}
//list删除
int main(void){
    list<int> l;

    for(int i = 0; i < 10; i++){
        l.push_back(i);
    }   

    list<int>::iterator it1 = l.begin();
    list<int>::iterator it2 = l.begin();
    it2++;
    it2++;
    it2++;

    l.erase(it1, it2); //删除是左闭右开的操作;[0, 3)
    printL(l);

    l.erase(l.begin());
    printL(l);

    l.insert(l.begin(), 100);
    l.insert(l.begin(), 100);
    l.insert(l.begin(), 100);
    l.insert(l.begin(), 100);
    l.insert(l.begin(), 100);
    printL(l);

    l.remove(100); //删除元素的方法,删除了所有值为100的元素;
    printL(l);

    return 0;
}
时间: 2025-01-01 06:12:23

vector,deque,list相关操作的相关文章

STL之heap相关操作算法

说明:本文仅供学习交流,转载请标明出处,欢迎转载! 堆(heap)是一种非常重要的数据结构(这里我们讨论的是二叉堆),它是一棵满足特定条件的完全二叉树,堆的定义如下: 堆是一棵树完全二叉树,对于该完全二叉树中的每一个结点x,其关键字大于等于(或小于等于)其左右孩子结点,而其左右子树均为一个二叉堆. 在上述的定义中,若堆中父亲结点关键字的值大于等于孩子结点,则称该堆为大顶堆:若堆中父亲结点关键子的值小于等于孩子结点,则称该堆为小顶堆. 由于堆是一棵完全二叉树,所以我们可以很轻易地用一个数组存储堆中

STL标准容器类学习笔记之(Vector/Deque/List)

STL标准容器类简介 1.顺序性容器 vector相当与数组,从后面快速的插入与删除,直接访问任何元素 deque双队列,从前面或后面快速的插入与删除,直接访问任何元素 list双链表,从任何地方快速插入与删除 2.关联容器 set快速查找,不允许重复值 multiset快速查找,允许重复值 map一对一映射,基于关键字快速查找,不允许重复值 multimap一对多映射,基于关键字快速查找,允许重复值 3.容器适配器 stack后进先出 queue先进先出 priority_queue最高优先级

stl 中List vector deque区别

stl提供了三个最基本的容器:vector,list,deque.         vector和built-in数组类似,它拥有一段连续的内存空间,并且起始地址不变,因此     它能非常好的支持随即存取,即[]操作符,但由于它的内存空间是连续的,所以在中间     进行插入和删除会造成内存块的拷贝,另外,当该数组后的内存空间不够时,需要重新     申请一块足够大的内存并进行内存的拷贝.这些都大大影响了vector的效率.         list就是数据结构中的双向链表(根据sgi   s

Scala学习(三)----数组相关操作

数组相关操作 摘要: 本篇主要学习如何在Scala中操作数组.Java和C++程序员通常会选用数组或近似的结构(比如数组列表或向量)来收集一组元素.在Scala中,我们的选择更多,不过现在我们先假定不关心其他选择,而只是想马上开始用数组.本篇的要点包括: 1. 若长度固定则使用Array,若长度可能有变化则使用ArrayBuffer 2. 提供初始值时不要使用new 3. 用()来访问元素 4. 用for (elem<-arr)来遍历元素 5. 用for (elem<-arr if…)…yie

Unity 中的 Vector向量的 相关使用1

Unity 中的 Vector向量的 相关使用1 孙广东 2015.10.28 以下页面提供有关在您的代码中有效地使用向量的一些建议. 理解向量算法 向量算术是 3D 图形. 物理和动画的基础,深度的理解它是有用的.下面是主要的操作和一些建议,它们可以用于许多的事的说明. 当两个向量相加时,结果是相当于以原始向量为"步骤",一个接一个.请注意这两个参数的顺序并不重要,因为结果是相同的无论哪种方式. 如果第一个向量作为空间中的点然后第二个可以被解释为一个偏移量,或者从这一个位置"

vector deque list

vector ,deque 和 list 顺序性容器: 向量 vector :   是一个线性顺序结构.相当于数组,但其大小可以不预先指定,并且自动扩展.它可以像数组一样被操作,由于它的特性我们完全可以将vector 看作动态数组.在创建一个vector 后,它会自动在内存中分配一块连续的内存空间进行数据存储,初始的空间大小可以预先指定也可以由vector 默认指定,这个大小即capacity ()函数的返回值.当存储的数据超过分配的空间时vector 会重新分配一块内存块,但这样的分配是很耗时

Scala详解---------数组相关操作

Scala中提供了一种数据结构-数组,其中存储相同类型的元素的固定大小的连续集合.数组用于存储数据的集合,但它往往是更加有用认为数组作为相同类型的变量的集合. 取替声明单个变量,如number0, number1, ..., 和number99,声明一个数组变量,如号码和使用numbers[0],numbers[1],...,numbers[99]表示单个变量.本教程介绍了如何声明数组变量,创建数组和使用索引的过程变量数组.数组的第一个元素的索引是数字0和最后一个元素的索引为元素的总数减去1.

二叉树的相关操作

#include<stdio.h> #include<malloc.h> #define MAXSIZE 20 typedef char TEelemtype; typedef struct BiTNode{ TEelemtype data; struct BiTNode *lchild,*rchild; }BiTNode,*BiTree; //队列的方式 typedef struct queueelem { BiTNode* b[MAXSIZE]; int front,rear;

(二十四)linux新定时器:timefd及相关操作函数

timerfd是Linux为用户程序提供的一个定时器接口.这个接口基于文件描述符,通过文件描述符的可读事件进行超时通知,所以能够被用于select/poll的应用场景. 一,相关操作函数 #include <sys/timerfd.h> int timerfd_create(int clockid, int flags); int timerfd_settime(int fd, int flags, const struct itimerspec *new_value, struct itim

二叉树各种相关操作(建立二叉树、前序、中序、后序、求二叉树的深度、查找二叉树节点,层次遍历二叉树等)(C语言版)

将二叉树相关的操作集中在一个实例里,有助于理解有关二叉树的相关操作: 1.定义树的结构体: 1 typedef struct TreeNode{ 2 int data; 3 struct TreeNode *left; 4 struct TreeNode *right; 5 }TreeNode; 2.创建根节点: 1 TreeNode *creatRoot(){ 2 TreeNode * root =(TreeNode *)malloc(sizeof(TreeNode)); 3 if(NULL=