数据结构——栈和队列

栈和队列

栈（顺序存储）

定义栈

#define MaxSize 10 //定义栈中元素的最大个数
typedef struct
{
    int data[MaxSize];//静态数组存放栈中元素
    int top;//栈顶指针
} SqStack;

void testStack()
{
    SqStack S;//声明一个顺序栈（分配空间）
}

初始化栈

//初始化栈
void InitStack(SqStack *S)
{
    S->top=-1;//初始化栈顶指针
}

判断栈空

//判断栈空
bool StackEmpty(SqStack S)
{
    if(S.top==-1) //栈空
        return true;
    else
        return false; //不空
}

入栈

//新元素入栈
bool Push(SqStack *S,int x)
{
    if(S->top==MaxSize-1) //栈满，报错
        return false;
    S->top =S->top+1;//指针先加1
    S->data[S->top]=x;//新元素入栈
    return true;
}

出栈

//出栈操作
bool Pop(SqStack *S,int *x)
{
    if(S->top==-1) //栈空，报错
        return false;
    x=S->data[S->top];//栈顶元素先出栈
    S->top=S->top-1;//指针再减1
    return true;
}

读取栈顶元素

//读取栈顶元素
bool GetTop(SqStack S,int *x)
{
    if(S.top==-1) //栈空，报错
        return false;
    x=S.data[S.top]; //x记录栈顶元素
    return true;
}

共享栈

//共享栈
typedef struct 
{
    int data[MaxSize];//静态数组存放栈中元素
    int top0;//0号栈栈顶指针
    int top1;//1号栈栈顶指针
}ShStack;
//初始化栈
void InitShStack(ShStack *S)
{
    S->top0=-1; //初始化栈顶指针
    S->top1=MaxSize;
}

栈(链式存储)

//链栈
typedef struct Linknode
{
    int data;//数据域
    struct Linknode *next;//指针域
} *LiStack;//栈类型定义

队列（顺序存储）

定义队列

#define MaxSize 10//定义队列中元素的最大个数
typedef struct
{
    int data[MaxSize];//用静态数组存放队列元素
    int front,rear;//队头指针和队尾指针
} SqQueue;

初始化队列

//初始化队列
void InitQueue(SqQueue *Q)
{
    //初始时、队头、队尾指针指向0
    Q->rear=Q->front=0;
}
void testQueue()
{
    SqQueue Q;//声明一个队列
    InitQueue(&Q);
}

判断队列是否为空

//判断队列是否为空
bool QueueEmpty(SqQueue Q)
{
    if(Q.rear=Q.front) //队空条件
        return true;
    else
        return false;
}

入队操作

//入队操作
bool EnQueue(SqQueue *Q,int x)
{   
    if((Q->rear+1)%MaxSize==Q->front) //队列已满，报错
        return false;
    Q->data[Q->rear]=x;//将x插入队尾
    Q->rear=(Q->rear+1)%MaxSize;//队尾指针加1取模
    return true;
}

出队操作

//出队操作
bool DeQueue(SqQueue *Q,int *x)
{
    if(Q->rear==Q->front)
        return false;//队空则报错
    x=Q->data[Q->front];
    Q->front=(Q->front+1)%MaxSize;
    return true;
}

获取队头

//获取队头
bool GetHead(SqQueue Q,int *x)
{
    if(Q.rear==Q.front)
        return false;//队空则报错
    x=Q.data[.front];
    return true;
}

队列（链式存储）

定义队列

typedef struct LinkNode
{
    //链式队列结点
    int data;
    struct LinkNode *next;
} LinkNode;

typedef struct
{
    //链式队列
    LinkNode *front,*rear; //队列的队头指针和队尾指针
} LinkQueue;

初始化队列

// 初始化队列(带头结点)
void InitQueue(LinkQueue *Q)
{
    //初始时 front、rear都指向头结点
    Q->front=Q->rear=(LinkNode *)malloc(sizeof(LinkNode));
    Q->front->next=NULL;
}
// 初始化队列(不带头结点)
void InitNoHeadQueue(LinkQueue *Q)
{
    //初始时 front、rear都指向NULL
    Q->front=NULL;
    Q->rear=NULL;
}
void testLinkQueue()
{
    LinkQueue Q; //声明一个队列
    InitQueue(&Q); //初始化队列
}

判断队列是否为空

//判断队列是否为空(带头结点)
bool IsEmpty(LinkQueue Q)
{
    if(Q.front==Q.rear)
        return true;
    else
        return false;
}
//判断队列是否为空(带头结点)
bool IsNoHeadEmpty(LinkQueue Q)
{
    if(Q.front==NULL)
        return true;
    else
        return false;
}

入队操作

//新元素入队(带头结点)
void EnQueue(LinkQueue *Q,int x)
{


    LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
    s->data=x;
    s->next=NULL;
    Q->rear->next=s;//新结点插入到rear之后
    Q->rear=s;//修改表尾指针
}
//新元素入队(不带头结点)
void EnNoHeadQueue(LinkQueue *Q,int x)
{
    LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
    s->data=x;
    s->next=NULL;
    if(Q->front==NULL)
    {
        Q->front=s;
        Q->rear=s;
    }
    else
    {
        Q->rear->next=s;//新结点插入到rear之后
        Q->rear=s;//修改表尾指针
    }

}

出队操作

//队头元素出队（带头结点）
bool DeQueue(LinkQueue *Q,int *x)
{
    if(Q->front==Q->rear)
        return false;//空队
    LinkNode *p =Q->front->next;
    x=p->data;//用变量x返回队头元素
    Q->front->next=p->next;//修改头结点的next指针
    if(Q->rear==p)//此次是最后一个结点出队
        Q->rear=Q->front;//修改rear指针
    free(p);//释放结点空间
    return true;
}
//队头元素出队（不带头结点）
bool DeNoHeadQueue(LinkQueue *Q,int *x)
{
    if(Q->front==NULL)
        return false;//空队
    LinkNode *p =Q->front;//p指向此次出队结点
    x=p->data;//用变量x返回队头元素
    Q->front=p->next;//修改front指针
    if(Q->rear==p)//此次是最后一个结点出队
        Q->rear=NULL;//front指向NULL
        Q->front=NULL;//rear指向NULL
    free(p);//释放结点空间
    return true;
}