队列与栈基础

一.队列

只允许在一端进行插入操作，一端进行删除操作的先进先出的线性表。

这里提供顺序表和链表两种实现队列的方法。

一.顺序表实现队列

在顺序表的基础上，队列的结构定义包括如下：

typedef struct Queue{
    vector *data;
    int size, head, tail, count;
}Queue;

data指向数据存储区， size为存储区可存储的数据个数，head,tail头尾指针，count实际存储的数据个数。

队列的相关结构操作

队列的初始化：

Queue *init_Queue(int n){ //队列初始化
    Queue *p = (Queue *)malloc(sizeof(Queue));
    p -> data = init_Vector(n);
    p -> size = n;
    p -> head = p -> tail = p -> count = 0;
    return p;
}

队列销毁：

void clear(Queue *p){//销毁队列
    if(p == NULL) return ;
    clear_Vector(p -> data);
    free(p);
}

队列判空：

int empty(Queue *p){ //检查队列是否为空
    return p -> count == 0;
}

入列：

int push(Queue *p, int val){ //入列
    if(p -> count == p -> size) return 0;
    insert_Vector(p -> data, p -> tail, val);
    p -> tail += 1;
    if(p -> tail == p -> size) p -> tail = 0;
    p -> count += 1;
    return 1;
}

出列：

int pop(Queue *p){//出列
    if(empty(p)) return 0;
    p -> head += 1;
    p -> count -= 1;
    return 1;
}

读取头元素：

int front(Queue *p){ //查看队列的第一个值
    return seek_Vector(p -> data, p -> head);
}

其中顺序表的相关结构操作如下：

typedef struct vector{
    int *data;
    int size;
}vector;

vector *init_Vector(int n){ //顺序表初始化
    vector *p = (vector*)malloc(sizeof(vector));
    p -> data = (int*)malloc(sizeof(int) * n);
    p -> size = n;
    return p;
}
int insert_Vector(vector *p, int pos, int val){//顺序表的插入
    if(pos < 0 || pos >= p -> size) return 0;
    p -> data[pos] = val;
    return 1;
}
int seek_Vector(vector *p, int pos){//查看顺序表指定位置的值
    if(pos < 0 || pos >= p -> size) return -1;
    return p -> data[pos];
}
void clear_Vector(vector *p){//顺序表销毁
    if(p == NULL) return ;
    free(p -> data);
    free(p);
    return ;
}

二.链表实现队列

在链表的基础上，队列的结构定义包括：

typedef struct Queue{
    LinkList *l;
    int count;
}Queue;

一个链表和记录当前队列存储元素的个数。

队列的相关结构操作

队列初始化：

Queue *init_Queue(){ //初始化队列
    Queue *p = (Queue*)malloc(sizeof(Queue));
    p -> l = init_LinkList();
    p -> count = 0;
    return p;
}

队列销毁：

void clear(Queue *p){ //队列销毁
    if(p == NULL) return ;
    clear_LinkList(p -> l);
    free(p);
    return ;
}

队列判空：

int empty(Queue *p){ //队列检查是否为空
    return p -> count == 0;
}

读取头元素：

int front(Queue *p){ //查看队列的第一个值
    if(p == NULL) return 0;
    return front_LinkList(p -> l);;
}

入列：

int push(Queue *p, int val){//入列
    insert_LinkList(p -> l, val);
    p -> count += 1;
    return 1;
}

出列：

int pop(Queue *p){//出列
    erase_LinkList(p -> l);
    p -> count -= 1;
    return 1;
}

相应的链表的结构操作如下：

typedef struct node{
    struct node *next;
    int data;
}node;

typedef struct LinkList{
    node head, *tail; //头结点和尾指针
}LinkList;

node *get_new_node(int val){ //创建链表节点
    node *p = (node *)malloc(sizeof(node));
    p -> data = val;
    p -> next = NULL;
    return p;
}

LinkList *init_LinkList(){//初始化链表
    LinkList *p = (LinkList*)malloc(sizeof(LinkList));
    p -> head.next = NULL;
    p -> tail = &(p -> head);
    return p; 
}
int front_LinkList(LinkList *l){ //查看链表的第一个元素
    if(l -> head.next == NULL) return 0;
    return l -> head.next -> data;
}
int insert_LinkList(LinkList *l, int val){ //在链表尾部插入一个值
    node *x = get_new_node(val);
    l -> tail -> next = x;
    l -> tail = x;
    return 1;
}
void erase_LinkList(LinkList *l){ //删除链表头部的值
    if(l -> head.next == NULL) return ;
    node *p = l -> head.next;
    l -> head.next = p -> next;
    if(l -> tail == p) l -> tail = &(l -> head);
    free(p);
    return ;
}
void clear_LinkList(LinkList *l){ //销毁链表
    node *p = l -> head.next, *q;
    while(p){
        q = p -> next;
        free(p);
        p = q;
    }
    free(l);
    return ;
}

二.栈

栈是只允许一端进行插入和删除操作的先入后出的线性表。

这里用数组实现相关操作。

栈的结构定义包括一片数据存储区，表示该区域可存储元素个数的size和指向栈顶元素的指针top

typedef struct Stake{
    int *data;
    int size, top;
}Stake;

栈的相关结构操作

栈的初始化：

Stake *init_Stake(int n){
    Stake *p = (Stake*)malloc(sizeof(Stake));
    p -> data = (int*)malloc(sizeof(int) * n);
    p -> size = n;
    p -> top = -1;
    return p;
}

栈的销毁：

void clear(Stake *p){
    if(p == NULL) return ;
    free(p -> data);
    free(p);
    return ;
}

栈判空：

int empty(Stake *p){
    return p -> top == -1;
}

查看栈顶元素：

int top(Stake *p){
    if(empty(p)) return 0;
    return p -> data[p -> top];
}

入栈：

int push(Stake *p, int val){
    if(p -> top + 1 == p -> size) return 0;;
    p -> top += 1;
    p -> data[p -> top] = val;
    return 1;
}

出栈：

int pop(Stake *p){
    if(empty(p)) return 0;
    p -> top -= 1;
    return 1;
}