我们组的代码

tjp

#include <stdlib.h>
#include <stdbool.h>

#define MAXSIZE 100  // 定义队列的最大容量

// 定义顺序队列结构体
typedef struct {
    int data[MAXSIZE];  // 队列的数组
    int front;          // 队列前端指针
    int rear;           // 队列尾端指针
} Queue;

// 初始化队列
void initQueue(Queue* q) {
    q->front = 0;  // 队列前端指针初始化为0
    q->rear = -1;  // 队列尾端指针初始化为-1，表示队列为空
}

// 判断队列是否为空
bool isEmpty(Queue* q) {
    return q->front == q->rear + 1;
}

// 判断队列是否满
bool isFull(Queue* q) {
    return (q->rear + 1) % MAXSIZE == q->front;
}

// 入队操作
bool enqueue(Queue* q, int value) {
    if (isFull(q)) {
        printf("Queue is full!\n");
        return false;
    }
    q->data[++(q->rear)] = value;  // 先自增尾端指针，再赋值（注意取模运算用于循环队列）
    // 对于非循环队列，不使用取模运算，而是直接检查是否达到MAXSIZE-1
    // if (q->rear < MAXSIZE - 1) {
    //     q->data[++(q->rear)] = value;
    // } else {
    //     printf("Queue is full!\n");
    //     return false;
    // }
    return true;
}

// 出队操作
bool dequeue(Queue* q, int* value) {
    if (isEmpty(q)) {
        printf("Queue is empty!\n");
        return false;
    }
    *value = q->data[(q->front)++];  // 先赋值，再自增前端指针（注意循环队列的处理）
    // 对于非循环队列且不需要保留队列空间，可以在出队后将数组元素前移
    // 但在这个简单实现中，我们不考虑空间优化
    // if (q->front < q->rear) {
    //     *value = q->data[q->front++];
    // } else {
    //     // 队列为空，但这里已经在isEmpty中检查过了，所以不需要再次检查
    //     // 只是为了说明，如果要在这里处理，应该返回false
    // }
    // 注意：如果要实现循环队列，需要在这里对front指针进行取模运算
    // 但在这个例子中，我们假设队列不是循环的，所以不需要取模
    // 但在isFull函数中，我们使用了取模来模拟循环队列的满条件（这是一个假设的示例）
    // 实际上，对于非循环队列，我们不需要在isFull中使用取模，只需检查rear是否达到MAXSIZE-1
    return true;
}

// 获取队列前端元素（不删除）
bool getFront(Queue* q, int* value) {
    if (isEmpty(q)) {
        printf("Queue is empty!\n");
        return false;
    }
    *value = q->data[q->front];
    return true;
}

// 打印队列中的所有元素（用于调试）
void printQueue(Queue* q) {
    if (isEmpty(q)) {
        printf("Queue is empty.\n");
        return;
    }
    printf("Queue elements: ");
    for (int i = q->front; i <= q->rear; i++) {
        printf("%d ", q->data[i]);
    }
    printf("\n");
}

int main() {
    Queue q;
    initQueue(&q);

    // 测试入队操作
    enqueue(&q, 10);
    enqueue(&q, 20);
    enqueue(&q, 30);

    // 打印队列
    printQueue(&q);

    // 测试获取队列前端元素
    int frontValue;
    if (getFront(&q, &frontValue)) {
        printf("Front element: %d\n", frontValue);
    }

    // 测试出队操作
    int dequeuedValue;
    while (dequeue(&q, &dequeuedValue)) {
        printf("Dequeued element: %d\n", dequeuedValue);
    }

    // 测试队列是否为空
    if (isEmpty(&q)) {
        printf("Queue is empty.\n");
    }

    return 0;
}```

tjp

顺序队列（Sequential Queue）是一种基于数组或连续存储空间实现的数据结构，用于存储和操作一系列按先进先出（FIFO，First In First Out）顺序排列的元素。在顺序队列中，元素通常被存储在一个一维数组中，并且使用两个指针（或索引）来跟踪队列的头和尾。

顺序队列的基本操作
初始化队列：
分配一个固定大小的数组作为队列的存储空间。
初始化头指针（front）和尾指针（rear）为0，表示队列为空。
判断队列是否为空：
如果 front == rear，则队列为空。
判断队列是否已满：
如果 rear == 数组的容量，则队列已满。
注意：在某些实现中，为了区分队列满和队列空的情况，可能会保留一个额外的空间（即 rear 最多只能达到数组的容量 - 1）。
入队（Enqueue）：
检查队列是否已满。
如果未满，将新元素存储在 rear 指针所指向的位置。
然后将 rear 指针加1。
出队（Dequeue）：
检查队列是否为空。
如果不为空，取出 front 指针所指向的元素。
然后将 front 指针加1。
获取队列头元素（Front/Peek）：
检查队列是否为空。
如果不为空，返回 front 指针所指向的元素，但不移动指针。
获取队列长度：
计算 rear - front（如果考虑循环队列，则需要进行模运算）。
顺序队列的优缺点
优点：

逻辑结构简单，易于理解和实现。
访问速度快，因为数据存储在连续的存储空间中。
缺点：

队列的最大容量在初始化时固定，不易扩展。
当队列满时，如果无法动态增加容量，可能导致操作失败。
存在假溢出问题（即队列实际上未满，但由于头尾指针的限制而无法继续入队）。

八十sui辣妹

#include<stdio.h>
#include<iostream>
using namespace std;



#define MaxSize 128 //预先分配空间，这个数值根据实际需要预估确定

typedef int ElemType;

typedef struct _QStack {
    ElemType* base; //栈底指针
    ElemType* top; //栈顶指针
}QStack;

//采用top指向栈顶元素的方法
#define MAXSIZE 50  //定义栈中元素的最大个数


bool InitStack(QStack& S);
bool PushStack(QStack& S, ElemType e);
bool PopStack(QStack& S, ElemType& e);
bool GetTop(QStack& S, ElemType e);
bool Input(QStack S);
void StackShow(QStack& S);


bool InitStack(QStack& S) { //构造一个空栈 S（初始化）
    S.base = new ElemType[MaxSize];//为顺序栈分配一个最大容量为 Maxsize 的空间

    if (!S.base) return false; //空间分配失败

    S.top = S.base; //top 初始为 base，空栈

    return true;
}


bool PushStack(QStack& S, ElemType e) { // 插入元素 e 为新的栈顶元素
    if (S.top - S.base == MaxSize) //栈满
        return false;

    *(S.top++) = e; //元素 e 压入栈顶，然后栈顶指针加 1;
    Input(S);
    return true;
}

bool PopStack(QStack& S, ElemType& e) //删除 S 的栈顶元素，暂存在变量 e中
{
    if (S.base == S.top) { //栈空
        return false;
    }

    e = *(--S.top); //栈顶指针减 1，将栈顶元素赋给 e
    Input(S);
    return true;
}



bool GetTop(QStack& S, ElemType e) { //返回 S 的栈顶元素，栈顶指针不变    
    if (S.top != S.base) { //栈非空
        e = *(S.top - 1);
        return true;
    }
    else {
        return false;
    }
}


bool Input(QStack S)//打印栈空间
{
    ElemType* p;
    p = S.top;
    if (S.base == p)
    {
        cout << "栈空了哈（*＾-＾）" << endl;
        return false;
    }
    cout << "---------栈空间内存展示-------------------------" << endl;
    cout << "----栈顶----" << endl;
    for (p--; p >= S.base; p--)
        cout << "=>" << *p << "   (" << p << ")" << endl;
    cout << "----栈底----" << endl;
    return true;
}



void StackShow(QStack& S)
{
    char* p;

    p = (char*)S.top;
    char* end = (char*)S.base;
    int k = 0;
    if (end == p)
    {
        cout << "顺序栈为空！" << endl;
        return;
    }
    cout << "---------栈空间内存展示-------------------------\n" << endl;
    for (p; p >= end; p -= 8) {

        printf("--> %p  %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx\n", p, *(p + 7), *(p + 6), *(p + 5), *(p + 4), *(p + 3), *(p + 2), *(p + 1), *(p));
    }
    cout << endl;
    return;

}

int main()
{
    QStack S;
    int a;
    ElemType e = 0;;
    if (!InitStack(S))
        cout << "顺序栈初始化失败！" << endl;
    else
        cout << "顺序栈初始化成功！" << endl;
    while (1)
    {
        cout << "\n【1】入栈  【2】出栈  【3】读栈顶元素  【4】输出栈  【0】退出" << endl;
        cout << "请选择要进行的操作：";
        cin >> a;
        switch (a)
        {
        case 1:
            cout << "请输入入栈元素：";
            cin >> e;
            if (!PushStack(S, e))
                cout << "栈满了哈（*＾-＾）" << endl;
            else
                cout << "元素" << e << "入栈成功！" << endl;
            break;
        case 2:
            if (!PopStack(S, e))
                cout << "栈空了哈（*＾-＾）" << endl;
            else
                cout << "元素" << e << "出栈成功！" << endl;
            break;
        case 3:
            if (!GetTop(S, e))
                cout << "栈空了哈（*＾-＾）" << endl;
            else
                cout << "栈顶元素为：" << e << endl;
            break;
        case 4:
            StackShow(S);
            break;
        default:
            return 0;
        }
    }
    return 0;
}```

Koarz

代码有问题

Get部分 e 应该使用引用
StackShow 中为什么是每次展示八个字节，ElementType 不是 int 吗？以及为什么要对每个字节输出 %02hhx 格式而不是整体使用 ElementType* 呢
new 出的内存没有 delete 造成内存泄漏