数据结构(一)

链表

单链表

讲单链表及队列的实现，不使用结构体开空间
直接用数组模拟（笔试）

注意头结点head没有实际意义，只存储下标，头结点的下一个数才是数组链表的第一个数

#include <iostream>

using namespace  std;

const int N=1e5+10;

//利用数组模拟链表

int head,idx;  //head头结点，idx 存储当前已经用到了哪个点该节点为空

int e[N],ne[N];//定义数据域，指针域

void init(){
    
    head=-1;   //因为head后一开始没有数，初始化使其指向-1，那么数组链表的最后总是指向-1，可以作为遍历结束的条件
    
    idx=0;
}

void insert_h (int x){
    
    e[idx]=x;
    
    ne[idx]=head;  
    
    head=idx;
    
    idx++;
    
}


void insert(int k ,int x){
    
    e[idx]=x;
    
    ne[idx]=ne[k];
    
    ne[k]=idx;
    
    idx++;
    
}

void  remove(int k){
    
    if(k==-1)  head=ne[head];        //如果删除的是头结点，那么把下一个节点变成头结点
    
    
    else ne[k]=ne[ne[k]];
    
}

int main(){
    
    int m;
    cin>>m;
    
    init();
    
    while(m--){
        
        int k,x;//操作数
        char op;//指令数
        
        cin>>op;
        
        if(op=='H'){
            cin>>x;
            
            insert_h(x);
        }
        if(op=='D'){
            
            cin>>k;
            
            remove(k-1);
        }
        if(op=='I'){
            
            cin>>k>>x;
            
            insert(k-1,x);
        }
    }
    
    for(int i=head;i!=-1;i=ne[i])cout<<e[i]<<' ';
    
    return 0;
    
}

双链表

即多了一个指向前一个节点的指针域
此处偷懒没有设置head和tail节点，用idx=0代表头结点，idx=1代表尾节点

#include <iostream>
#include <algorithm>
using namespace std;

const int N=1e5+10;

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

int  idx;

//将r[0]作为左端点l[1]作为右端点(左端点有右边节点，右端点有左边节点)
void init(){
    r[0]=1;
    l[1]=0;
    idx=2;
    
}

void insert (int k, int x){
    
    e[idx]=x;
    l[idx]=k;
    r[idx]=r[k];
    l[r[k]]=idx;
    r[k]=idx;
    idx++;
    
    
}

void  remove(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 k,x;
        
        if(op=="L"){
           
            cin>>x;
            insert(0,x);
           
        }
        
        if(op=="R"){
            
            cin>>x;
            insert(l[1],x);
        }
        
        if(op=="D"){
            cin>>k;
            remove(k+1);   //注意k+1这个大坑  因为起始的idx是从2开始的  所以第k个插入的数对应的坐标应该是k-1+2==k+1
        }
        
        if(op=="IL"){
            cin>>k>>x;
            
            insert(l[k+1],x);
            
        }
        if(op=="IR"){
            cin>>k>>x;
            
            insert(k+1,x);
        }
        
        
    }
    for(int i=r[0]; i!=1;i=r[i]) cout<<e[i]<<' ';
    

        
    
    
    return 0;
}

模拟栈

注意tt是栈顶指针从-1开始，每次入栈时应当使其先++

#include <iostream>

using namespace  std;

const int N =1e5+10;

int skt[N],tt;  //定义栈和栈顶指针

void push(int x){
    
    skt[++tt]=x;
    
}

void pop(){
   tt--;
}

void empty(){
    
    if(tt==-1)cout<<"YES"<<endl;
    else cout<<"NO"<<endl;
}

void query(){
    
    cout<<skt[tt]<<endl;
}


int main(){
    
    tt=-1;
    
    int m,x;
    cin>>m;
    
    while(m--){
        string op;
        
        cin>>op;
        
        if(op=="push"){
            cin>>x;
            push(x);
        }
        
        if(op=="pop"){
            
            pop();
            
        }
        
        if(op=="empty"){
            empty();
        }
        
        if(op=="query"){
            query();
        }
        
    }
    
    
    return 0;
    
}

模拟队列

注意hh为头指针tt为尾指针，初始化时因为从队列尾入队，所以队列应该提前++那么tt初始化的值应该为-1，而头指针只需要指向0，，因此当hh-tt=1时或tt<hh时队列是空队列

#include <iostream>

using namespace  std;

const int N =1e5+10;

int q[N],  hh  ,tt;  //定义队列，队头和队尾

void push(int x){
    q[++tt]=x;
}

void pop(){
    hh++;
    
}

void empty(){
    if(hh-tt==1)cout<<"YES"<<endl;
    else  cout<<"NO"<<endl;
    
}

void query(){
    
    cout<<q[hh]<<endl;
}


int main(){
    
    hh=0;
    tt=-1;
    
    
    int m,x;
    cin>>m;
    
    while(m--){
        string op;
        
        cin>>op;
        
        if(op=="push"){
            cin>>x;
            push(x);
        }
        
        if(op=="pop"){
            
            pop();
            
        }
        
        if(op=="empty"){
            empty();
        }
        
        if(op=="query"){
            query();
        }
        
    }
    
    
    return 0;
    
}

单调栈

写一下单调栈的大概思路
单调栈的题目基本只有找寻符合条件的最近的点

其基本思路：
如例题：

• 找寻每个点左边第一个比他小的数,假设需要完成此操作的数组数据依次入栈
• 我们的目标是使其在每插入一个新的数据之前使之变成一个单调序列（从小到大）
• 注意这个变成单调序列并不是指把他排序
  而是要将所有类似于a[i]>a[j]且i<j的a[i]值去除掉

类似于这个图，倘若插入的点是a[j]那么我们把a[i]弹出栈，知道a[i]<a[j]为止
使其变成如下的单调栈

为什么要变成这样的单调栈：

• 1这时插入点前面的a[i]值就是要寻找的答案
• 2其次这种操作可以避免接下来的重复比较 剩余的数一定是优于剔除的数的优解，而出栈后的数就成为垃圾数据不会再次入栈，所以时间复杂度为O（n） 减少了正常排序的时间

#include <iostream>

using namespace std;

const int N=1e5+10;

int q[N];

int n,tt;//定义操作次数，以及栈顶指针

int main(){
    
    
    cin>>n;
    
    tt=0;
    
    for(int i=0;i<n;i++){
        
        int x;
        
        cin>>x;
        
        while(tt&&q[tt]>=x)tt--;
        
        if(tt)cout<<q[tt]<<" ";         //如果找到tt输出q[tt]
        
        else  if(!tt)cout<<"-1"<<' ';  //如果没有找到，则tt坐标应该为0，注意q[0]没有存数，此时输出-1
        
        q[++tt]=x;                 //操作结束，将操作数入栈
        
      }
    
    return 0;
    
}

单调队列

滑动窗口

同样是单调栈的做法，每次将队列中冗余的部分删除使之具有局部单调性，那么就可以直接求出最小值，最大值可以镜像的求一遍

#include<iostream>

using namespace std;

const int N =1e6+10;

int a[N],q[N];   //原数组，单调队列(存储下标)

int n,k;

int hh,tt;//队头和队尾

int main(){
    
    cin.tie(0);
    
    ios::sync_with_stdio(false);
    
    cin>>n>>k;
    
    hh=0,tt=-1;
    
    for(int i=0;i<n;i++)cin>>a[i];
    
    for(int i=0;i<n;i++){
        
        //i为窗口尾，i-k+1为窗口头
        
        if(hh<=tt&&q[hh]<i-k+1)hh++;     //如果队列不为空并且q[hh]的坐标在窗口头之外，hh++

//ps:一开始想写成tt-hh+2>k用的是队列里的下标，是不对的，把大的元素剔除只是理想状况，但是窗口并不能"跳过元素"，即使"剔除"也仍旧存在于a[N]当中，还是要以实际的数组下标为准
        
        while(hh<=tt&&a[q[tt]]>=a[i])tt--;  //如果队列不为空并且新插入进队列的数小于队列尾，把它出队
        
        q[++tt]=i;                       //将新插入的数入队
        
        if(i-k+1>=0)cout<<a[q[hh]]<<" ";        //由于是线性队列，队头的数必然是窗口的最小值，输出它
        
        
    }
        cout<<endl;
        
        hh=0;tt=-1;
        
        //对称的求最大值
        for(int i=0;i<n;i++){
            
        if(hh<=tt&&q[hh]<i-k+1)hh++;    
        
        while(hh<=tt&&a[q[tt]]<=a[i])tt--;  
        
        q[++tt]=i;                       
        
        if(i>=k-1)cout<<a[q[hh]]<<" ";        
        
    }
    
    return 0;
    
}

kmp字符串

找到在长字符串（蓝色）中所有匹配的短字符串（红色）的所有起始坐标
暴力做法是依次比较
kmp的思路是：
每次将已经达到部分匹配的红字符串向后移动最少的位置，能使最长的部分与蓝字符串重新匹配，如图所示，移动的最小距离就是next数组（返回的是移动后的j的下标）
而暴力做法就是每次移动一位，kmp想要移动的就是最理想的距离

ne数组的实现过程以及匹配过程
P：短串
S：长串
求ne数组就是以短串本身作为模板串，并对自身匹配
比如求ababab的ne数组，其最短子串是a，自身没有与其相等的部分，所以ne[1]=0,然后是ab，自身也没有与之相等的部分，所以ne[2]=0,而长度为三的子串aba则含有两个a，可以进行长度的匹配即ne[3]=1,下一次移动即可以移动到第二个a的位置

---

可以看出匹配过程和求ne数组的过程非常类似，其本质都是求匹配的过程

#include<iostream>

using namespace std;

const int N=10010,M=100010;

char s[M],p[N];

int ne[N];          //ne[N]求解的是短字符串内部的next数组，即j应该向前（或者说短字符串向后）想要达到下一次匹配的最短移动距离
  
int n,m;

int main(){
    
    cin >>n>>p + 1>>m>>s + 1;     //输入n，m，s和p数组，s和p数组下标定义从1开始
    
    //ne数组的实现,实际上是短串本身作为模板串
    for(int i=2,j=0;i<=n;i++){     //(注意i从2开始)ne[1]必等于0,因为一个字符无法拆成前后缀两部分
        
        while(j&&p[i]!=p[j+1])j=ne[j];
        
        if(p[i]==p[j+1])j++;
        
        ne[i]=j;                 //j为最大匹配的前后缀的长度     如ababa   i=5  ne[5]=3,因为最大匹配的前后缀字符串是aba
        
    }
    
    
    //匹配过程
    for(int i=1,j=0;i<=m;i++){            //使j=0，把匹配字符串和长字符串错开一位
        
        while(j&&s[i]!=p[j+1])j=ne[j];   //如果j没有前移到0并且没有找到匹配时，使j前移(j前移相当于短串相对后移)
        
        if(s[i]==p[j+1])j++;             //如果相等那么向后匹配一位，注意每次只能向后匹配一位，因为如果可以匹配多位的话，和之前假设的模板串与短串匹配长度最大相矛盾
        
        if(j==n){                        //如果j长度与需要匹配的字符串一致，输出结果，并把j移动到下一个位置
            
            cout <<i-n<<" ";
            
            j=ne[j];
            
        }
        
        
    }
    
    return 0;
}