栈和队列的相关知识

1.栈

 1.1栈的概念及其结构

 栈：一种特殊的线性表，只允许一端进行插入和删除元素的操作，就像一个水瓶，进水口和出水口都是一样的。在栈中进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。

入栈：栈的插入操作叫做压栈/进栈/入栈，入数据在栈顶

出栈：删除操作就叫做出栈，出数据也在栈顶

下图可以让我们更好理解栈的概念，以及入栈和出栈的过程：

1.2栈的实现 

 栈的实现一般可以使用数组或者链表实现，相较于链表，数组用来实现栈更好，因为在数组中插入数据的代价比较小。

以下是栈的实现的头文件：

 // 下面是定长的静态栈的结构，实际中一般不实用，所以我们主要实现下面的支持动态增长的栈typedef int STDataType;
#define N 10
typedef struct Stack
{
  STDataType a[N];
 int top; // 栈顶
}Stack;
// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
 STDataType* a;
 int  top; // 栈顶
 int capacity; // 容量
}Stack;
// 初始化栈
void StackInit(Stack* ps); 
// 入栈
void StackPush(Stack* ps, STDataType data); 
// 出栈
void StackPop(Stack* ps); 
// 获取栈顶元素
STDataType StackTop(Stack* ps); 
// 获取栈中有效元素个数
int StackSize(Stack* ps); 
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps); 
// 销毁栈
void StackDestroy(Stack* ps);  

以下为头文件的实现：

#include<stdio.h>
#include"stack.h"
#include<assert.h>
#include<stdlib.h>

void StackInit(Stack* ps)
{
    assert(ps);
    ps->a = NULL;
    ps->top = 0;
    ps->capacity = 0;
    

}
void StackPush(Stack* ps, STDataType data)
{
    assert(ps);
    if (ps->capacity == ps->top)
    {
        int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
        STDataType *tmp = (STDataType*)realloc(ps->a,newcapacity * sizeof(STDataType));
        if (tmp == NULL)
        {
            perror("malloc fail");
            return;
        }
        ps->a = tmp;
        ps->capacity = newcapacity;
    }
    
    
    ps->a[ps->top] =data;
    ps->top++;

}
// 出栈 
void StackPop(Stack* ps)
{
    assert(ps);
    assert(ps->top > 0);
    ps->top--;
}

STDataType StackTop(Stack* ps)
{
    assert(ps);
    return ps->a[ps->top - 1];
}

int StackSize(Stack* ps)
{
    assert(ps);
    return ps->top;
}
int StackEmpty(Stack* ps)
{
    assert(ps);
    return ps->top == 0;
}
void StackDestroy(Stack* ps)
{
    assert(ps);
    free(ps->a);
    ps->a = NULL;
    ps->top = ps->capacity = 0;

}
 

 

以下则为栈的实现：

 

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include"stack.h"
#include<assert.h>
#include<stdlib.h>
int main()
{
    Stack st;
    StackInit(&st);
    StackPush(&st, 1);
    StackPush(&st, 2);
    StackPush(&st, 3);
    StackPush(&st, 4);
    while (!StackEmpty(&st))
    {
        printf("%d", StackTop(&st));
        StackPop(&st);
    }
    StackDestroy(&st);

}

2.队列 

  2.1队列的概念及结构

队列：只允许在一端插入数据，在另一端进行删除数据操作的特殊线性表，就像羽毛球桶一样，从一头把羽毛球放入，然后从另外一头把羽毛球取出。进行插入操作的一端称为队尾，进行删除操作的一端称为队头。

    2.2队列的实现 

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。

以下为队列实现的头文件：

 // 链式结构：表示队列
typedef struct QListNode
{ 
 struct QListNode* pNext; 
 QDataType data; 
}QNode; 
// 队列的结构
typedef struct Queue

{ 
 QNode* front; 
 QNode* rear; 
}Queue; 
// 初始化队列
void QueueInit(Queue* q); 
// 队尾入队列
void QueuePush(Queue* q, QDataType data); 
// 队头出队列
void QueuePop(Queue* q); 
// 获取队列头部元素
QDataType QueueFront(Queue* q); 
// 获取队列队尾元素
QDataType QueueBack(Queue* q); 
// 获取队列中有效元素个数
int QueueSize(Queue* q); 
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q); 
// 销毁队列
void QueueDestroy(Queue* q);

以下为头文件的实现：

 

#include<stdio.h>
#include"Queue.h"
#include<assert.h>
#include<stdlib.h>
void QueueInit(Queue* q)
{
    assert(q);
    q->size = 0;
    q->front = NULL;
    q->rear = NULL;
}
void QueuePush(Queue* q, QDataType data)
{
    assert(q);
    QNode* newnode = (QNode*)malloc(sizeof(QNode));
    if (newnode == NULL)
    {
        perror("malloc fail");
        return;
    }
    newnode->next = NULL;
    newnode->data = data;
    if (q->rear == NULL)
    {
        q->rear = q->front = newnode;
    }
    else
    {
        q->rear->next = newnode;
        q->rear = newnode;
    }
    q->size++;
}
void QueuePop(Queue* q)
{
    assert(q);
    assert(q->size);
    if (q->front->next == NULL)
    {
        free(q->front);
        q->front = q->rear = NULL;
        q->size = 0;
    }
    else
    {
        QNode* next = q->front->next;
        free(q->front);
        q->front = next;
        q->size--;
    }
}
QDataType QueueFront(Queue* q)
{
    assert(q);
    assert(q->front);
    return q->front->data;
}
QDataType QueueBack(Queue* q)
{
    assert(q);
    assert(q->rear);
    return q->rear->data;
}

int QueueSize(Queue* q)
{
    assert(q);
    return q->size;
}
int QueueEmpty(Queue* q)
{
    assert(q);
    return q->size == 0;
}
void QueueDestroy(Queue* q)
{
    q->size = 0;
    q->front = q->rear = NULL;
}    

以下为队列的实现：

 #include<stdio.h>
#include"Queue.h"
#include<assert.h>
#include<stdlib.h>
int main()
{
    Queue st;
    QueueInit(&st);
    QueuePush(&st, 1);
    QueuePush(&st, 2);
    QueuePush(&st, 3);
    QueuePush(&st, 4);
    while (!QueueEmpty(&st))
    {
        printf("%d", QueueFront(&st));
        QueuePop(&st);
    }
    printf("/n");
    return 0;
}