数据结构-栈和队列

栈和队列都是动态集合，且在其上进行删除操作所移除的元素都是预先设定的。在栈中被删除的是最新插入的元素，栈实现的是一种后进先出的策略。队列实现的是一种先进先出的策略。栈和队列的实现方式主要有顺序存储和链式存储方式。

1栈：

• 只在一端（栈顶，Top）做插入、删除
• 插入数据：入栈（Push）
• 删除数据：出栈（Pop）
• 后入先出（LIFO）

1.1栈的顺序存储实现：

栈的顺序存储结构通常由一个一位数组和一个记录栈顶元素的变量组成。

#define MaxSize 100;
typedef struct SNode *Stack;
typedef ElementType int;
struct SNode{
    ElementType Data[MaxSize];
    ElementType Top;
}; 
//入栈Push
void Push(Stack PtrS, ElementType item)
{
    if (PtrS->Top == MaxSize-1) {
        printf("栈满");
        return;
    } else {
        PtrS->Data[++(PtrS->Top)] = item;
        return;
    }
}
//出栈Pop
ElementType Pop(Stack PtrS)
{
    if (PtrS->Top == -1) {
        printf("栈空");
        return ERROR;
    } else {
        return (PtrS->Data[(PtrS->Top)--]);
    }
}

1.2栈的链式存储方式

栈的链式存储结构是一个单链表，叫做链栈。插入和删除操作只能在链栈的栈顶进行，一般把第一个节点作为栈顶。

typedef struct SNode *Stack;
struct SNode {
    ElementType Data;
    struct SNode *Next;
};
Stack CreateStack() {
    //构建一个头结点，返回指针
    Stack S;
    S = (Stack)malloc(sizeof(struct SNode));
    S->Next = NULL;
    return S;
}
int IsEmpty(Stack S) {
    return (S->Next == NULL);
}
void Push(ElementType item, Stack S) {
    struct SNode *TmpCell;
    TmpCell = (struct SNode*)malloc(sizeof(struct SNode));
    TmpCell->Data = item;
    TmpCell->Next = S->Next;
    S->Next = TmpCell;
}
ElementType Pop(Stack S) {
    struct SNode *FirstCell;
    ElementType TopElem;
    if (IsEmpty(S)) {
        printf("栈空");
        return NULL;
    } else {
        FirstCell = S->Next;
        S->Next = FirstCell->Next;
        TopElem = FirstCell->Data;
        free(FirstCell);
        return TopElem;
    }
}

2队列

• 插入数据：入队列队尾插入
• 删除数据：出队列对头出队列
• 先进先出（FIFO）

2.1队列的顺序存储实现：

队列的顺序存储结构通常由一个一维数组和一个记录队列头元
素位置的变量front以及一个记录队列尾元素位置的变量rear组成。

#define MaxSize 100;
struct QNode {
    ElementType Data[MaxSize];
    int rear;
    int front;
};
typedef struct QNode *Queue;
void AddQ(Queue PtrQ, Elementtype item) {
    if ((PtrQ->rear + 1)%MaxSize == PtrQ->front) {
        printf("队列满");
        return;
    }
    PtrQ->rear = (PtrQ->rear+1)%MaxSize;
    PtrQ->Data[PtrQ->rear] = item;
}
ElementType DeleteQ(Queue PtrQ) {
    if (PtrQ->rear == PtrQ->front) {
        printf("队列空");
        return ERROR;
    } else {
        PtrQ->front = (PtrQ->front + 1)%MaxSize;
        return PtrQ->Data[PtrQ->front];
    }
}

2.2队列的链式存储实现：

队列的链式存储结构可以用一个单链表实现，插入和删除分别在链表两头进行。

struct Node {
    ElementType Data;
    struct Node *Next;
};
struct QNode {
    struct Node *rear;
    struct Node *front;
};
typedef struct QNode *Queue;
Queue PtrQ;
void AddQ(Queue PtrQ, ElementType item) {
    struct Node *RearCell;
    ElementType RearElem;
    RearCell = (struct Node*)malloc(sizeof(struct Node));
    RearCell->Data = item;
    PtrQ->rear->Next = RearCell;
    PtrQ->rear = PtrQ->rear->Next;
}
ElementType DeleteQ(Queue PtrQ) {
    struct Node *FrontCell;
    ElementType FrontElem;
    if (PtrQ->front == NULL) {
        printf("队列空");
        return ERROR;
    }
    FrontCell = PtrQ->front;
    if (PtrQ->rear == PtrQ->front) {
        PtrQ->front = PtrQ->rear = NULL;
    } else {
        PtrQ->front = PtrQ->front->Next;
    }
    FrontElem = FromeCell->Data;
    free(FromeCell);
    return FrontElem;
}

---