@TOC)

数据结构—栈

栈的概念

要想学习一个东西，概念是一定要看并且理解的，那么栈是个什么玩意呢？

可以用下图来理解，非常简单。

其实也就是只有一个口是进元素和出元素的，进入元素叫做入栈，出去元素则叫出栈。由于其结构特性，所以总结为先进后出，或者叫做后进先出。

以上就是栈的结构描述和基本了解。下面就该是栈的实现了。

栈的实现

由于栈只是提供了一种数据存储的思路，所以具体怎样来实现选择其实是并不确定的，通常来说栈的实现是通过数组或者链表实现，而数组实现的栈叫做顺序栈，链表实现的栈叫做链栈。通常来说，顺序栈比较好写一点，而且用起来其实比链栈也更优一些。比较一下两者结构，很容易发现由于链表并不适合尾插，所以数组在尾上插入数据的代价比较小。

这里我们就实现比较优的顺序栈了。

typedef int DateType;

typedef struct Stack
{
   
   
    DateType* arr;
    size_t top;//栈顶
    size_t capacity;//容量
}Stack;

//初始化栈
void StackInit(Stack* ps);
//销毁栈
void StackDestroy(Stack* ps);

//入栈
void StackPush(Stack* ps,DateType x);
//出栈
void StackPop(Stack* ps);

//获取栈顶元素
DateType StackTop(Stack* ps);
//获取栈的有效元素个数
size_t StackSize(Stack* ps);
//判断栈是否为空
bool StackEmpty(Stack* ps);

上面就是实现一个顺序栈要去完善的接口，栈相对于之前的链表来说实在是过于简单。

typedef int DateType;

typedef struct Stack
{
   
   
    DateType* arr;
    size_t top;//栈顶
    size_t capacity;//容量
}Stack;

//初始化栈
void StackInit(stack* ps)
{
   
   
    assert(ps);
    DateType* tmp = (DateType*)malloc(sizeof(DateType)*INITNUM);
    if (tmp == NULL)
    {
   
   
        perror("StackInit fail\n");
        return;
    }
    ps->arr = tmp;
    ps->capacity = INITNUM;//默认容量
    ps->top = 0;//栈顶的下一个下标
}

//销毁栈
void StackDestroy(stack* ps)
{
   
   
    assert(ps);
    free(ps->arr);
    ps->arr = NULL;
    ps->capacity = 0;
    ps->top = 0;
}

//入栈
void StackPush(stack* ps, DateType x)
{
   
   
    assert(ps);
    //检查容量是否需要扩容
    if (ps->capacity == ps->top)
    {
   
   
        DateType* tmp = (DateType*)realloc(ps->arr, sizeof(DateType) * ps->capacity * 2);
        if (tmp == NULL)
        {
   
   
            perror("StackPush fail\n");
            return;
        }
        ps->arr = tmp;
        ps->capacity *= 2;
    }

    ps->arr[ps->top++] = x;
}
//出栈
void StackPop(stack* ps)
{
   
   
    assert(ps);
    assert(!StackEmpty(ps));

    ps->top--;
}

//获取栈顶元素
DateType StackTop(stack* ps)
{
   
   
    assert(ps);
    assert(!StackEmpty(ps));

    return ps->arr[ps->top - 1];
}
//获取栈的有效元素个数
size_t StackSize(stack* ps)
{
   
   
    assert(ps);

    return ps->top;
}
//判断栈是否为空
bool StackEmpty(stack* ps)
{
   
   
    assert(ps);

    return ps->top == 0;
}

其实并不难对不对，其中需要注意的点只有几处，

第一处需要注意的是：

在初始化的啥时候，top赋值成0还是-1，所代表的含义是不同的，这里我选择了0，每次压入一个数据，top就要++一次，所以top代表的其实是栈顶下一个位置的下标，所以在获取栈顶元素的时候返回的是arr[top-1]

第二处需要注意的是：

在出栈的时候top是不能一直--的，因为top最多到0，所以专门封装了一个函数StackEmpty来判断栈是否为空。

除了以上两处，也就没有什么特别需要注意的地方了，上面就是顺序栈的实现。

数据结构—队列

队列的概念和结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)
入队列：进行插入操作的一端称为队尾
出队列：进行删除操作的一端称为队头

队列实际上比栈还要简单，因为只需要控制一头用来进，一头用来出即可。

队列的实现

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

下面就用代码来实现队列的结果，

// 链式结构：表示队列 
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);

以上是实现队列的接口，

typedef int DateType;
//注意理清楚两个结构体之间的关系
typedef struct QueueNode
{
   
   
    struct QueueNode* next;
    DateType data;
}QNode;
typedef struct Queue
{
   
   
    QNode* head;
    QNode* tail;
    size_t size;
}Queue;
void QueueInit(Queue* ps)
{
   
   
    assert(ps);

    ps->head = ps->tail = NULL;
    ps->size = 0;

}
void QueueDestroy(Queue* ps)
{
   
   
    assert(ps);

    QNode* cur = ps->head;
    while (cur)
    {
   
   
        QNode* next = cur->next;
        free(cur);
        cur = next;
    }
    ps->head = ps->tail = NULL;
    ps->size = 0;

}
void QueuePush(Queue* ps, DateType x)
{
   
   
    assert(ps);
    //新的节点
    QNode* newnode = (QNode*)malloc(sizeof(QNode));
    if (newnode == NULL)
    {
   
   
        perror("QueuePush fail\n");
        return;
    }
    newnode->data = x;
    newnode->next = NULL;
    //入队
    if (ps->head == NULL)
    {
   
   
        assert(ps->tail == NULL);
        ps->head = ps->tail = newnode;
    }
    else
    {
   
   
        ps->tail->next = newnode;
        ps->tail = ps->tail->next;
    }
    ps->size++;
}
void QueuePop(Queue* ps)
{
   
   
    assert(ps);
    assert(ps->head);
    //最后一个节点
    if (ps->head->next == NULL)
    {
   
   
        free(ps->head);
        ps->head = ps->tail = NULL;
    }
    else
    {
   
   
        QNode* newhead = ps->head->next;
        free(ps->head);
        ps->head = newhead;
    }
    ps->size--;
}
DateType QueueFront(Queue* ps)
{
   
   
    assert(ps);
    assert(!QueueEmpty(ps));
    return ps->head->data;
}
DateType QueueBack(Queue* ps)
{
   
   
    assert(ps);
    assert(!QueueEmpty(ps));
    return ps->tail->data;
}
bool QueueEmpty(Queue* ps)
{
   
   
    assert(ps);
    return ps->size == 0;
}
size_t QueueSize(Queue* ps)
{
   
   
    assert(ps);
    return ps->size;
}

除此了链式的队列之外，还有一些其他的特殊队列结构，例如环形队列

感兴趣的就自己去扩展了。