首页 / 算法 / 【算法与数据结构】常用算法模板2

【算法与数据结构】常用算法模板2

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了【算法与数据结构】常用算法模板2，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含9938字，纯文字阅读大概需要15分钟。

内容图文

链表

单链表

一般做题中，采用数组模拟链表的方式，效率高

#include <iostream>
using namespace std;
const int N = 100010;

//head表示头结点
//value[i]存放i的值
//ne[i]存放i的next指针
//idx表示当前已经用到了多少节点
int head, value[N], ne[N], idx;

//初始化
void init(){
    head = -1;
    idx = 0;
}

//将x插入到头结点
void appendHead(int x){
    value[++idx]  = x;
    ne[idx] = head;
    head = idx;
}
//在第k个节点后，插入x
void insert(int x, int k){
    value[++idx] = x;
    ne[idx] = ne[k];
    ne[k] = idx;
}
//删除第k个节点的下一个节点
void move(int k){
    ne[k] = ne[ne[k]];
}

int main(){
    int m;
    cin>>m;
    init();
    while(m--){
        char op;
        cin>>op;
        if(op == 'H'){
            int x;
            cin>>x;
            appendHead(x);
        }else if(op == 'I'){
            int k, x;
            cin>>k>>x;
            insert(x, k);
        }else if(op == 'D'){
            int k;
            cin>>k;
            if(!k) head = ne[head];
            else move(k);
        }
    }
    //尾结点的指针域为-1
    for(int i = head; i != -1; i = ne[i]) cout<<value[i]<<' ';
    cout << endl;
}

双链表

双链表存在两个指针域，一个指向它的前一个节点，一个指向它的后一个节点

#include <iostream>
const int N = 100010;
using namespace std;

int value[N], l[N], r[N], idx;

//令0为左边的头结点  1为右边的头结点
void init(){
    r[0] = 1;
    l[1] = 0;
    idx = 2;
}

//在第k个位置的右边插入x
void insert(int k, int x){
    value[idx] = x;
    l[idx] = k;
    r[idx] = r[k];
    
    
    l[r[k]] = idx;
    r[k] = idx++;
}

//删除第k个节点
void move(int k){
    l[r[k]] = l[k];
    r[l[k]] = r[k];
}

int main(){
    int m;
    cin>>m;
    init();
    while(m--){
        string op;
        cin>>op;
        int x, k;
        if(op == "L"){
            cin>>x;
            insert(0, x);
        }else if(op == "R"){
            cin>>x;
            insert(l[1], x);
        }else if(op == "D"){
            cin>>k;
            move(k + 1);
        }else if(op == "IL"){
            cin>>k>>x;
            insert(l[k + 1], x);
        }else if(op == "IR"){
            cin>>k>>x;
            insert(k + 1, x);
        }
    }
    for(int i = r[0]; i != 1; i = r[i]) cout<<value[i]<<" ";
    cout<<endl;
    
}

栈和队列

栈

后进先出：栈顶插入和删除

#include <iostream>

const int N = 100010;
using namespace std;

int stk[N], top;

//入栈
//stk[++top] = x;

//出栈
//top--;

//判断空
//top > 0


//获取栈顶元素
//stk[top]
int main(){
    int m;
    cin>>m;
    top = 0;
    while(m--){
        string op;
        int x;
        cin>>op;
        if(op == "push"){
            cin>>x;
            stk[++top] = x;
        }else if(op == "pop"){
            top--;
        }else if(op == "empty"){
            cout<< (top ? "NO" : "YES")<<endl;
        }else if(op == "query"){
            if(top > 0) x = stk[top];
            cout<<x<<endl;
        }
    }
    return 0;
}

队列

先进先出：队头删除元素，队尾插入元素

#include <iostream>
using namespace std;
const int N = 100010;

int queue[N], tail, head;



//入队
//queue[++tail] = x;

//出队
//queue[head++] = x;


//对头
//x = queue[tail];

//判断空
//tail < head;

int main(){
    int m;
    cin>>m;
    head =  1;
    while(m--){
        string op;
        cin>>op;
        int x;
        if(op == "push"){
            cin>>x;
            queue[++tail] = x;
            
        }else if(op == "pop"){
            head++;
        }else if(op == "empty"){
            cout<<(tail < head ? "YES" : "NO") <<endl;
        }else if(op == "query"){
            if(tail >= head) x = queue[head];
            cout<<x<<endl;
        }
    }
}

单调栈

#include <iostream>
const int N = 100010;
using namespace std;


int stk[N], top;

int main(){
    int n;
    cin >> n;
    while(n--){
        int x;
        cin >> x;
        while(top && stk[top] >= x) top--;
        if(!top) cout << "-1" << " ";
        else cout << stk[top] << " ";
        // for(int i = 0; i <= top; i++)
        //     cout << stk[i] <<" ";
        // cout<<endl;
        stk[++ top] = x;
        
    }
    return 0;
}

单调队列

#include <iostream>
const int N = 1000020;
using namespace std;
int n, k;
int queue[N], a[N], tail = 0, head = 1;
int main(){
    cin>>n>>k;
    for(int i = 0; i< n; i++)
        cin >> a[i];
    for(int i = 0; i < n; i ++){
        if(head <= tail &&  i - k + 1 > queue[head]) head ++;
        while(head <= tail && a[queue[tail]] >= a[i]) tail --;
        queue[++ tail] = i;
        if(i >= k - 1) cout << a[queue[head]] << " ";
    }
    cout<<endl;
    
    head = 1, tail = 0;
    for(int i = 0; i < n; i ++){
        if(head <= tail &&  i - k + 1 > queue[head]) head ++;
        while(head <= tail && a[queue[tail]] <= a[i]) tail --;
        queue[++ tail] = i;
        if(i >= k - 1) cout<<a[queue[head]]<<" ";
    }
    cout<<endl;   
}

KMP

暴力算法如何做

//S[N]长串, p[M]短串
//暴力做法
for(int i = 1; i <= n; i++)
{
    bool flag = true;
	for(int j = 1; j <= m; j++)
        if(s[i + j - 1] != p[j])
        {
            flag = false;
            break;
        }
}    
//next[i]
//字符串的前缀集合与后缀集合的交集中最长元素的长度
//模式串中相等的前缀与后缀的最大长度
//以i为终点的后缀和从1开始的前缀相等，而且后缀的长度最长
//p[1, j] = p[i - j + 1, i];

如何去优化

//借助next数组
#include <iostream>

using namespace std;

const int N = 10010, M = 100010;

int n, m;
char p[N], s[M];
int ne[N];

int main()
{
    cin >> n >> p + 1 >> m >> s + 1;
    //求ne[j]的过程
    for(int i = 2, j = 0; i <= m; i++)
    {
        while(j && p[i] != p[j + 1]) j = ne[j];
    	if(s[i] == p[j + 1]) j++;
        ne[i] = j;
    }
    
    //KMP匹配过程
    for(int i = 1, j = 0; i <= m; i++)
    {
        //j没有退回起点
        //当前的节点与下一个节点不匹配
        while(j && s[i] != p[j + 1]) j = ne[j];
        if(s[i] == p[j + 1]) j++;
        if(j == n)
        {
            //匹配成功
            printf("%d ", i - n);
            j = ne[j];
        }
    }
}

Trie

#include <iostream>

using namespace std;

const int N = 100010;

//x节点的所有儿子存到了son[x]中
//son[x][0] x的第0个儿子
//son[x][1] x的第1个儿子

//cnt[X]以X结尾的单词个数有多少个
int son[N][26]; //每个节点的所有儿子是什么
int cnt[N]; //以当前这个节点结尾的单词数目
int idx;  //当前用到了哪一个下标
//下标是0的点，既是根节点，又是空节点

char str[N];

void insert(char str[])
{
    int p = 0;
    for(int i = 0; str[i]; i++)
    {
        int u = str[i] - 'a';
        if(!son[p][u]) son[p][u] = ++idx;
        p = son[p][u];
    }
    
    cnt[p]++;
}
int query(char str[])
{
    int p = 0;
    for(int i = 0; str[i]; i++)
    {
        int u = str[i] - 'a';
        if(!son[p][u]) return 0;
        p = son[p][u];
    }
    return cnt[p];
}
int main()
{
    int n;
    scanf("%d", &n);
    while(n -- )
    {
        char op[2];
        scanf("%s%s", op, str);
        if(op[0] == 'I') insert(str);
        else cout<<query(str)<<endl;
    }
    return 0;
}

并查集

两个操作（近乎O(1)的时间复杂度）：

将两个集合合并
1. 询问两个元素是否在一个集合当中

基本原理：每个集合用一颗树来表示，树根的编号就是整个集合的编号，每个节点存储它的父节点，p[x]表示x的父节点。

问题1. 如何判断树根 if(p[x] == x)

问题2. 如何求x的集合编号：while(p[x] != x) x = p[x];

路径压缩的思想优化：遍历到某个节点都让该节点的父节点指向整个集合

问题3. 如何合并两个集合：p[x]是x的集合编号，p[y]是y的集合编号，p[x] = y;

#include <iostream>
using namespace std;
const int N = 100010;
int n, m;
int p[N]; //存放的i的父亲节点

int find(int x) //返回x的祖宗节点 + 路径压缩
{
    if(p[x] != x) p[x] = find(p[x]);
    return p[x];
}
int main()
{
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i++) p[i] = i;
    while(m--)
    {
        char op[2]; //读入字符串可以过滤掉字符串和回车
        int a, b;
        scanf("%s%d%d", op, &a, &b);
        if(op[0] == 'M') p[find(a)] = find(b);
        else
        {
            if(find(a) == find(b)) puts("Yes");
            else puts("No");
        }
    }
    return 0;
}

并查集除了以上之外，可以额外维护一个信息。

堆

如何手写一个堆？

插入一个数
```
heap[++size] = x; up(size);
```
求集合当中最小值
```
heap[1]
```
删除最小值

将最后一个元素覆盖到堆顶元素heap[1]，再将堆顶down一遍。

原因：一维数组，删除头结点非常困难，删除尾结点比较方便size--
```
heap[1] = heap[size]; size--; down(1);
```

删除任意一个元素

方法1

x = heap[k];
heap[k] = heap[size]; size--;

if(heap[k] > x) down(k);
else up(k);

2）方法2

heap[k] = heap[size]; size--;
down(k), up(k);//只会执行一个

修改任意一个元素
```
heap[k] = x; down(k); up(k);
```

堆是一个完全二叉树。除了最后一层叶子节点外，上面节点都是非空的，叶子节点是按照从左到右的顺序排列的。

小根堆：每个点都是小于等于左右儿子的

大根堆：每个点都是大于等于左右儿子的

堆的存储：一维数组存储，1为根节点，x的左儿子2x, 右儿子2x+1

down(x): 往下调整，如果某个点的值变大了，将它往下沉，下沉的过程中与左右子节点中的最小值进行交换

int h[N], size;

void down(int u)
{
    int t = u;
    //判断左儿子
    if(u * 2 <= size && h[u * 2] < h[t]) t = u * 2;
    //判断右儿子
    if(u * 2 + 1 <= size && h[u * 2 + 1] < h[t]) t = u * 2 + 1;
    if(u != t)
    {
        swap(h[u], h[t]);
        down(t);
    }        
}

up(x): 往上调整，如果某个点的值变小了，将它往上走，上移的过程中，与父节点比较即可，如果小于父节点，交换

int h[N], size;
void up(int u)
{
	while(u / 2 && h[u / 2] > h[u])
	{
		swap(h[u / 2], h[u]);
		u /= 2;
	}
}

1~5由down和up实现

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 100010;

int n, m;
int h[N], size;

void down(int u)
{
    int t = u;
    if(u * 2 <= size && h[u * 2] < h[t]) t = u * 2;
    if(u * 2 + 1 <= size && h[u * 2 + 1] < h[t]) t = u * 2 + 1;
    if(u != t)
    {
        swap(h[u], h[t]);
        down(t);
    }    
}

int main()
{
	scanf("%d", n);
	for(int i = 1; i <= n; i++) scanf("%d", &h[i]);
	size = n;
	
	for(int i = n/ 2; i; i--) down(i); //O(n)
    
    while(m--)
    {
        printf("%d ", h[1]);
        h[1] = h[size];
        size--;
        down(1);
    }
    return 0;
	
}

哈希表

【算法与数据结构】常用算法模板2 - 文章图片

拉链法

#include <iostream>
#include <cstring>
using namespace std;
const int N = 100003;

int h[N], e[N], ne[N], idx;
void insert(int x)
{
    int k = (x % N + N) % N;
    e[idx] = x;
    ne[idx] = h[k];
    h[k] = idx++;
}
bool find(int x)
{
    int k = (x % N + N) % N;
	for(int i = h[k]; i!= -1; i = ne[i])
        	if(e[i] == x) return true;
   return false;
}

int main()
{
    int n;
    cin>>n;
    memset(h, -1, sizeof h);
    while(n--)
    {
        char op[2];
        int x;
        cin>>op>>x;
        if(*op == 'I') insert(x);
        else
        {
            if(find(x)) puts("Yes");
            else puts("No");
        }
    }
    return 0;
    
}

开放寻址法

#include <iostream>
#include <cstring>
using namespace std;
const int N = 200003, null = 0x3f3f3f;

int h[N];

bool find(int x)
{
    int k = (x % N + N) % N;
	while(h[k] != null && h[k] != x)
	{
		k++;
		if(k == N) k = 0;
	}
   return k;
}

int main()
{
    int n;
    cin>>n;
    memset(h, 0x3f, sizeof h);
    while(n--)
    {
        char op[2];
        int x;
        cin>>op>>x;
        int k = find(x);
        if(*op == 'I') 
      		h[k] = x;
        else
        {
            if(h[k] != null) puts("Yes");
            else puts("No");
        }
    }
    return 0;
}

字符串哈希

#include <iostream>
using namespace std;
tyedef unsigned long long ULL;
const int N = 100010, P = 131;
int n, m;
char str[N];
ULL h[N], p[N];

ULL get(int l, int r)
{
	return h[r] - h[l - 1] * p[r - 1 + 1]; 
}

int main()
{
	scanf("%d%d%s", &n, &m, str + 1);
	p[0] = 1;
	for(int i = 1; i <= n; i++)
	{
		p[i] = p[i - 1] * P;
		h[i] = h[i - 1] * P + str[i];
	}
	while(m--)
	{
		int l1, r1, l2, r2;
		scanf("%d%d%d%d", l1, r1, l2, r2);
		if(get(l1, r1) == get(l2, r2)) puts("Yes");
		else puts("No");
	}
	return 0;
}

STL常用的库函数

/*
vector, 变长数组，倍增的思想
	size() 返回元素个数
	empty() 返回是否为空
	clear() 清空
	倍增的思想：系统为某个程序分配空间时，所需时间与空间大小无关，与申请次数有关。
	front() back() 第一个数和最后一个数
	begin() end() 第0个数和最后一个数的下一个数
	 
string, 字符串， substr(), c_str()
queue, 队列，push(), front(), pop()
priority_queue, 优先队列，push(),top(),pop()
stack, 栈，push(), top(), pop()
deque, 双端队列
set, map, multiset, multimap 基于平衡二叉树(红黑树)来实现， 动态维护有序序列
unordered_set, unordered_map, unordered_multiset, unordered_multimap， 哈希表
bitset，压位
*/

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>

内容总结

以上是互联网集市为您收集整理的【算法与数据结构】常用算法模板2全部内容，希望文章能够帮你解决【算法与数据结构】常用算法模板2所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/636439.html

来源：【匿名】

【上一篇】基本算法-堆排序及其Java实现【下一篇】浅谈php实现映射的两种方法（链表和二叉树）

更多 ►

【【算法与数据结构】常用算法模板2】教程文章相关的互联网学习教程文章

【Java】大话数据结构(11) 查找算法(2)（二叉排序树/二叉搜索树）【代码】【图】

本文根据《大话数据结构》一书，实现了Java版的二叉排序树/二叉搜索树。二叉排序树介绍在上篇博客中，顺序表的插入和删除效率还可以，但查找效率很低；而有序线性表中，可以使用折半、插值、斐波那契等查找方法来实现，但因为要保持有序，其插入和删除操作很耗费时间。二叉排序树(Binary Sort Tree)，又称为二叉搜索树，则可以在高效率的查找下，同时保持插入和删除操作也又较高的效率。下图为典型的二叉排序树。二叉查找树具有以下...

数据结构和算法-001 数组【代码】

数组，都懂的，直接看代码吧，实现以下功能：创建数组查找在索引上的值查找数组中是否含有值删除在索引上的值添加一个值查找一个值在数组的位置public class ArrayStructures {private int[] theArray = new int[50];private int arraySize = 10;public void generateRandomArray(){for (int i =0; i< arraySize;i++){theArray[i] = (int)(Math.random()*10 + 10);}}public void printArray(){StringBuffer sb = new StringBuffer(...

数据结构和算法(Golang实现)(16)常见数据结构-字典【代码】

字典我们翻阅书籍时，很多时候都要查找目录，然后定位到我们要的页数，比如我们查找某个英文单词时，会从英语字典里查看单词表目录，然后定位到词的那一页。计算机中，也有这种需求。一、字典字典是存储键值对的数据结构，把一个键和一个值映射起来，一一映射，键不能重复。在某些教程中，这种结构可能称为符号表，关联数组或映射。我们暂且称它为字典，较好理解。如：键=>值"cat"=>2 "dog"=>1 "hen"=>3我们拿出键cat的值，就是2了...

算法与数据结构（八） HashMap源码【代码】

一存储结构 static class Node<K,V> implements Map.Entry<K,V> { final int hash; final K key; V value; Node<K,V> next;｝transient Node<K,V>[] table;内部存储的单元如上所示，整体上就是数组加链表的桶状结构。二 put操作put(key，value)内部调用的是putVal() 下面是源码 jdk1.8采用的是尾插法 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {Node<K,V>[] tab; Node<K,V...

初转java随感（一）程序=数据结构+算法【图】

大学刚学编程的时候，有一句很经典的话程序=数据结构+算法今天有了进一步认识。场景：1、当前局面（1）有现成的封装好的分页组件返回结果是page。类型为：Page。包括 page 分页信息，data 数据列表 List型。（2）查询了一个数据列表 midResult。类型为 List<Map<String,Object>> 。2、想要的结果　　现在想把page midResult 两个结果集进行处理。返回页面。3、解决问题　　首先纠结的是，用哪种类型来存储数据。用List 还是Map<St...

js:数据结构笔记11--排序算法（1）【代码】【图】

基本准备： function CArray(numElems) {this.dataStore = [];this.pos = 0;this.numElems = numElems;this.insert = insert;this.toString = toString;this.clear = clear;this.setData = setData;this.swap =swap;for(var i = 0; i < numElems; ++i) {this.dataStore[i] = i;}}function setData() {for(var i = 0; i < this.numElems; ++i) {this.dataStore[i] = Math.floor(Math.random() * 100);//0-99}}function clear() {...

数据结构与算法（1）- 数据结构概览【图】

声明：虽然本系列博客与具体的编程语言无关。但是本文作者对c++相对比较熟悉，其次是java，所以难免会有视角上的偏差。举例也大多是和这两门语言相关。今天先来看看有哪些常见的数据结构(C++ STL视角，其他应该也大同小异吧。哈哈，我猜的！)。所以之后的内容大多从STL出发，然后顺便对比下java中对应的数据结构。作为一名合格的软件开发人员，我们有时不需要深入对这些结构进行深度了解（原子级了解），但是至少我们得知道这些结构...

Java数据结构-串及其应用-KMP模式匹配算法【代码】

串（string）是由零个或多个宇符组成的有限序列，又名叫字符串。定义的解释： ??串中的字符数目n称为串的长度，定义中谈到“有限”是指长度n是一个有限的数值。 ??零个字符的串称为空串（null string），它的长度为零，可以直接用两双引号一表示，也可以用希腊Φ字母来表示。 ??所谓的序列，说明串的相邻字符之间具有前驱和后继的关系。下面是串的一些概念性东西：??空格串，是只包含空格的串。注意它与空串的区别，空格串是有内...

算法与数据结构--图的实现、基本操作及应用

#include<iostream> #include<queue> #include<stack> using namespace std;#define INFINITY DBL_MAX //无穷大 #define MAX_VERTEX_NUM 20 //最大顶点个数 enum GraphKind //图的类型 {DG,DN,UDG,UDN//有向图、有向网、无向图、无向网 };//弧结构 typedef struct ArcCell {double adj;//权值，无权图用1表示 }AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; //邻接矩阵图结构struct MGraph {int vexs[MAX_VERTEX_NUM];//顶点集合...

计算机算法学习(1) - 不相交集合数据结构【图】

不相交集合故名思意就是一种含有多个不相交集合的数据结构。典型的应用是确定无向图中连通子图的个数。其基本操作包括：Make-Set(x):建立一个新的集合，集合的成员是x；Union(x,y): 将包含x和y的集合合并为一个集合；Find-Set(x): 返回指向包含x的集合的指针；下面是一个例子，(a)是一个无向图，(b)是使用不相交集合来找连通子图的个数。做法是初始为各个顶点为一个集合，然后遍历各个边，把边的端点的集合进行合并，当处理完所有...

浅谈MySQL索引背后的数据结构及算法【代码】【图】

摘要本文以MySQL数据库为研究对象，讨论与数据库索引相关的一些话题。特别需要说明的是，MySQL支持诸多存储引擎，而各种存储引擎对索引的支持也各不相同，因此MySQL数据库支持多种索引类型，如BTree索引，哈希索引，全文索引等等。为了避免混乱，本文将只关注于BTree索引，因为这是平常使用MySQL时主要打交道的索引，至于哈希索引和全文索引本文暂不讨论。文章主要内容分为四个部分。第一部分主要从数据结构及算法理论层面讨论MySQ...

数据结构(九)——排序算法【代码】【图】

前言??上篇文章给大家介绍数据结构中一个较为常用的思想——递归。主要介绍了递归的相关概念以及通过一些案例来进一步说明递归的用法。本文介绍数据结构中排序的算法。其实我们在数据结构开始的时候介绍过数据结构中常用的十大算法。当时，我们均用C语言、java以及python将其实现，另外通过各种数据结构的可视化工具。本文主要介绍排序的分类以及算法的时间复杂度的介绍以及各大算法的实现。首先对排序算法的相关内容做相应的介绍。...

数据结构和算法(Golang实现)(4)简单入门Golang-结构体和方法【代码】

结构体和方法一、值，指针和引用我们现在有一段程序：package mainimport "fmt"func main() {// a,b 是一个值a := 5b := 6fmt.Println("a的值：", a)// 指针变量 c 存储的是变量 a 的内存地址c := &afmt.Println("a的内存地址：", c)// 指针变量不允许直接赋值，需要使用 * 获取引用//c = 4// 将指针变量 c 指向的内存里面的值设置为4*c = 4fmt.Println("a的值：", a)// 指针变量 c 现在存储的是变量 b 的内存地址c = &bfmt.Printl...

【刷题】面筋-数据结构-排序算法的复杂度、稳定性、内部外部排序【图】

复杂度图示复杂度小结O(n^2) 平方阶排序 -- 各类简单排序：直接插入、直接选择和冒泡排序。O(nlog2n) 线性对数阶排序 -- 快速排序、堆排序和归并排序；O(n1+§)) 排序，§ 是介于 0 和 1 之间的常数 -- 希尔排序O(n) 线性阶排序 -- 基数排序，此外还有桶、箱排序。内部排序和外部排序排序算法可以分为内部排序和外部排序。内部排序是数据记录在内存中进行排序。外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中...

《数据结构、算法与应用》第一章习题1.2

一年前写的一个脚本，通过爬虫技术，将网站页面上出现的email地址给扒下来，然后进行重发邮件，由于邮箱的安全机制，可能会进行阻拦(可以考虑怎么避免这样).........附代码：main.py#! /usr/bin/python # -*- coding: utf-8 -*-import re, urllib, sys, SendMailpatt2 = ‘\w+@\w+\.com‘ pattern = ‘[\w.-]+@[\w.-]+\.\w+‘if len(sys.argv) < 2:print "print mail --help for more help"sys.exit(1)if sys.argv[1].startswit...

算法与数据结构 - 相关标签

算法与数据结构

算法 - 最热教程

浅谈SQLServer查询优化器中的JOIN算法有没那种可逆算法是密文比明文短的呢？...javascript-类似Excel里面的NORMDIST函...C++中的分治算法及常见题目汇总压缩感知重构算法综述-学习笔记 c++中内置函数qsort（快速排序）和bsea...一、fpga图像处理算法整合基于遗传算法（deap）的非线性函数寻优...集成学习-Bagging集成学习算法随机森林...机器学习笔记（九）聚类算法及实践（K-...

首页 / 算法 / 【算法与数据结构】常用算法模板2

【算法与数据结构】常用算法模板2

内容导读

内容图文

链表

单链表

双链表

栈和队列

栈

队列

单调栈

单调队列

KMP

Trie

并查集

堆

哈希表

STL常用的库函数

内容总结

内容备注

内容手机端

【【算法与数据结构】常用算法模板2】教程文章相关的互联网学习教程文章

算法与数据结构 - 相关标签

算法 - 最新教程

算法 - 最热教程