数据结构_栈和队列

栈

栈的特点：遵循“先进后出，后进先出”原则；先压入栈的在栈底，后入的在栈顶，从栈顶开始拿取数据。
栈的定义

typedef int DataType;

typedef struct Stack
{
    DataType* _array;
    size_t _top; //栈顶 
    size_t _end;
}Stack;

栈的实现

void StackInit(Stack* s)
{
    assert(s);
    s->_array = NULL;
    s->_end = 0;
    s->_top = 0;
}

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

    //if (s->_end == 0)
    //{
    //  s->_end = 3;
    //  s->_array = (DataType*)realloc(s->_array, s->_end*sizeof(DataType));
    //}
    //else if (s->_top < s->_end)
    //{
    //  s->_array[s->_top++] = x;
    //}
    //else
    //{
    //  s->_end *= 2;
    //  s->_array = (DataType*)realloc(s->_array, s->_end*sizeof(DataType));
    //  s->_array[s->_top++] = x;
    //}

    if (s->_top == s->_end)
    {
        size_t size = s->_end > 0 ? s->_end * 2 : 3;
        s->_array = (DataType*)realloc(s->_array, size*sizeof(DataType));
        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);

    if (s->_top > 0)
    {
        return s->_array[s->_top - 1];
    }
    else return 0;
}

size_t StackSize(Stack* s)
{
    assert(s);

    return s->_top;
}

int StackEmpty(Stack* s)  //拍单端栈是否为空
{
    assert(s);

    return s->_top;
}

调试代码

void TestStack()
{
    Stack s1;
    StackInit(&s1);
    StackPush(&s1, 1);
    StackPush(&s1, 2);
    StackPush(&s1, 3);
    StackPush(&s1, 4);
    StackPush(&s1, 5);

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

队列

队列的特点：遵循“先进先出，后进后出”原则。
队列的定义

typedef int DataType;

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

队列的实现

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

void QueueInit(Queue* q)
{
    assert(q);

    q->_head = NULL;
    q->_tail = NULL;
}

void QueuePush(Queue* q, DataType x)
{
    assert(q);

    QueueNode* node;
    node = (QueueNode*)malloc(sizeof(QueueNode));
    node->_data = x;
    node->_next = NULL;
    assert(node);

    if (q->_head == NULL)
    {
        q->_head = q->_tail = node;
    }
    else
    {
        q->_tail->_next = node;
        q->_tail = node;
    }
}

void QueuePop(Queue* q)
{
    assert(q);

    if (q->_head != NULL)
    {
        if (q->_head == q->_tail)
        {
            free(q->_head);
            q->_head = q->_tail = NULL;
        }
        else
        {
            QueueNode* tail = q->_head;
            q->_head = q->_head->_next;
            free(tail);
        }   
    }
}

DataType QueueFront(Queue* q)
{
    assert(q);

    if (q->_head != NULL)
    {
        return q->_head->_data;
    }
    else return 0;
}

DataType QueueBack(Queue* q)
{
    assert(q);

    if (q->_tail != NULL)
    {
        return q->_tail->_data;
    }
    else return 0;
}

size_t QueueSize(Queue* q)
{
    assert(q);

    QueueNode* tail = q->_head;
    size_t x = 1;
    if (tail == NULL)
        return 0;
    while (tail != q->_tail)
    {
        x++;
        tail = tail->_next;
    }
    return x;
}

int QueueEmpty(Queue* q)  //判断队列是否为空
{
    assert(q);

    return q->_head == NULL ? 0 : 1;
}

调试代码

void TestQueue()
{
    Queue q;
    QueueInit(&q);
    QueuePush(&q, 1);
    QueuePush(&q, 2);
    QueuePush(&q, 3);
    QueuePush(&q, 4);
    QueuePush(&q, 5);

    while (QueueEmpty(&q))
    {
        printf("%d ", QueueFront(&q));
        QueuePop(&q);
    }
    printf("\n");
}