STL+位运算的文件

1.queue 队列

queue的头文件是<queue>.

定义queue对象的示例代码如：

queue<int>q;  队列内存放的是int类型的数

queue<double> 队列内存放的是double类型的数

queue<node>q;  队列内存放的是结构体类型

入队列：q.push(x)   将x元素放到队列的末端。

出队列：q.pop()    将第一个元素删除

访问队首元素： q.front();

访问队中的元素的个数： q.size();

2. deque 双端队列

deque的用法：

3.priority_queue 优先队列(重点)

priority_queue模板类有三个模板参数，第一个是元素类型，第二个容器类型，第三个是比较算子，其中后两个都可以省略，默认容器为vector，默认算子为less，即小的往前排，大的往后排（出队时序列尾的元素出队）。

定义priority_queue对象的示例代码如下：

priority_queue<int> p;

priority_queue<int, vector<int>, greater<int> > p  //从小到大排列

priority_queue<int,vector<int>,less<int> >p;// 从大到小排列

自定义数据类型

定义自己的比较算子，方法有多种，重载比较运算符。

struct node

{

    int a,b;

    bool operator <(const node &x)const

    {

        return a<x.a;

    }

};

priority_queue<node>q;

注意：

这里是按照a的顺序从大到小出队的。

访问优先队列的队首元素 q.top() ;

出队列： q.pop();

入队列： q.push(x);

判断优先队列是否为空： q.empty();

示例代码：

#include <cstdio>

#include <cstring>

#include <queue>

#include <algorithm>

using namespace std;

struct node

{

    int a,b;

    bool operator <(const node &x)const

    {

        return a<x.a;

    }

}p[100];

 

int main()

{

    priority_queue<node>q;

    p[0].a = 6; p[0].b = 1;

    p[1].a = 9; p[1].b = 5;

    p[2].a = 2; p[2].b = 3;

    p[3].a = 8; p[3].b = 2;

    p[4].a = 1; p[4].b = 4;

    for(int i=0; i<5; i++)

    {

        q.push(p[i]);

    }

    while(!q.empty())

    {

        node st=q.top();

        printf("%d %d\n",st.a,st.b);

        q.pop();

    }

    return 0;

}

4.stack 栈

stack的头文件 <stack>.

定义stack对象的示例代码如下：

stack<int> s1;
stack<string> s2;

Stack 操作：

入栈 ：q.push(x);

出栈 ：q.pop(); 注意，出栈操作只是删除栈顶元素，并不返回该元素。

访问栈顶 ：q.top();

判断栈空 ：q.empty(); 当栈空的时， 返回true。

访问栈中的元素个数 ：q.size();

5. List  双向链表

List1的元素(1,2,3)  list2(4,5,6);

list<int>::iterator  it;

 

List 构造函数

list<int>L  //空链表

list<int>L1(9)   //建一个含个默认值的元素的链表

list
<int > L2 (5,1); // 建一个含个元素的链表，值都是.

list
<int > L3 (L2 );  // 建一个L 2 的 copy
链表

list
<int > L4 (L0 .begin (), L0 .end ());// 建一个含 L0 一个区域的元素

 

assign()
分配值，有两个重载

L1.
assign ( 4,3);           // L1(3,3,3,3)

L1.
assign( ++list1.beging(), list2.end());  
// L 1(2,3)

 

operator=赋值重载运算符

L1 =
list1;   // L1 (1,2,3)

front()
返回第一个元素的引用

int n
= list1.front()    // n= 1

back()
返回最后一元素的引用

int n
= list1.back()     // n = 3

begin()
返回第一个元素的指针(iterator)

it =
list1.begin();    // *it = 1
end() 返回最后一个元素的下一位置的指针(list
为空时end()=begin())

it =
list1.end();--it;         // *it = 3

rbegin()
返回链表最后一元素的后向指针(reverse_iterator
or const)

list
<int >::reverse_iterator it = list1 .rbegin ();  // *it = 3

rend()
返回链表第一元素的下一位置的后向指针

list<
int>::reverse_iterator it = list1 .rend(); // *(--riter) = 1

push_back()
增加一元素到链表尾

list1.push_back(
4)       // list1(1,2,3, 4 )

push_front()
增加一元素到链表头

list1.push_front(
4)      // list1( 4 ,1,2,3)

pop_back()
删除链表尾的一个元素

list1.pop_back(
)          // list1(1,2)

pop_front()
删除链表头的一元素

list1.pop_front()
　         // list1(2,3)

clear()
删除所有元素

list1.clear();   // list1 空了,list1.size()
= 0；

erase()
删除一个元素或一个区域的元素 ( 两个重载函数)

list1.erase(
list1.begin());                //
list1(2,3)

list1.erase(
++list1.begin(),list1.end()); // list1(1)

remove()
删除链表中匹配值的元素( 匹配元素全部删除)

list 对象L1( 4
,3,5,1, 4 )

L1.remove(
4);               // L1(3,5,1);

remove_if()
删除条件满足的元素( 遍历一次链表) ，参数为自定义的回调函数

// 小于2 的值删除

bool
myFun (const int & value ) { return (value < 2); }

list1.remove_if(
myFun );    // list1(3) 　

empty()
判断是否链表为空

bool
bRet = L1.empty(); // 若L1 为空，bRet
= true ，否则bRet = false 。

max_size()
返回链表最大可能长度

list
<int >::size_type nMax = list1 .max_size ();// nMax = 1073741823

size()
返回链表中元素个数

list<
int>::size_type nRet = list1.size();     
// nRet = 3

resize()
重新定义链表长度( 两重载函数)

list1.resize(5)    // list1 (1,2,3, 0,0 ) 用默认值填补

list1.resize(5,4)    // list1 (1,2,3, 4,4 ) 用指定值填补

reverse()
反转链表:

list1.reverse(
);     // list1(3,2,1)

sort()
对链表排序，默认升序( 可自定义回调函数 )

list 对象L1(4,3,5,1,4)

L1.sort(
);                 // L1(1,3,4,4,5)

L1.sort(
greater <int >() ); // L1(5,4,4,3,1)

merge()
合并两个有序链表并使之有序

// 升序

list1.merge(list2);          // list1(1,2,3,4,5,6) list2 现为空

// 降序

L1(
3,2,1), L2(6,5,4)

L1.merge(L2,
greater <int >() ); // list1(6,5,4,3,2,1) list2 现为空

insert()
在指定位置插入一个或多个元素( 三个重载函数)

list1.insert(
++list1.begin(),9);  // list1(1,9,2,3)

list1.insert(list1.begin(),2,9);  // list1(9,9,1,2,3);

list1.insert(list1.begin(),list2.begin(),--list2.end());//list1(4,5,1,2,3);

swap()
交换两个链表( 两个重载)

list1.swap(list2);   // list1 （4 ，5 ，6 ）
list2 （1 ，2 ，3 ）

unique()
删除相邻重复元素

L1(
1, 1 ,4,3,5,1)

L1.unique(
);         // L1(1,4,3,5,1)

 

list成员	说明
constructor	构造函数
destructor	析构函数
operator=	赋值重载运算符
assign	分配值
front	返回第一个元素的引用
back	返回最后一元素的引用
begin	返回第一个元素的指针(iterator)
end	返回最后一个元素的下一位置的指针
rbegin	返回链表最后一元素的后向指针(reverse_iterator or const)
rend	返回链表第一元素的下一位置的后向指针
push_back	增加一元素到链表尾
push_front	增加一元素到链表头
pop_back	pop_back()删除链表尾的一个元素
pop_front	删除链表头的一元素
clear	删除所有元素
erase	删除一个元素或一个区域的元素(两个重载)
remove	删除链表中匹配值的元素(匹配元素全部删除)
remove_if	删除条件满足的元素(遍历一次链表)，参数为自定义的回调函数
empty	判断是否链表为空
max_size	返回链表最大可能长度
size	返回链表中元素个数
resize	重新定义链表长度(两重载函数)
reverse	反转链表
sort	对链表排序，默认升序
merge	合并两个有序链表并使之有序
splice	对两个链表进行结合(三个重载函数) 结合后第二个链表清空
insert	在指定位置插入一个或多个元素(三个重载函数)
swap	交换两个链表(两个重载)
unique	删除相邻重复元素

6.

(1)头文件#include<vector>.

(2)创建vector对象，vector<int> vec;

(3)尾部插入数字：vec.push_back(a);

(4)使用下标访问元素，cout<<vec[0]<<endl;记住下标是从0开始的。

(5)使用迭代器访问元素.

vector<int>::iterator it;

for(it=vec.begin();it!=vec.end();it++)

cout<<*it<<endl;

(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();

Vector 还可以这样定义：vector<int>g[1000];

7.map

map是键-值对的集合。map类型通常可理解为关联数组。

map的头文件：#include<map>;

map对象的定义：

 map<string,int>q; map<int,int>q;
map<string,node>q; map<int,node>; map<int,string>q;

map添加元素：

如：map<int,string>q; q[100]=”adnsnd”;

还可以：q.insert(pair<int,string>(100,”adnsnd”));

q.insert(map<int,string>::value_type(100,”adnsnd”)) ;

map查找并读取元素：

如map<int,string>q;

最简单的方法：int n=q[“dadad”];

q.count(x); 返回q中x出现的次数。

判断q中x是否出现过可以这样：

if(q.find(x)==q.end())
//x在没有在q中出现过。

使用迭代器判断：

map<int,string>::iterator
it=q.find(x);

if(it!=q.end())
//x在q中出现过。

map中删除元素：

q.erase(x)//删除q中键为x的元素。返回size_type类型的值，表示删除的元素的个数。

map对象的迭代遍历：

map<int,string>::const_iterator
it=q.begin();

While(it!=q.end())

{

printf(“%d %d\n”,it-first,it-second);

it++;

}

7.set

头文件：#include<set>

set对象的定义：set<int>ivec;

set中添加元素：

ivec.insert(10);

set中获取元素

ivec.find(x);

判断x是否在ivec中出现过可以用：

ivec.find(x); 也可以用
ivec.count(x);这里count的返回值只能是1或0。

set的遍历；

set<int>::iterator
it=ivec.begin();

While(it!=q.end())

{

printf(“%d ”,*it);

it++;}

set的删除元素：

it=ivec.find(x);

ivec.erase(it);

set 的lower_bound/upper_bound的用法：

使用迭代器 set<int>::iterator itlow,itup;

itlow=ivec.lower_bound(x);

itup=ivec.upper_bound(x);

lower_bound返回的是在ivec中大于或等于x的第一个数的位置，upper_bound返回的是在ivec中大于x的第一个数的位置；

 

 

位运算：

12.1 位运算符和位运算

运算符　　含义

&　　　　按位与

|　　　　按位或

^ 　　　按位异或

~　　　　取反

<< 　　左移

>> 　　右移

说明：

（1）位运算符中除 ~ 外，均为二目运算符，即要求出侧各有一个运算量。

（2）运算早只能是整型或字符型的数据，不能为实型数据。

1.按位与运算符 &

参加运算的两个数制，按二进制进行与运算。如果两个相应的二进位数为1，刚该位的结果为 1 否则为 0 即：

　　0 & 0 = 0；0 & 1 = 0；1 & 0 = 0；1& 1 = 1

例如：3 & 8 并不等于8，应该是按位与

3 = 00000011

5 = 00000101 &

     
00000001

因此 3 & 5 的值得 1，如果参加 & 是负数（-3 & -5），则以补码形式表示为二进制数。然后按位进行与运算

按拉与有一些特殊的用途：

　　（1）清零。如果想将一个单元清零，即使其全部二进位为 0，只要找一个二进制数，其中各个位符合以下条件：原来数中为 1 的位，新数中相应位为 0。然后使二者进行 & 运算，即可以达到清零目的。

　　（2）取一个数中某些指定位。如有一个整数 a （2个字节）想要其中的低字节。只需将 a 与(337)。按位与即可。

　　（3）要想将哪一个保留下来，就与一个数进行 & 运算，此数在该位位1，如有一个数 01010100，想把其中左面第3，4，5，7，8可以这样运算：

01010100

00111011 &

00010000

2.按位或运算符 |

两个相应的二进位中只要有一个为 1，该位的结果就为 1。

0|0=0; 0|1=1; 1|0=1; 1|1=1;

　　按位或运算常用来对一个数据的某些位定值为1，如 a 是一个整数（16位）有表达式 a & 0377，则低 8 位全置为 1。高 8 位保留原样。

3. 异或运算符 ^

异或运算符 ^ 也称 XOR 运算符。它的规则是若参加运算的两个二进位同号，则结果为0，异号则为1。即 0^0=0; 0^1=1; 1^0=1;1^1=0;

（1）使特定位翻转

假设有 01111010，想使其低4 位翻转，即 1 变为 0，0 变为 1，可以将它与 00001111进行 ^ 运算，即

01111010

00001111 ^

01110101

结果值的低 4 位正好是原数低4位的翻转。

（2）与 0 相 ^ 保留原值

如 012 ^ 00 = 012

00001010

00000000 ^

00001010

因为原数中的 1 与 0 进行 ^ 运算得 1，0 与 1 运算得 0，故保留原数。

（3）交换两个值，不用临时变量

假如 a = 3, b = 4。想将 a 和 b 的值互换，可以用以下赋值语句实现：

　　a = a ^ b;

　　b = b ^ a;

　　a = a ^ b;

4. 取反运算符 ~

~是一个头单目运算符，用来对一个二进制按位取反，即将 0 变 1，1变 0。例如~25 是对八进制数 25 （即 00010101）按位取反。

00000000 00010101

11111111 11101010 ~

　　~运算符的优先级别比算术运算符，关系运算符，逻辑运算符和其它运算符都高，例如：~a & b，先进行 ~a 然后进行 & 运算。

5.左移运算符 <<

用来将一个数各二进位全部左移若干位。例如：

　　a = a << 2;

将 a 的二进制数左移 2 位，右补 0，若 a = 15，即二进制数 00001111，左移2位得到 00111100，即十进制数60.

　　高位左移后溢出，舍弃不起作用。

　　左移一位相当于该数乘以2。但些结论只适用于该数左移时被溢出舍弃的高位中不包含1 的情况。

　　左移比乘法运算快得多，有些C编译程序自动将乘2的运算用左移来实现。

6. 7.右移运算符 >>

a >> 2 表示将 a 的各二进位右移 2 位。移到右端的低位被舍弃，对无符号数，高位补 0。如 a = 017 时：

a = 00001111 >> 2

00000011

　　右移一位相当于除以 2 ，右移 n 位相当于除于 2^n。

在右移时，需要注意符号位问题。对无符号数，右移时左边高位移入 0。对于有符号的值，如果原来符号位为 0 （该数为正），则左边也是移入 0，如果上例表示的那样，如果符号位原来为 1（该数为负），则左边移入的 0 还是 1 ，要取决于所用的计算机系统。移入 0 称为逻辑右移，即简单右移。移入 1 称为算术右移

7.位运算赋值运算符

位运算符与赋值运算符可以组成复合赋值运算符。

　　如：&=， |=， >>|, <<=, ^=

8.不同长度的数据进行位运算

如果两个数据长度不同（例如 long 型和 int 型）进行位运算时（如 a & b 而 a 为 long型，b 为 int 型），系统会将二者按右端对齐。如果 b 为正数，则左侧 16 位补满 0。若 b 为负数，左端应补满 1。如果 b 为无符号整数型，则左侧补满 0。