数据结构

1.栈

STL栈

2.队列

STL队列用法
经典例题：机器翻译

3.链表

STL链表用法
　　经典例题：队列安排
　　本题提示：erase可以删除迭代器指向的元素，remove可以删除某个特定值的元素，erase效率比remove更高（见前几次TLE）

4.堆

堆的基本操作有4种：1.堆的维护；2.查询并删除堆顶元素；3.插入元素；4.建堆

1. 堆的维护：设下标为curr的元素发生改变，比较改变后的值与它两个孩子的值，如果curr值最大则不用调整，如果它的一个孩子最大，则交换curr和它孩子的值，然后递归维护curr的孩子，直到curr节点无孩子或curr的值为最大。设二叉树节点数为n，则二叉树高度为O（logn），该操作最坏复杂度为O（logn）
   代码：

void update(int arr[],int curr)//curr为当前更新的节点编号
{
    int maxIndex=curr;//初始化最大值的下标为 curr
    if(2*curr<currSize && arr[2*curr]>arr[maxIndex])
        maxIndex=2*curr;
    if(2*curr+1<currSize && arr[2*curr+1]>arr[maxIndex])
        maxIndex=2*curr+1;
    if(maxIndex!=curr)
    {
        swap(arr[curr],arr[maxIndex]);
        update(arr,maxIndex);
    }
    return ;
}

2. 查询并删除堆顶元素
   返回用来保存堆的数组的第一个值。当最值从堆中删去后，堆的性质便不再满足，需要维护堆。将数组最后一个元素调至堆顶，然后从上往下维护堆。
   代码：

int heapDelete(int arr[])
{
    int val=arr[1];
    arr[1]=arr[currSize--];
    update(arr,1);
    return val;
}

3. 向堆中插入元素
   将元素插入堆的最后一个位置，自下往上更新堆。如果如果当前节点的值大于其父节点的值，则交换两个节点的值，然后自下而上更新其父节点直到更新至数组的第一个元素。
   代码：

void insert(int arr[],int val)
{
    arr[currSize++]=val;
    int temp=currSize;
    while(temp>1)
    {
        if(arr[temp]>arr[temp/2])
        {
            swap(arr[temp],arr[temp/2]);
            temp=temp/2;
        }
        else 
            break;
    }
    return ;
}

4. 建堆
   序列元素使用数组存储。假设数组下标从1开始，即其数组可以形象地表示成一棵完全二叉树，下标为1的元素为根。通过自底向上对完全二叉树进行调整，使其满足堆的性质。这里用大顶堆举例：

void CreateHeap(int a[],int len)
{
    int i,j,k,tmp;
    for(i=len/2;i>0;--i)
    {
        tmp=a[i];
        k=i;
        for(int j=i*2;j<=len;j=j*2)
        {
            if(j<len && a[j]<a[j+1])
                j++;
            if(tmp>a[j])
                break;
            a[k]=a[j];
            k=j;
        }
        a[k]=tmp;
    }
}

5.Hash

在天大白书P65有相应的概念，哈希函数的构造方法和处理碰撞的方法。

6.map

除了一般的 map<string,int>,map<int,int>,还支持map<vector< int > , int>操作
例题

7.并查集

并查集是一种树形的数据结构，用于处理一些不交集的合并和查询问题。有一个联合-查找算法(union-find algorithm)定义了两个用于此数据结构的操作：

• Find：确定元素属于哪一个子集，他可以用来确定两个元素是否属于同一个子集。
• Union：将两个集合合并为一个集合。

并查集是一种算法可以用来判断相互关联（同属一个集合）的元素属于几个集合，也可以用来判断图结构中的两点是否是联通的。
并查集板子题： HDU1232
并查集板子：

int find(int x) {//查询操作，其中包括路径压缩
  if (x == fa[x])  
	    return fa[x]; 
  return fa[x]=find(fa[x]);
}
void unionSet(int x, int y) {//合并操作
  x = find(x);//其实不用刻意写函数，直接在主函数中写亦可
  y = find(y);
  if (x == y)
    return;
  fa[x] = y; 
}

并查集当然不会只有板子题鸭。有几道变形题目要好好看看：
POJ1703
POJ1988
POJ1182 本题有一个讲的不错的博客：食物链
这些题目我自己写的代码就很好，代码很相似，有一定的规律性，推荐食用！！
这些题目应该算是带边权的并查集，要用到并查集判断元素是否已经被判定，还要再加一个距离数组判断是否属于同一个集合。
一些不太明显的并查集：
CF Cow and Snacks

8.树状数组

推荐食用博客：树状数组
树状数组的一些用途：

1. 统计子树权和 POJ3321
2. 逆序对的计算 HDU1394

9.vector

vector

10.set

set中的元素一下显著特征：

1. set中的元素都是排好序的
2. set集合中没有重复的元素
   由此更加灵活的运用set。
   更多set内容见此博客：set

例题：CodeForces - 1227B
我自己写的时候都用的是普通数组，最终报了TLE，改进后的AC代码用了set和vector，显著压缩了时间。

11.线段树

直接上板子：

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
const int maxn = 100010;
int n, m;
struct segment_tree {
    int l, r;
    ll sum, lazy;
} tree[maxn << 2];

void build(int k, int l, int r) {
    tree[k].l = l;
    tree[k].r = r;
    if (l == r) {
        cin >> tree[k].sum;
        return;
    }
    int mid = (l + r) >> 1;
    build(k << 1, l, mid);
    build(k << 1 | 1, mid + 1, r);
    tree[k].sum = tree[k << 1].sum + tree[k << 1 | 1].sum;
}

void pushdown(int k) {
    if (tree[k].l < tree[k].r && tree[k].lazy) {
        tree[k << 1].lazy += tree[k].lazy;
        tree[k << 1].sum += (tree[k << 1].r - tree[k << 1].l + 1) * tree[k].lazy;
        tree[k << 1 | 1].lazy += tree[k].lazy;
        tree[k << 1 | 1].sum += (tree[k << 1 | 1].r - tree[k << 1 | 1].l + 1) * tree[k].lazy;
        tree[k].lazy = 0;
    }
}
//区间更新
void update(int k, int l, int r, ll val) {
    pushdown(k);
    if (tree[k].l == l && tree[k].r == r) {
        tree[k].lazy += val;
        tree[k].sum += (tree[k].r - tree[k].l + 1) * val;
        return;
    }
    int mid = (tree[k].l + tree[k].r) >> 1;
    if (mid >= r) {
        update(k << 1, l, r, val);
    } else if (mid < l) {
        update(k << 1 | 1, l, r, val);
    } else {
        update(k << 1, l, mid, val);
        update(k << 1 | 1, mid + 1, r, val);
    }
    tree[k].sum = tree[k << 1].sum + tree[k << 1 | 1].sum;
}
//区间求和
ll query(int k, int l, int r) {
    pushdown(k);
    if (tree[k].l == l && tree[k].r == r) {
        return tree[k].sum;
    }
    int mid = (tree[k].l + tree[k].r) >> 1;
    if (mid >= r) {
        return query(k << 1, l, r);
    } else if (mid < l) {
        return query(k << 1 | 1, l, r);
    } else {
        return query(k << 1, l, mid) + query(k << 1 | 1, mid + 1, r);
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin >> n >> m;
    build(1, 1, n);
    while (m--) {
        int op, l, r, k;
        cin >> op >> l >> r;
        if (op == 1) {
            cin >> k;
            update(1, l, r, k);
        } else {
            cout << query(1, l, r) << endl;
        }
    }
    return 0;
}

区间修改区间求和：poj3468
单点修改区间求最大值：hdu-1754

注意
在写题时不要一味的使用STL数据结构，有时候自己写的栈、队列等可能更有效。例如POJ1028，若用STL栈要维护2个，自己写只用一个栈！

此文章加入了很多其他博主的超链接，如有侵权，麻烦告知，此文章乃个人学习所用，无任何商业企图。