数据结构之C语言实现栈与循环队列

栈的实现

从数据结构的角度看，栈是一种抽象数据类型，具有先进后出（FILO, First In Last Out）的特点，添加元素和删除元素的操作只能在【栈顶】进行

定义结构体

typedef struct myStack
{
    int *data;
    int topIndex;  // 指向栈顶元素的指针
    int maxSize;   // 栈容量
} myStack;

初始化栈【参数使用引用，这是c++语法】

栈顶指针初始化为-1

void initStack(myStack &stk, int maxSize)
{
    int *s = (int *)malloc(maxSize * sizeof(int)); // 分配空间
    stk.data = s;
    stk.topIndex = -1;
    stk.maxSize = maxSize;
}

判断栈是否为空

bool empty(myStack stk)
{
    return stk.topIndex == -1;
}

入栈操作

包含2个操作：

1. 判断栈是否已满
2. 将元素放入栈内
3. 栈顶指针+1

bool push(myStack &stk, int e)
{
    if (stk.topIndex == stk.maxSize - 1)
        return false; // 栈满，返回入栈失败
    stk.data[++stk.topIndex] = e;
    return true;
}

出栈操作

bool pop(myStack &stk)
{
    if (empty(stk))
        return false; // 栈空，返回出栈失败
    --stk.topIndex;
    return true;
}

返回栈顶元素

int top(myStack stk)
{
    return stk.data[stk.topIndex];
}

完整代码及测试

#include 
#include 

typedef struct myStack
{
    int *data;
    int topIndex;  // 指向栈顶元素的指针
    int maxSize;   // 栈容量
} myStack;

void initStack(myStack &stk, int maxSize)
{
    int *s = (int *)malloc(maxSize * sizeof(int)); // 分配空间
    stk.data = s;
    stk.topIndex = -1;
    stk.maxSize = maxSize;
}

bool empty(myStack stk)
{
    return stk.topIndex == -1;
}

bool push(myStack &stk, int e)
{
    if (stk.topIndex == stk.maxSize - 1)
        return false; // 栈满，返回入栈失败
    stk.data[++stk.topIndex] = e;
    return true;
}

bool pop(myStack &stk)
{
    if (empty(stk))
        return false; // 栈空，返回出栈失败
    --stk.topIndex;
    return true;
}

int top(myStack stk)
{
    return stk.data[stk.topIndex];
}

int getStackSize(myStack stk)
{
    return stk.topIndex + 1;
}

int main()
{
    myStack stk;
    initStack(stk, 100);
    for (int i = 1; i <= 10; i += 1)
    {
        push(stk, i * i);
    }
    while (!empty(stk))
    {
        printf("%d\t", top(stk));
        pop(stk);
    }
}

循环队列

结构体

typedef struct myQueue
{
    int *data;
    int front, rear;
    int maxSize;
} myQueue;

初始化，分配空间，设定容量，队列头、尾指针设置为0

注：这里队列的参数是指针，不是引用

void initQueue(myQueue *q, int maxSize)
{
    int *p = (int *)malloc(maxSize * sizeof(int));
    q->data = p;
    q->front = q->rear = 0;
    q->maxSize = maxSize;
}

队尾入队操作

1. 判断队列是否已满
2. 元素入队
3. 尾指针+1，rear = (rear+1) % maxSize

// 从队尾入队，返回是否插入成功
bool enQueue(myQueue *q, int e)
{
    if ((q->rear + 1) % q->maxSize == q->front)
        return false; // 队列已满
    q->data[q->rear] = e;
    q->rear = (q->rear + 1) % q->maxSize;
    return true;
}

判断队列是否为空

bool empty(myQueue q)
{
    return q.rear == q.front;
}

获取队头元素

1. 判断是否队列为空
2. 返回元素

// 通过指针参数e来返回元素
// 函数返回值表示是否返回成功
bool getFront(myQueue q, int *e)
{
    if (empty(q))
        return false;
    *e = q.data[q.front];
    return true;
}

队头出队操作

1. 判断是否为空队列
2. 队头指针+1，front = (front+1) % maxSize

bool deQueue(myQueue *q)
{
    if (empty(*q))
        return false;
    q->front = (q->front + 1) % q->maxSize;
    return true;
}

获取队列内已经存下的元素个数

int getLength(myQueue q)
{
    return (q.rear - q.front + q.maxSize) % q.maxSize;
}

完整代码及测试

// 循环队列

#include 
#include 

typedef struct myQueue
{
    int *data;
    int front, rear;
    int maxSize;
} myQueue;

void initQueue(myQueue *q, int maxSize)
{
    int *p = (int *)malloc(maxSize * sizeof(int));
    q->data = p;
    q->front = q->rear = 0;
    q->maxSize = maxSize;
}

// 从队尾入队，返回是否插入成功
bool enQueue(myQueue *q, int e)
{
    if ((q->rear + 1) % q->maxSize == q->front)
        return false; // 队列已满
    q->data[q->rear] = e;
    q->rear = (q->rear + 1) % q->maxSize;
    return true;
}

// 判断队列是否为空
bool empty(myQueue q)
{
    return q.rear == q.front;
}

bool getFront(myQueue q, int *e)
{
    if (empty(q))
        return -1;
    *e = q.data[q.front];
    return true;
}

// 出队
bool deQueue(myQueue *q)
{
    if (empty(*q))
        return false;
    q->front = (q->front + 1) % q->maxSize;
    return true;
}

int getLength(myQueue q)
{
    return (q.rear - q.front + q.maxSize) % q.maxSize;
}

int main()
{
    myQueue *q;
    initQueue(q, 10);
    for (int i = 1; i < 25; i++)
    {
        if (!enQueue(q, i))
        {
            printf("i=%d 队列已满\n", i);
            break;
        }
    }
    printf("此时队列内元素个数：%d\n", getLength(*q));
    while (!empty(*q))
    {
        int x;
        getFront(*q, &x);
        printf("%d\t", x);
        deQueue(q);
    }

    return 0;
}