数据结构1Accepted4

链表与邻接表：树与图的存储

单链表

//数组模拟链表，即静态链表
#include <iostream>

using namespace std;

const int N = 100010;

//head 头结点
//dta[i] 结点i的值
//nxt[i] 结点i的next指针
//idx存储当前已经用到了哪个点
int head, dta[N], nxt[N], idx;

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

//将x插到头结点
void add_to_head(int x)
{
    dta[idx] = x;
    nxt[idx] = head;
    head = idx;
    idx ++ ;
}

//删除
void remove(int k)
{
    nxt[k] = nxt[nxt[k]];
}

//将x插到下标是k的结点的后面
void add(int k, int x)
{
    dta[idx] = x;
    nxt[idx] = nxt[k];
    nxt[k] = idx;
    idx ++ ;
}

int main()
{
    int m;
    cin >> m;
    
    init();
    
    while(m -- )
    {
        int k, x;
        char op;
        
        cin>>op;
        if (op == 'H')
        {
            cin >> x;
            add_to_head(x);
        }
        else if (op == 'D')
        {
            cin >> k;
            if (!k) //如果删除头结点
            {
                head = nxt[head];
            }
            remove(k-1);
        }
        else
        {
            cin >> k >> x;
            add(k-1,x);
        }
    }
    
    for (int i = head; i != -1; i = nxt[i]) cout << dta[i] << " ";
    cout << endl;
    
    return 0;
}

双链表

#include <iostream>

using namespace std;

const int N = 100010;

int m;
int e[N], l[N], r[N], idx;

// 初始化
void init()
{
    // 0表示左端点，1表示右端点
    r[0] = 1;
    l[1] = 0;
    idx = 2;
}

// 在下标是k的结点的右边，插入x
void add(int k, int x)
{
    e[idx] = x;
    l[idx] = k;
    r[idx] = r[k];
    l[r[k]] = idx;//这一步要在下一步前面
    r[k] = idx;
}

// 在下标是k的结点的左边，插入x。
// add(l[k], x)

// 删除第k个结点
void remove()
{
    l[r[k]] = l[k];// k右边的点的左指针，指向k左边的点
    r[l[k]] = r[k];// k左边的点的右指针，指向k右边的点 
}

int main()
{
    
}

栈与队列：单调队列、单调栈

模拟栈

#include <iostream>

using namespace std;

const int N = 10010;

int stk[N], tt;

// 插入
stk[ ++ tt] = x;

// 弹出
tt -- ;

// 判断栈是否为空
if(tt > 0) not empty
else empty

// 栈顶元素
stk[tt];

int main()
{
    
}

模拟队列

#include <iostream>

using namespace std;

const int N = 10010;

// 在队尾插入元素，在队头弹出元素
//(看个人习惯，队尾元素从-1开始)
int q[N], hh, tt = -1;

// 插入
q[ ++ tt] = x;

// 弹出
hh ++;

// 判断队列是否为空
if (hh <= tt) not empty
else empty

// 取出队头元素
q[hh];

int main()
{
	
}

单调栈

#include <iostream>

using namespace std;

const int N = 10010;

int n;
int stk[N], tt;

int main()
{
    cin.tie(0);// 优化输入输出速度
    ios::sync_with_stdio(false);// 优化输入输出速度
    
    cin >> n;
    
    for (int i = 0; i < n; i ++ )
    {
        int x;
        cin >> x;
        while(tt && stk[tt] >= x) tt -- ;// 将大于等于x的数据全部弹出栈
        if (tt) cout << stk[tt] << " ";// 当tt!=0，即队列不为空，说明stk[tt]就是t左侧比t小的第一个数
        else cout << "-1" << " ";// 当队列为空，说明没有找到
        
        stk[ ++ tt] = x;// 将t入队
    }
    
    return 0;
}

单调队列

#include <iostream>

using namespace std;

const int N = 1000010;

int n, k;
int a[N], q[N];// q数组存储的是下标

int main()
{
    cin >> n >> k;
    for (int i = 0; i < n; i ++) cin >> a[i];
    
    //求窗口的最小值，构造递增的单调队列
    int hh = 0, tt = -1;
    for (int i = 0; i < n; i ++ )
    {
        if (hh <= tt && i - k + 1 > q[hh]) // 队头要小于队尾（防止队列为空）且窗口的起点i-k+1要大于队头的下标（如果q[hh]的值比左端点小，说明队头节点已经不在区间中了，需要弹出）
        {
            hh ++ ;
        }
        while(hh <= tt && a[q[tt]] >= a[i]) // 队尾元素大于等于当前元素，弹出队
        {
            tt -- ;
        }
        q[ ++ tt] = i;// 加入当前元素的下标
        if (i >= k - 1 ) 
        {
            cout << a[q[hh]] << " ";// 输出最小值，即队头元素
        }
    }
    puts("");
    
    //求窗口的最大值
    hh = 0, tt = -1;
    for (int i = 0; i < n; i ++ )
    {
        if (hh <= tt && i - k + 1 > q[hh]) hh ++ ;
        while(hh <= tt && a[q[tt]] <= a[i]) tt -- ;// 队尾元素小于等于当前元素，弹出队
        q[ ++ tt] = i;
        if (i >= k - 1 ) cout << a[q[hh]] << " ";
    }
    puts("");
    
    return 0;
}

kmp

#include <iostream>

using namespace std;

const int N = 10010, M = 100010;

int n, m;
char p[N], s[M];// s为主串，p为子串
int ne[N];// ne数组表示匹配不成功时可以直接向后跳多少位

int main()
{
    cin >> n >> p + 1 >> m >> s + 1;// 字符串的下标从1开始
    
    // 求next数组，只与p串本身有关，而与s串无关（子串p自己与自己匹配）
    // i指匹配位置，j指最大匹配长度也指正在匹配的前缀的末尾
    for (int i = 2, j = 0; i <= n; i ++ )// p[1]的next数组为0，所以直接从2开始匹配 
    {
        while (j && p[i] != p[j + 1]) j = ne[j];// 如果j不为0，且当前值不匹配，j跳转到ne[j]。（当前缀与后缀的匹配中断时，j回退到上一个位置，并将p[i]与其再次进行比较，若还不相等，再次回退，直到回退到开头。）
        if (p[i] == p[j + 1]) j ++ ;// 如果当前值匹配，继续匹配下一个值 j++
        ne[i] = j;// 字符串p第i位的next值为j
    }
    
    // KMP匹配过程
    // i为主串s中所匹配到的位置，j与上面的含义不一样，为子串p中所匹配到的位置
    for (int i = 1, j = 0; i <= m; i ++)
    {
        while (j && s[i] != p[j + 1]) j = ne[j];// 如果j不为0，且当前s的值s[i]与当前p的值p[j+1]不匹配，j直接跳到ne[j] 
        if (s[i] == p[j + 1]) j ++ ;// 如果当前值匹配，继续匹配下一个值 j++
        if (j == n)//匹配成功
        {
            printf("%d ", i - n);
            j = ne[j];// //j跳到下一次可以和前面字符串匹配的位置 
        }
    }
}