二、数据结构之栈、队列、循环队列

二、数据结构之栈、队列、循环队列

顺序栈

Stack.h

• 结构类型，函数声明：

•   #ifndef  _STACK_H_
    #define _STACK_H_
  
    typedef int SElementType;
  
    ///顺序栈
    #define STACK_INIT_SIZE 20
    #define STACK_INCREMENT 10
  
    typedef struct {
        SElementType * base;
        SElementType * top;
        int stackSize;///当前栈的大小
    }SqStack;///SequenceStack
  
    ///function--
    void InitStack(SqStack * pSqStack);
    void DestoryStack(SqStack * pSqStack);
    void ClearStack(SqStack * pSqStack);
    int IsStackEmpty(SqStack * pSqStack);
    int GetStackLength(SqStack * pSqStack);
    void GetStackTop(SqStack * pSqStack, SElementType * elem);
    void PushStack(SqStack * pSqStack, SElementType elem);
    void PopStack(SqStack * pSqStack, SElementType * elem);
  
    #endif // ! _STACK_H_
  

Stack.cpp

• 实现：

•   #include <stdio.h>
    #include <stdlib.h>
  
    #include "Stack.h"
  
    ///初始化栈，创建容量为STACK_INIT_SIZE大小的栈
    void InitStack(SqStack * pSqStack) {
        pSqStack->base = (SElementType *)malloc(STACK_INIT_SIZE * sizeof(SElementType));
        pSqStack->top = pSqStack->base;
        pSqStack->stackSize = STACK_INIT_SIZE;
    }
  
    ///销毁栈
    void DestoryStack(SqStack * pSqStack) {
        if (pSqStack->base != NULL) {
            free(pSqStack->base);
            pSqStack->base = NULL;
            pSqStack->top = NULL;
            pSqStack->stackSize = 0;
        }
    }
  
    ///清空栈
    void ClearStack(SqStack * pSqStack) {
        pSqStack->top = pSqStack->base;
    }
  
    ///判断栈是否为空
    int IsStackEmpty(SqStack * pSqStack) {
        int iRet = -1;
        if (pSqStack->base == pSqStack->top) {
            iRet = 0;
        }
        return iRet;
    }
  
    ///获取栈中元素长度
    int GetStackLength(SqStack * pSqStack) {
        int iRet = -1;
        int length = pSqStack->top - pSqStack->base;
        iRet = length;
        return iRet;
    }
  
    ///获取栈顶元素，但不出栈
    void GetStackTop(SqStack * pSqStack, SElementType * elem) {
        if (pSqStack->base != pSqStack->top) {
            *elem = *(pSqStack->top - 1);
        }
    }
  
    ///压栈
    void PushStack(SqStack * pSqStack, SElementType elem) {
        if (pSqStack->top - pSqStack->base >= pSqStack->stackSize) {
            pSqStack->base = (SElementType *)realloc(pSqStack->base, (pSqStack->stackSize + STACK_INCREMENT) * sizeof(SElementType));
            pSqStack->stackSize += STACK_INCREMENT;
            pSqStack->top = pSqStack->base + pSqStack->stackSize;
        }
        *pSqStack->top++ = elem;
    }
  
    ///出栈
    void PopStack(SqStack * pSqStack, SElementType * elem) {
        if (pSqStack->base != pSqStack->top) {
            *elem = *(--pSqStack->top);
        }
    }
  

队列

Queue.h

• 数据结构、函数声明：

•   #ifndef _QUEUE_H_
    #define _QUEUE_H_
  
    typedef int QElementType;
  
    ///结点结构类型
    typedef struct QNode {
        QElementType elem;
        QNode * next;
    }QNode, * QueuePtr;
  
    ///链表结构
    typedef struct QLink {
        QueuePtr front; //头指针
        QueuePtr rear; //尾指针
    }LinkQueue;
  
  
    ///function--
    void InitLinkQueue(LinkQueue * plQueue);
    void DestoryLinkQueue(LinkQueue * plQueue);
    void ClearLinkQueue(LinkQueue * plQueue);
    int IsLinkQueueEmpty(LinkQueue * plQueue);
    int GetLinkQueueLength(LinkQueue * plQueue);
    void EnLinkQueue(LinkQueue * plQueue, QElementType elem);
    void DeLinkQueue(LinkQueue * plQueue, QElementType * elem);
  
  
    //////////////////////////////////////////////////////
    #define SEQUENCE_QUEUE_INIT_LENGTH 3
    ///循环队列CircularQueue
    typedef struct {
        QElementType * base;//用来保存入队数据
        int front;
        int rear;
    }SqCirQueue;
  
    void InitSqCircularQueue(SqCirQueue * pSqCirQueue);
    int GetSqCircularQueueLength(SqCirQueue * pSqCirQueue);
    int IsSqCircularQueueEmpty(SqCirQueue * pSqCirQueue);
    void EnSqCircularQueue(SqCirQueue * pSqCirQueue, QElementType elem);
    void DeSqCircularQueue(SqCirQueue * pSqCirQueue, QElementType * elem);
  
    #endif // !_QUEUE_H_
  

Queue.cpp

• 实现：

•   #include <stdio.h>
    #include <stdlib.h>
  
    #include "Queue.h"
  
    //static LinkQueue plQueue;
  
    ///返回只有头结点的队列
    void InitLinkQueue(LinkQueue * plQueue) {
        plQueue->front = plQueue->rear = (QueuePtr)malloc(sizeof(QNode));
        plQueue->front->next = NULL;
        plQueue->front->elem = 0;
    }
  
    ///销毁队列
    void DestoryLinkQueue(LinkQueue * plQueue) {
        while (plQueue->front) {
            plQueue->rear = plQueue->front->next;
            free(plQueue->front);
            plQueue->front = plQueue->rear;
        }
        plQueue->front = plQueue->rear = NULL;
    }
  
    ///清空队列，即只保留头结点
    void ClearLinkQueue(LinkQueue * plQueue) {
        QueuePtr head = plQueue->front;
        plQueue->front = plQueue->front->next;
        while (plQueue->front != NULL) {
            plQueue->rear = plQueue->front->next;
            free(plQueue->front);
            plQueue->front = plQueue->rear;
        }
        plQueue->front = plQueue->rear = head;
        plQueue->front->next = NULL;
        plQueue->front->elem = 0;
    }
  
    ///队列的头始终指向链表的头结点
    int IsLinkQueueEmpty(LinkQueue * plQueue) {
        int iRet = -1;
        if (plQueue->front == plQueue->rear) {
            iRet = 0;
        }
        return iRet;
    }
  
    ///队列头结点保存队列中元素的数目
    int GetLinkQueueLength(LinkQueue * plQueue) {
        return plQueue->front->elem;
    }
  
    /// 入队
    void EnLinkQueue(LinkQueue * plQueue,QElementType elem) {
        if (plQueue->front != NULL &&plQueue->rear != NULL) {
            QueuePtr temp = (QueuePtr)malloc(sizeof(QNode));
            temp->elem = elem;
            temp->next = NULL;
  
            plQueue->rear->next = temp;
            plQueue->rear = plQueue->rear->next;
  
            plQueue->front->elem++;
        }
    }
  
    ///出队
    void DeLinkQueue(LinkQueue * plQueue, QElementType * elem) {
        if (plQueue->front->elem > 0) {
            QueuePtr temp = plQueue->front->next;
            *elem = temp->elem;
            plQueue->front->next = temp->next;
            plQueue->front->elem--;
            free(temp);
        }
    }
  
    ///初始化循环队列,0位置不存储元素，作为队列为空的标志
    void InitSqCircularQueue(SqCirQueue * pSqCirQueue) {
        pSqCirQueue->base = (QElementType *)malloc(SEQUENCE_QUEUE_INIT_LENGTH * sizeof(QElementType));
        pSqCirQueue->front = 0;
        pSqCirQueue->rear = 0;
    }
  
    ///获取队列长度，实际模长为SEQUENCE_QUEUE_INIT_LENGTH-1其中有一个位置为标志位
    ///队列头指针在队列尾指针的下一位表示队列已满
    int GetSqCircularQueueLength(SqCirQueue * pSqCirQueue) {
        return (pSqCirQueue->rear - pSqCirQueue->front + SEQUENCE_QUEUE_INIT_LENGTH) % SEQUENCE_QUEUE_INIT_LENGTH;
    }
  
    ///判断队列是否为空
    int IsSqCircularQueueEmpty(SqCirQueue * pSqCirQueue) {
        int iRet = -1;
        if (pSqCirQueue->front == pSqCirQueue->rear) {
            iRet = 0;
        }
        return iRet;
    }
  
    ///入队
    void EnSqCircularQueue(SqCirQueue * pSqCirQueue, QElementType elem) {
        if ((pSqCirQueue->rear + 1) % SEQUENCE_QUEUE_INIT_LENGTH != pSqCirQueue->front) {	 //判断队列是否满
            pSqCirQueue->base[pSqCirQueue->rear++] = elem;
            pSqCirQueue->rear = pSqCirQueue->rear % SEQUENCE_QUEUE_INIT_LENGTH;
        }
    }
  
    ///出队
    void DeSqCircularQueue(SqCirQueue * pSqCirQueue, QElementType * elem) {
        if (pSqCirQueue->front != pSqCirQueue->rear) {//判断队列是否为空
            *elem = pSqCirQueue->base[pSqCirQueue->front++];
            pSqCirQueue->front %= SEQUENCE_QUEUE_INIT_LENGTH;
        }
    }