棧和隊列的插入、刪除、獲取頭尾元素操作

棧：一種特殊的線性表，其只允許在固定的一端進行插入和刪除元素操作。進行數據插入和刪除操作的一端稱爲棧頂，另一端稱爲棧底。棧又稱爲後進先出的線性表。

Stack.h

#pragma once

#include<stdio.h>
#include<assert.h>
#include<Windows.h>

typedef int DataType;

typedef struct Stack
{
    DataType* _array;
    int _top; //棧頂
    int _end;//棧底
}Stack;

// 棧的實現接口
void StackInit(Stack* s);//棧初始化
void StackPush(Stack* s, DataType x);//壓棧
void StackPop(Stack* s);//出棧
DataType StackTop(Stack* s);//棧頂元素
size_t StackSize(Stack* s);//棧大小
int StackEmpty(Stack* s);//棧判空
void StackDestory(Stack *s);//棧銷燬

Stack.c

#include"Stack.h"

void StackInit(Stack* s)//初始化棧
{
    s->_array = NULL;
    s->_end = 0;
    s->_top = 0;
}

void StackPush(Stack* s, DataType x)//壓棧
{
    assert(s);

    if (s->_end == s->_top)
    {   
        int size = (s->_end == 0) ? 5 : (s->_end) * 2;
        s->_array = (DataType*)realloc(s->_array, sizeof(DataType)*size);
        assert(s->_array);
        s->_end = size;
    }
    s->_array[s->_top++] = x;

}

void StackPop(Stack* s)//出棧

{
    assert(s);
    if (s->_top > 0)
    {
        s->_top--;
    }
}

DataType StackTop(Stack* s)//棧頂元素
{
    assert(s);
    return s->_array[s->_top - 1];

}
size_t StackSize(Stack* s)//棧大小
{
    assert(s);
    return s->_top;
}

int StackEmpty(Stack* s)//判空
{
    assert(s);
    return s->_top;
}

void StackDestory(Stack *s)//棧銷燬
{
    assert(s);

    s->_end = 0;
    s->_top = 0;

    free(s->_array);
    s->_array = NULL;
}

Test.c

#include"Stack.h"

Test()
{
    Stack s;
    StackInit(&s);

    StackPush(&s, 5);
    StackPush(&s, 4);
    StackPush(&s, 3);
    StackPush(&s, 2);
    StackPush(&s, 1);

    printf("Stack has %d element.\n", StackSize(&s));//

    while (StackEmpty(&s))
    {
        printf("%d\n", StackTop(&s));
        StackPop(&s);
    }

    StackDestory(&s);
}

int main()
{
    Test();

    system("pause");
    return 0;
}

隊列：一種特殊的線性表，特殊之處在於它只允許在表的前端（front）進行刪除操作，而在表的後端（rear）進行插入操作，和棧一樣，隊列是一種操作受限制的線性表。進行插入操作的端稱爲隊尾，進行刪除操作的端稱爲隊頭。隊列具有先進先出(FIFO)的特性順序隊列。

Queue.h

#pragma once

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<Windows.h>

typedef int DataType;


typedef struct QueueNode
{
    DataType _data;
    struct QueueNode* _next;
}QueueNode;

typedef struct Queue
{
    QueueNode* _head;
    QueueNode* _tail;
}Queue;

void QueueInit(Queue* q);//初始化隊列
void QueuePush(Queue* q, DataType x);//入隊列
void QueuePop(Queue* q);//出隊列
DataType QueueFront(Queue* q);//隊頭元素
DataType QueueBack(Queue* q);//隊尾元素
size_t QueueSize(Queue* q);//隊列元素個數
DataType QueueEmpty(Queue* q);//判空
void QueueDestory(Queue* q);//銷燬隊列
void QueuePrint(Queue *q);//打印隊列

Queue.c

#include"Queue.h"

void QueueInit(Queue* q)//初始化隊列
{
    assert(q);
    q->_head = q->_tail = NULL;
}

void QueuePush(Queue* q, DataType x)//入隊列
{
    assert(q);
    QueueNode *qNode = (QueueNode*)malloc(sizeof(QueueNode));
    assert(qNode);

    qNode->_data = x;
    qNode->_next = NULL;

    if (q->_head==NULL)//棧爲空
    {

        q->_head = q->_tail = qNode;
    }
    else//棧不爲空
    {
        q->_tail->_next = qNode;
        q->_tail = qNode;
    }

}

void QueuePop(Queue* q)//出隊列
{
    assert(q && q->_head);

    QueueNode *tmp = q->_head;
    q->_head = tmp->_next;
    free(tmp);
    tmp = NULL;
}

DataType QueueFront(Queue* q)//隊頭元素
{
    assert(q && q->_head);

    return q->_head->_data;

}

DataType QueueBack(Queue* q)//隊尾元素
{
    assert(q && q->_head);

    return q->_tail->_data;

}

size_t QueueSize(Queue* q)//隊列元素個數
{
    assert(q);

    QueueNode *tmp = q->_head;
    DataType i = 0;
    while (tmp)
    {
        i++;
        tmp = tmp->_next;
    }
    return i;
}

void QueuePrint(Queue *q)//打印隊列
{
    assert(q);

    QueueNode *tmp = q->_head;
    while (tmp)
    {
        printf("%d\n", tmp->_data);
        tmp = tmp->_next;
    }
}

DataType QueueEmpty(Queue* q)//判空
{
    assert(q);
    return q->_head == NULL ? 0 : 1;
}

void QueueDestory(Queue* q)//銷燬隊列
{
    assert(q);

    QueueNode *tmp = q->_head;
    while (tmp)
    {
        q->_head = tmp;
        tmp = tmp->_next;
        free(q->_head);
        q->_head = NULL;
    }

}

Test.c

#include"Queue.h"

Test()
{
    Queue q;

    QueueInit(&q);
    QueuePush(&q, 1);
    QueuePush(&q, 2);
    QueuePush(&q, 3);
    QueuePush(&q, 4);
    QueuePush(&q, 5);

    QueuePrint(&q);

    printf("Queue font is %d\n", (&q)->_head->_data);
    printf("Queue back is %d\n", (&q)->_tail->_data);
    printf("Queue size is %d\n", QueueSize(&q));

    QueuePop(&q);
    QueuePop(&q);
    QueuePush(&q, 7);
    QueuePush(&q, 8);
    QueuePush(&q, 9);

    while (QueueEmpty(&q))
    {
        printf("%d\n", (&q)->_head->_data);
        QueuePop(&q);
    }

    QueueEmpty(&q);

}


int main()
{
    Test();

    return 0;
    system("pause");
}