栈和队列的基本操作

1.栈的基本操作

1.1 顺序栈的结构

typedef int DataType; 

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

---

1.2 栈的初始化

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

    s->_array = (DataType*)malloc(sizeof(DataType)*(s->_end));
}

---

1.3 入栈

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

    size_t size = 0;
    if (s->_top == s->_end)
    {
        size = s->_end > 0 ? s->_end * 2 : 3;

        DataType* p = (DataType*)realloc(s->_array, sizeof(DataType)*size);

        if (p != NULL)
        {
            s->_array = p;
            s->_end = size;
        }
    }
    s->_array[s->_top++] = x;
}

---

1.4 出栈

void StackPop(Stack* s)
{
    assert(s != NULL);

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

---

1.5 获取栈顶元素

DataType StackTop(Stack* s)
{
    assert(s != NULL);

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

---

1.6 计算栈的大小

size_t StackSize(Stack* s)
{
    assert(s != NULL);

    return s->_top;
}

---

1.7 判断栈是否为空

int StackEmpty(Stack* s)
{
    assert(s != NULL);

    return 0 == s->_top;
}

---

2.队列的基本操作

2.1 队列的链式结构

typedef int DataType;

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


typedef struct Queue
{
    QueueNode* _head; //队头指针
    QueueNode* _tail; //队尾指针
}Queue;

---

2.2 创建队列节点

QueueNode* BuyQueueNode(DataType x)
{
    QueueNode* cur = (QueueNode*)malloc(sizeof(QueueNode));
    QueueNode* newNode = NULL;
    if (NULL != cur)
    {
        newNode = cur;
        newNode->_data = x;
        newNode->_next = NULL;

        return newNode;
    }
    else
    {
        return NULL;
    }
}

---

2.3 初始化队列

void QueueInit(Queue* q)
{
    assert(q != NULL);

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

---

2.4 入队

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

    QueueNode* cur = BuyQueueNode(x);
    if (q->_tail == NULL)
    {
        q->_tail = cur;
        q->_head = cur;
    }
    else
    {
        q->_tail->_next = cur;
        q->_tail = cur;
    }
}

---

2.5 出队

void QueuePop(Queue* q)
{
    assert(q != NULL);

    if (q->_head == q->_tail && q->_head != NULL) //只有一个元素
    {
        free(q->_head);
        q->_head = NULL;
        q->_tail = NULL; 
    }
    else if (q->_head != q->_tail)
    {
        QueueNode* cur = q->_head ->_next;
        free(q->_head);

        q->_head = cur;
    }
}

---

2.6 获取队头元素和队尾元素

DataType QueueFront(Queue* q)//获取队头元素
{
    assert(q != NULL);

    return q->_head->_data;
}


DataType QueueBack(Queue* q)//获取队尾元素
{
    assert(q != NULL);

    return q->_tail->_data;
}

---

2.7 计算队的大小

size_t QueueSize(Queue* q)
{
    assert(q != NULL);

    size_t count = 0;
    QueueNode* cur = q->_head;

    while (cur != NULL)
    {
        count++;
        cur = cur->_next;
    }
    return count;
}

---

2.8判断队列是否为空

int QueueEmpty(Queue* q)
{
    assert(q != NULL);

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