栈和队列

最新推荐文章于 2024-11-09 17:45:50 发布

转载最新推荐文章于 2024-11-09 17:45:50 发布 · 440 阅读

算法水题同时被 2 个专栏收录

55 篇文章

订阅专栏

数据结构

1 篇文章

订阅专栏

栈和队列都是数据结构里面的东西，刚学，也是半懂不懂的

栈的头文件是#include<stack>

队列的头文件是#include<queue>

栈的定义如下：

stack < int > stk;

队列的定义如下：

queue <int > q;

有下面的操作：

//栈是先进的后出 ，相当于一个桶，里面放了球，拿出来的时候只能是从上面依次拿出来，不能从桶底拿
//用完后要清空栈，要不然会一直出现bug 
s.empty()               //判断栈是否为空，如果栈为空返回true，否则返回false  
s.size()                //返回栈中元素的个数  
s.pop()                 //删除栈顶元素但不返回其值  
s.top()                 //返回栈顶的元素，但不删除该元素  
s.push()                //在栈顶压入新的元数  

//队列是先进的先出来，相当于高速路上的隧道，先进去的车，肯定是先出来，后进去的车肯定是后面出来，讲究的 
//用完也是要清空的， 
q.empty()               //判断队列是否为空，如果队列为空返回true，否则返回false  
q.size()                //返回队列中元素的个数  
q.pop()                 //删除队列首元素但不返回其值  
q.front()               //返回队首元素的值，但不删除该元素  
q.push()                //在队尾压入新元素  
q.back()                //返回队列尾元素的值，但不删除该元素  

//两者都要讲究一个顺序

vector

1.C++ Vectors能够使用标准运算符: ==, !=, <=, >=, <, 和 >.
v[] // 要访问vector中的某特定位置的元素可以使用 [] 操作符.
v1 == v2 // 两个vectors被认为是相等的,如果: 1.它们具有相同的容量;2.所有相同位置的元素相等.
v1 != v2
v1 <= v2 // vectors之间大小的比较是按照词典规则.
v1 >= v2
v1 < v2
v1 > v2

(1)头文件#include<vector>.
(2)创建vector对象，vector<int> vec;
(3)尾部插入数字：vec.push_back(a);
(4)使用下标访问元素，cout<<vec[0]<<endl;记住下标是从0开始的。
(5)使用迭代器访问元素.
(6)插入元素： vec.insert(vec.begin()+i,a);在第i+1个元素前面插入a;
(7)删除元素： vec.erase(vec.begin()+2);删除第3个元素
vec.erase(vec.begin()+i,vec.end()+j);删除区间[i,j-1];区间从0开始
(8)向量大小:vec.size();
(9)清空:vec.clear();

    #include <vector>  
    #include <algorithm>  
    #include <iostream>  
    int main( )  
    {  
        using namespace std;  
        vector <int> v1;  
        vector <int>::iterator Iter1;   
        for (int  i = 0 ; i <= 5 ; i++ )  
        {  
            v1.push_back( i );  
        }  
        v1.insert(v1.begin()+2,22);//在2的位置上插入元素  
        v1.erase(v1.begin()+2);//删除在2的位置上的元素  
        v1.pop_back();//删除最后的元素  
        reverse(v1.begin(),v1.end());//翻转  使用reverse将元素翻转：需要头文件#include<algorithm>  
        cout << "vector v1 = ( " ;  
        for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )  
            cout << *Iter1 << " ";  
        cout << ")" << endl;  
      
        return 1;  
    }

向量（vector）、双端队列（deque）、列表（list）、集合（set）、多重集合（multiset）、映射（map）和多重映射（multimap）
multimap允许重复元素，map不允许重复元素。

//deque  
http://www.cplusplus.com/reference/deque/deque/  
Modifiers:  
assign  
Assign container content (public member function )  
push_back  
Add element at the end (public member function )  
push_front  
Insert element at beginning (public member function )  
pop_back  
Delete last element (public member function )  
pop_front  
Delete first element (public member function )  
insert  
Insert elements (public member function )  
erase  
Erase elements (public member function )  
swap  
Swap content (public member function )  
clear  
Clear content (public member function )  
emplace   
Construct and insert element (public member function )  
emplace_front   
Construct and insert element at beginning (public member function )  
emplace_back   
Construct and insert element at the end (public member function )  
  
  
  
//set 用法  
set集合容器：实现了红黑树的平衡二叉检索树的数据结构，插入元素时，它会自动调整二叉树的排列，把元素放到适当的位置，以保证每个子树根节点键值大于左子树所有节点的键值，小于右子树所有节点的键值；另外，还得保证根节点左子树的高度与右子树高度相等。  
平衡二叉检索树使用中序遍历算法，检索效率高于vector、deque和list等容器，另外使用中序遍历可将键值按照从小到大遍历出来。  
构造set集合主要目的是为了快速检索，不可直接去修改键值。  
  
 C++ Set常用用法  
分类： CPlus 2013-04-22 19:24 4525人阅读 评论(0) 收藏 举报  
set集合容器：实现了红黑树的平衡二叉检索树的数据结构，插入元素时，它会自动调整二叉树的排列，把元素放到适当的位置，以保证每个子树根节点键值大于左子树所有节点的键值，小于右子树所有节点的键值；另外，还得保证根节点左子树的高度与右子树高度相等。  
平衡二叉检索树使用中序遍历算法，检索效率高于vector、deque和list等容器，另外使用中序遍历可将键值按照从小到大遍历出来。  
构造set集合主要目的是为了快速检索，不可直接去修改键值。  
  
常用操作：  
1.元素插入：insert()  
2.中序遍历：类似vector遍历（用迭代器）  
3.反向遍历：利用反向迭代器reverse_iterator。  
    例：  
    set<int> s;  
    ......  
    set<int>::reverse_iterator rit;  
    for(rit=s.rbegin();rit!=s.rend();rit++)  
4.元素删除：与插入一样，可以高效的删除，并自动调整使红黑树平衡。  
            set<int> s;  
            s.erase(2);        //删除键值为2的元素  
            s.clear();  
5.元素检索：find()，若找到，返回该键值迭代器的位置，否则，返回最后一个元素后面一个位置。  
            set<int> s;  
            set<int>::iterator it;  
            it=s.find(5);    //查找键值为5的元素  
            if(it!=s.end())    //找到  
                cout<<*it<<endl;  
            else            //未找到  
                cout<<"未找到";  
6.自定义比较函数  
    (1)元素不是结构体：  
        例：  
        //自定义比较函数myComp,重载“（）”操作符  
        struct myComp  
        {  
            bool operator()(const your_type &a,const your_type &b)  
            [  
                return a.data-b.data>0;  
            }  
        }  
        set<int,myComp>s;  
        ......  
        set<int,myComp>::iterator it;  
    (2)如果元素是结构体，可以直接将比较函数写在结构体内。  
        例：  
        struct Info  
        {  
            string name;  
            float score;  
            //重载“<”操作符，自定义排序规则  
            bool operator < (const Info &a) const  
            {  
                //按score从大到小排列  
                return a.score<score;  
            }  
        }  
        set<Info> s;  
        ......  
        set<Info>::iterator it;  
          
  
  
//map  
* Map的特点: 1、存储Key-value对  
* 2、支持快速查找，查找的复杂度基本是Log(N)  
* 3、快速插入，快速删除，快速修改记  
#include <iostream>  
#include <string>  
#include <map>   
using namespace std;  
  
  
int main()  
{  
    map<const char*,int> m;  
    m["a"]=1;  
    m["b"]=6;  
    m["c"]=9;  
    map<const char*,int>::iterator it;  
    it=m.begin();  
    const char* c =it->first;  
    cout<<"first element is :"<<c<<endl;  
    int i = m["c"];  
    while(it!=m.end()){  
        cout << it->first<<";"<<it->second<<endl;  
        ++it;  
    }  
    cout <<"m[\"c\"]="<<i<<endl;  
    cout <<"sizeof m:"<<m.size()<<endl;  
    cout <<"erase m[\"c\"](1:succ 0:failed):"<<m.erase("c")<<endl;  
    cout <<"erase m[\"c\"]:"<<m.erase("c")<<endl;  
    cout <<"sizeof m:"<<m.size()<<endl;  
    cout<<"m[c]="<<m["c"]<<endl;  
    cout<<"sizeof m :"<<m.size()<<endl;  
  
    return 0;  
  
}  
  
//集合 数字唯一  
  
Map是STL的一个关联容器，它提供一对一（其中第一个可以称为关键字，每个关键字只能在map中出现一次，第二个可能称为该关键字的值）的数据处理能力，由于这个特性，它完成有可能在我们处理一对一数据的时候，在编程上提供快速通道。这里说下map内部数据的组织，map内部自建一颗红黑树(一种非严格意义上的平衡二叉树)，这颗树具有对数据自动排序的功能，所以在map内部所有的数据都是有序的，后边我们会见识到有序的好处。  
  
  
迭代器和指针的关系  
//迭代器是抽象的指针@@@  
容器的类型是抽象的,使用迭代器,算法函数可以访问容器中指定位置的元素,而无需关注元素的具体类型.  
迭代器  
迭代器是面向对象版本的指针，它们提供了访问容器、序列中每个元素的方法。  
  
  
48 适配器  
适配器是一种接口类  
–为已有的类提供新的接口。  
–目的是简化、约束、使之安全、隐藏或者改变被修改类提供的服务集合。  
?三种类型的适配器：  
//容器适配器  
?用来扩展7种基本容器，它们和顺序容器相结合构成栈、队列和优先队列容器  
//迭代器适配器  
//函数对象适配器。  
  
49 顺序容器  
顺序容器的接口  
–插入方法  
?push_front()，push_back()，insert()，运算符“=”  
–删除方法  
?pop() ，erase()，clear()  
–迭代访问方法  
?使用迭代器  
–其他顺序容器访问方法（不修改访问方法）  
?front()，back()，下标[]运算符  
  
//顺序容器——向量  
//顺序容器——双端队列  
双端队列是一种放松了访问权限的队列。元素可以从队列的两端入队和出队，也支持通过下标操作符“[]”进行直接访问。  
//顺序容器——列表  
列表主要用于存放双向链表，可以从任意一端开始遍历。列表还提供了拼接（splicing）操作，将一个序列中的元素从插入到另一个序列  
  
  
容器适配器:  
容器适配器是用来扩展7种基本容器的  
?栈容器  
–使用适配器与一种基础容器相结合来实现  
–例10-4：应用标准库中的deque顺序容器生成一个整数栈stack。  
?队列容器  
–使用适配器与一种基础容器相结合来实现的先进先出数据结构。  
–例10-5：应用标准库中的deque顺序容器生成一个整数标准队列queue