数据结构-栈，队列，数组

数据结构-栈

栈（Strack）：受限的顺序表；仅能从一端进栈，一端出栈。栈顶元素，栈顶，空栈。

常用操作：1.InitStrack（&S） 初始化栈。2.DestroyStrack（&S）销毁栈；

3.Push（&S，x）进栈 4.Pop（&S，&x）出栈。5.StrackEmpty（&S）判断栈空。

1. 栈的定义和初始化；

与顺序表相同，分为顺序栈和链栈

//顺序栈初始化:
#define maxsize 10
typedef struct {
    int data[maxsize];//静态数组
    int top;//游标
}SqStack;

bool InitStack(SqStack& S) //初始化
{
    S.top = -1;
    return true;
}

2. 判空Empty

bool Empty(SqStack& S) //判空
{
    if (S.top == -1)//判满：S.top == maxsize-1；
    return false;
    else
        return true;
}

3.进栈

//进栈；
bool Push(SqStack& S, int e) 
{
    if (S.top == maxsize - 1)//栈满
        return false;
    S.top = S.top + 1;
    S.data[S.top] = e;//S.data[++S.top]=e;简写；
    return true;
}

4.出栈

//出栈;
bool Pop(SqStack& S ,int& e) 
{
    if (S.top == -1)//空栈
        return false;
    e = S.data[S.top];//等价于:  e=S.data[S.top--];
    S.top--;
}

4.读取栈顶元素 GetTop

//读取栈顶元素；Get top；
bool GetTop(SqStack& S,int &e) 
{
    if (S.top == -1)
        return false;
    e = S.data[S.top];
}

共享栈（两个栈共用一个静态链表）

//共享栈：
#define maxsize1 20
typedef struct {
    int data[maxsize1];
    int top0;
    int top1;
}Sqstrack1;

void InitStrack(Sqstrack1& S) //初始化
{
    S.top0 = -1;
    S.top1 = maxsize ;      //栈满的条件：S.top1-S.top0==1；
}

5.链栈：（分为有头结点和无头结点）

//链栈
typedef struct Linknode{
    int data;
    struct Linknode* next;
}*LiStack;

//初始化：有节点
bool InitLiStack(LiStack& S) 
{
    S = (Linknode*)malloc(sizeof(LiStack));
    if (S == NULL)  //无节点： S=NULL；
        return false;
    S->next = NULL;   
}

6.进栈（头插法）

//进栈：(有结点）
bool PushStack(LiStack& S,int e) 
{
    Linknode* a = (Linknode*)malloc(sizeof(LiStack));
    a->data = e;
    a->next = S->next;
    S->next = a;
    //无结点时，S.data=e；
    //a.next=S；
    //S=a；
}

7.出栈（尾删）

//出栈；
bool PopStack(LiStack& S, int& e) 
{
    if (S->next == NULL)//判空
        return false;
    Linknode* P = S->next;//无头结点：
    e = P->data;          // e=S.data
    S->next = P->next;    //P=S；
    free(P);              //S=S.next；
                          //free（P）；
}

8.查栈顶元素

//查栈顶元素；(带头结点)
bool GetStack(LiStack S, int& e)
{
    if(S->next==NULL)
     return false;
    e = S->next->data;
}

队列：Queue（一端入队，另一端出队）

1.定义与初始化：

//队列Queue：操作受限的限定表；一段（队尾）输入，另一端（队头）输出；
//顺序队列和链式队列：
//顺序队列(循环)：
#define maxsize 20
typedef struct {//定义顺序队列
    int data[maxsize];
    int front;//队头指针，指向队头元素（第一个删除）的位置
    int rear;//队尾指针,指向下一个元素插入的位置
}SqQueue;

bool InitQueue(SqQueue &Q)//初始化顺序队列
{
    Q.rear = Q.front = 0;
}

2.判空：

bool EmptyQueue(SqQueue& Q) //判空
{
    if (Q.front == Q.rear)
        return true;
    else
        return false;
}

3.进队

bool EnQueue(SqQueue& Q,int e) //进队(尾插)
{
    if ((Q.rear + 1) % maxsize == Q.front)//牺牲一格空间用于判满
        return false;
    Q.data[Q.rear] = e;
    Q.rear=(Q.rear+1)%maxsize;//+1取模循环
    return true;
}

4.出队

bool DeQueue(SqQueue& Q, int& e) //出队
{
    if (Q.rear == Q.front)
        return false;
    e = Q.data[Q.front];
    Q.front = (Q.front + 1) % maxsize;
    return true;
}

5.获取队头元素：

bool GetQueue(SqQueue& Q, int& e)//获取队头元素
{
    if (Q.front == Q.rear)
        return false;
    e = Q.data[Q.front];
    return true;
}
//计算队列中元素个数：（Q.rear+maxsize-Q.front）%maxize

6.链式队列：

1定义与初始化；

//链式存储：
typedef struct LinkNode{//定义链队结点
    int data;
    struct LinkNode* next;
}LinkNode;

typedef struct {//定义链队（包含队头结点指针front，队尾结点指针rear）
    LinkNode* front;//指向头结点;或指向队头元素
    LinkNode* rear;//指向最后一个元素（队尾）
}SqQueue1;

bool InitQueue1(SqQueue1& Q1)//初始化：带头结点
{
    Q1.front = Q1.rear = (LinkNode*)malloc(sizeof(LinkNode));
    Q1.front->next = NULL;
    return true;
}
bool InitQueue1(SqQueue1& Q1)//初始化：不带头结点
{
    Q1.front = NULL;
    Q1.rear = NULL;
}

判空：

bool IsEmpty(SqQueue1& Q1) //判空
{
    if (Q1.front == Q1.rear)//Q.front.next==NULL也可以判定
        return true;
    else
        return false;
}

入队：

bool EnQueue(SqQueue1& Q1,int e) //入队，带头结点
{
    LinkNode* s = (LinkNode*)malloc(sizeof(LinkNode));
    if (s == NULL)
        return false;
    s->data = e;
    s->next = NULL;
    Q1.rear->next = s;
    Q1.rear = s;
    return true;
}
bool EnQueue1(SqQueue1& Q1, int e)//不带头结点（第一个元素入队时特殊处理。）
{
    LinkNode* s = (LinkNode*)malloc(sizeof(LinkNode));
    if (s == NULL)
        return false;
    s->data = e;
    s->next = NULL;
    if (Q1.front == NULL) //队头结点为空，队列中无元素
    {
        Q1.front = s;
        Q1.rear = s;
    }
    else 
    {
        Q1.rear->next = s;
        Q1.rear = s;
    }
    return true;
}

出队：

//出队(带头结点)
bool DeQueue(SqQueue1& Q1, int& e) 
{
    if (Q1.front == Q1.rear)
        return false;
    LinkNode* s = Q1.front->next;
    e = s->data;
    Q1.front->next = s->next;
    if (s == Q1.rear) {
        Q1.rear = Q1.front;
    }
    free(s);
    return true;
}
//出队（不带头结点）
bool DeQueue1(SqQueue1& Q1, int& e) 
{
    if (Q1.front==NULL)
        return false;
    e = Q1.front->data;
    LinkNode* s = Q1.front;
    Q1.front = s->next;
    if (s == Q1.rear)//（最后一个元素出队）
    {
        Q1.front = NULL;
        Q1.rear = NULL;
    }
    free(s);
}