2021-08-16

考研初试算法题合集2栈和队列/串

//栈,队列和数组
#define STACK_SIZE 100
#define STACKINCREAMENT 10
#define error 0
#define ok 1
#define OVERFLOW -2

typedef int SElemtype;
typedef int Status;
typedef char CElemtype;
//栈结点的结构

//初始化栈
typedef struct Stack{
    SElemtype *base;
    SElemtype *top;
    int stacksize;
}SqStack;
Status InitStack(SqStack&S)
{
S.base=(ElemType*)malloc(STACK_SIZE*sizeof(ElemType));
if(!S.base)exit(OVERFLOW);
S.top=S.base;
S.stacksize=STACK_SIZE;
return ok;
}

//元素入栈
Status Push(SqStack &S,ElemType e)
{
    if(S.top-S.base==S.stacksize)
    {
        S.base=(ElemType*)realloc(S.base,(S.stacksize+STACKINCREAMENT)*sizeof(ElemType));
        if(!S.base) return OVERFLOW;
        S.top=S.base+S.stacksize;
        S.stacksize+=STACKINCREAMENT;
    }
    *S.top=e;
    S.top++;
    return ok;
}//Push

//链队列的基本操作的实现
typedef int QElemType;

//定义队列结点的基本结构
typedef struct QNode{
    QElemType data;//元素值
    struct QNode *next;//指向下一个结点的指针
}QNode,*QueuePtr;

//定义链队列结构
typedef struct{
    QueuePtr front; //队头指针
    QueuePtr rear;//队尾指针
}LinkQueue;
//初始化队列
Status EnQueue(LinkQueue &Q,QElemType e){
    QNode *p;
    p=(QueuePtr)malloc(sizeof(QNode));
    if(!p)exit(OVERFLOW);
    p->data=e;
    p->next=NULL;
    Q.rear->next=p;
    Q.rear=p;
    return ok;
}
//出队列
Status DeQueue(LinkQueue Q,QElemType &e)
{
    QNode *p;
    //若队列不空，则队头元素出队列，用e返回其值并返回ok,否则返回error
    if(Q.rear==Q.front) return error;//队列为空返回error
    p=Q.front->next;//p指针指向队头元素
    e=p->data;//e来存储队头元素的值
    Q.front->next=p->next;//队头变为下一个元素
    if(Q.rear==p)//全部元素出栈后，队头即队尾
        Q.rear=Q.front;//将队置空
    free(p);
    return ok;
}

//循环队列

#define MAXSIZE 10
#define OK 1
#define ERROR 0
using namespace std;
typedef int QElemType;

//定义循环队列结构
typedef struct
{
    QElemType *base;//初始化的动态分配存储空间
    int front;//头指针，若队列不为空，指向队头元素
    int rear;//尾指针，若队列不为空，指向队尾元素的下一个位置
    //注：front，rear本身不是指针，是两个下标，类似数组的下标
}SqQueue;

//创建循环队列
Status InitQueue(SqQueue &Q)
{
    Q.base = (QElemType *)malloc(MAXSIZE *sizeof(QElemType));
    if (!Q.base) return ERROR;
    Q.front = Q.rear = 0;//初始时，头尾指针均为0;
    return OK;
}
//入队操作
Status EnQueue(SqQueue &Q, QElemType e)
{
    //将元素e插入队列Q的队尾
    if ((Q.rear + 1) % MAXSIZE == Q.front) return error;//如果队满则报错
    Q.base[Q.rear] = e;//将元素插入队尾
    Q.rear = (Q.rear + 1) % MAXSIZE;//%的作用：当Q.rear+1达到MAXSIZE时，Q.rear从0开始
}

//出队操作
Status DeQueue(SqQueue &Q,QElemType &e)
{
    if (Q.rear == Q.front) return error;//队列空则报错
    e=Q.base[Q.front];//返回队头元素的值
    Q.front = (Q.front + 1) % MAXSIZE;
   return ok;
}

//串和广义表
//
//朴素的串匹配算法
#include<string.h>
#define maxsize 100
typedef struct{
    char ch[maxsize];
    int len;
}sqtring;
int Index(sqtring S,sqtring P)
{
    int i=1,j=1;
    while(i<=S.len&&j<=P.len)
    {
         if(S.ch[i]==P.ch[j]){++i;++j;}
         else{i=i-j+2;j=1;}
         if(j>P.len)return (i-P.len);//若匹配成功返回子串P在S中的位置
         return -1;//匹配失败
    }
}

//字符串匹配

const int max_str_len = 255;//用户在255（1字节）以内定义最大串长
typedef char SString[max_str_len];//0号单元存放串的长度
int Strlength(SString S){
    int len = (int)S[0];
    return len;
}

//求next[j]数组
int Get_Index(SString P,int next[])
{
    int i,j;
    next[i]=1;next[1]=0;j=0;
    while(i<=Strlength(P)){
        if(j==0||P[i]==P[j]){
            ++i;++j;next[i]=j;
        }
        else
            j=next[j];
    }

}

//模式匹配算法 KMP算法
int Index_KMP(SString S,SString P,int pos,int next[])
{
    //返回子串T在主串S中从第POS个字符的开始的位置
    //要求T非空，1<=POS<=Strlength(S)
     int i=pos,j=1;
    while(i<=Strlength(S)&&j<=Strlength(P))
    {
        if(j==0||S[i]==P[j]){++i;++j;}
        else {j=next[j];}
    }
    if(j>Strlength(P))return (i-Strlength(P));
    return 0;
}