【数据结构】顺序栈的不同表示及其实现

于 2024-09-02 19:52:29 发布
阅读量1k 收藏 26
点赞数 13
文章标签： 数据结构 算法 c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2402_82428821/article/details/141826766
版权

采用顺序存储结构的栈称为顺序栈，即需要用一片地址连续的空间来存储栈的元素，很容易想到用一个一维数组实现，并指定栈顶位于序列末端。顺序栈的表示有很多种，下面我们就用C语言来看看顺序栈的表示。

1. 使用 top 表示栈顶位置

typedef struct {
	ElemType *elem; // 存储空间的基址   
	int top;        // 栈顶元素的下一个位置，简称栈顶位标
	int size;       // 当前分配的存储容量
	int increment;  // 扩容时，增加的存储容量
} SqStack;

特点

1.这里的 top 表示的是栈顶元素的下一个位置。这意味着 top 指向栈中实际元素的数量，因此栈为空时 top 为0，栈满时 top 等于 size。

2.常用于顺序栈的基本实现中，比较直观。

常见操作接口

  1. InitStack：初始化栈，分配初始的存储空间。
  2. StackEmpty：判断栈是否为空，空栈返回 OK，否则返回 ERROR。
  3. StackLength：返回栈的当前长度，即栈中元素的数量。
  4. GetTop：获取栈顶元素，栈顶元素通过参数 e 返回。
  5. Push：将元素入栈，如果栈满则自动扩容。
  6. Pop：将栈顶元素出栈，并通过参数 e 返回该元素。
  7. DestroyStack：销毁栈，释放所有分配的内存。
  8. ClearStack：清空栈，只需将 top 重置为0。
  9. TraverseStack：遍历栈并打印所有栈中的元素。
#include <stdio.h>
#include <stdlib.h>

typedef int ElemType; // 根据实际需要定义元素类型
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;

typedef struct {
    ElemType *elem; // 存储空间的基址   
    int top;        // 栈顶元素的下一个位置，简称栈顶位标
    int size;       // 当前分配的存储容量
    int increment;  // 扩容时，增加的存储容量
} SqStack;

// 初始化栈
Status InitStack(SqStack &S, int initial_size, int increment) {
    S.elem = (ElemType *)malloc(initial_size * sizeof(ElemType));
    if (!S.elem) return OVERFLOW; // 分配失败
    S.top = 0;  // 栈顶初始化为0
    S.size = initial_size;
    S.increment = increment;
    return OK;
}

// 判断栈是否为空
Status StackEmpty(SqStack S) {
    return S.top == 0 ? OK : ERROR;
}

// 获取栈的长度
int StackLength(SqStack S) {
    return S.top;
}

// 获取栈顶元素
Status GetTop(SqStack S, ElemType &e) {
    if (S.top == 0) return ERROR; // 栈空
    e = S.elem[S.top - 1]; // 栈顶元素在 top - 1 位置
    return OK;
}

// 入栈操作
Status Push(SqStack &S, ElemType e) {
    if (S.top >= S.size) { // 如果栈满，则需要扩容
        ElemType *newbase = (ElemType *)realloc(S.elem, (S.size + S.increment) * sizeof(ElemType));
        if (!newbase) return OVERFLOW; // 分配失败
        S.elem = newbase;
        S.size += S.increment;
    }
    S.elem[S.top++] = e; // 元素入栈，top 后移
    return OK;
}

// 出栈操作
Status Pop(SqStack &S, ElemType &e) {
    if (S.top == 0) return ERROR; // 栈空
    e = S.elem[--S.top]; // 栈顶元素出栈，top 前移
    return OK;
}

// 销毁栈
Status DestroyStack(SqStack &S) {
    if (S.elem) {
        free(S.elem);
        S.elem = NULL;
    }
    S.top = 0;
    S.size = 0;
    return OK;
}

// 清空栈
Status ClearStack(SqStack &S) {
    S.top = 0; // 只需将栈顶位置重置为0
    return OK;
}

// 遍历栈并打印栈中的所有元素
void TraverseStack(SqStack S) {
    printf("Stack elements: ");
    for (int i = 0; i < S.top; i++) {
        printf("%d ", S.elem[i]);
    }
    printf("\n");
}

int main() {
    SqStack S;
    ElemType e;
    
    // 初始化栈
    if (InitStack(S, 10, 5) == OK) {
        printf("Stack initialized successfully.\n");
    }

    // 入栈操作
    for (int i = 0; i < 15; i++) {
        if (Push(S, i) == OK) {
            printf("Element %d pushed onto stack.\n", i);
        }
    }
    
    // 获取栈顶元素
    if (GetTop(S, e) == OK) {
        printf("Top element: %d\n", e);
    }

    // 遍历栈
    TraverseStack(S);
    
    // 出栈操作
    while (Pop(S, e) == OK) {
        printf("Element %d popped from stack.\n", e);
    }

    // 销毁栈
    DestroyStack(S);

    return 0;
}

2. 使用 length 表示栈的长度

typedef struct {
	ElemType *elem; // 存储空间的基址   
	int length;     // 栈的长度（即栈中的元素数量）
	int size;       // 当前分配的存储容量
	int increment;  // 扩容时，增加的存储容量
} SqStack;

特点

1.这里使用 length 来表示栈中的元素数量，这实际上和上一个例子中的 top 表示的含义类似。

2.这种表示更直观地描述了栈的长度，而 length 可以更清晰地表达栈中当前的元素数量。

常见接口操作

  1. InitStack：初始化栈，分配初始的存储空间。
  2. StackEmpty：判断栈是否为空，空栈返回 OK，否则返回 ERROR。
  3. StackLength：返回栈的当前长度，即栈中元素的数量。
  4. GetTop：获取栈顶元素，栈顶元素通过参数 e 返回。
  5. Push：将元素入栈，如果栈满则自动扩容。
  6. Pop：将栈顶元素出栈，并通过参数 e 返回该元素。
  7. DestroyStack：销毁栈，释放所有分配的内存。
  8. ClearStack：清空栈，只需将 length 重置为0。
  9. TraverseStack：遍历栈并打印所有栈中的元素。
#include <stdio.h>
#include <stdlib.h>

typedef int ElemType; // 根据实际需要定义元素类型
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;

typedef struct {
    ElemType *elem; // 存储空间的基址   
    int length;     // 栈的长度，即栈中元素的数量
    int size;       // 当前分配的存储容量
    int increment;  // 扩容时，增加的存储容量
} SqStack;

// 初始化栈
Status InitStack(SqStack &S, int initial_size, int increment) {
    S.elem = (ElemType *)malloc(initial_size * sizeof(ElemType));
    if (!S.elem) return OVERFLOW; // 分配失败
    S.length = 0;  // 栈的初始长度为0
    S.size = initial_size;
    S.increment = increment;
    return OK;
}

// 判断栈是否为空
Status StackEmpty(SqStack S) {
    return S.length == 0 ? OK : ERROR;
}

// 获取栈的长度
int StackLength(SqStack S) {
    return S.length;
}

// 获取栈顶元素
Status GetTop(SqStack S, ElemType &e) {
    if (S.length == 0) return ERROR; // 栈空
    e = S.elem[S.length - 1]; // 栈顶元素在 length - 1 位置
    return OK;
}

// 入栈操作
Status Push(SqStack &S, ElemType e) {
    if (S.length >= S.size) { // 如果栈满，则需要扩容
        ElemType *newbase = (ElemType *)realloc(S.elem, (S.size + S.increment) * sizeof(ElemType));
        if (!newbase) return OVERFLOW; // 分配失败
        S.elem = newbase;
        S.size += S.increment;
    }
    S.elem[S.length++] = e; // 元素入栈，length 增加
    return OK;
}

// 出栈操作
Status Pop(SqStack &S, ElemType &e) {
    if (S.length == 0) return ERROR; // 栈空
    e = S.elem[--S.length]; // 栈顶元素出栈，length 减少
    return OK;
}

// 销毁栈
Status DestroyStack(SqStack &S) {
    if (S.elem) {
        free(S.elem);
        S.elem = NULL;
    }
    S.length = 0;
    S.size = 0;
    return OK;
}

// 清空栈
Status ClearStack(SqStack &S) {
    S.length = 0; // 只需将栈长度重置为0
    return OK;
}

// 遍历栈并打印栈中的所有元素
void TraverseStack(SqStack S) {
    printf("Stack elements: ");
    for (int i = 0; i < S.length; i++) {
        printf("%d ", S.elem[i]);
    }
    printf("\n");
}

int main() {
    SqStack S;
    ElemType e;
    
    // 初始化栈
    if (InitStack(S, 10, 5) == OK) {
        printf("Stack initialized successfully.\n");
    }

    // 入栈操作
    for (int i = 0; i < 15; i++) {
        if (Push(S, i) == OK) {
            printf("Element %d pushed onto stack.\n", i);
        }
    }
    
    // 获取栈顶元素
    if (GetTop(S, e) == OK) {
        printf("Top element: %d\n", e);
    }

    // 遍历栈
    TraverseStack(S);
    
    // 出栈操作
    while (Pop(S, e) == OK) {
        printf("Element %d popped from stack.\n", e);
    }

    // 销毁栈
    DestroyStack(S);

    return 0;
}

3. 使用指针 top 指向栈顶位置

typedef struct {
	ElemType *elem; // 存储空间的基址   
	ElemType *top;  // 栈顶指针，指向栈顶元素的下一个位置
	int size;       // 当前分配的存储容量
	int increment;  // 扩容时，增加的存储容量
} SqStack;

特点

1.top 是指针类型，指向栈顶元素的下一个位置。通过指针运算可以直接访问栈顶元素。

2.这种表示方式在操作指针时比较高效，可以直接操作内存地址。

常见接口操作

  1. InitStack：初始化栈，分配初始的存储空间，并设置 top 指针指向 elem 的基址。
  2. StackEmpty：判断栈是否为空，空栈时 top 等于 elem 的基址。
  3. StackLength：返回栈的当前长度，计算 top 和 elem 基址之间的距离。
  4. GetTop：获取栈顶元素，栈顶元素通过参数 e 返回。
  5. Push：将元素入栈，如果栈满则自动扩容。
  6. Pop：将栈顶元素出栈，并通过参数 e 返回该元素。
  7. DestroyStack：销毁栈，释放所有分配的内存。
  8. ClearStack：清空栈，只需将 top 重置为 elem 基址。
  9. TraverseStack：遍历栈并打印所有栈中的元素。
#include <stdio.h>
#include <stdlib.h>

typedef int ElemType; // 根据实际需要定义元素类型
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;

typedef struct {
    ElemType *elem; // 存储空间的基址   
    ElemType *top;  // 栈顶指针，指向栈顶元素的下一个位置
    int size;       // 当前分配的存储容量
    int increment;  // 扩容时，增加的存储容量
} SqStack;

// 初始化栈
Status InitStack(SqStack &S, int initial_size, int increment) {
    S.elem = (ElemType *)malloc(initial_size * sizeof(ElemType));
    if (!S.elem) return OVERFLOW; // 分配失败
    S.top = S.elem; // 初始时，top 指向 elem 基址，表示栈为空
    S.size = initial_size;
    S.increment = increment;
    return OK;
}

// 判断栈是否为空
Status StackEmpty(SqStack S) {
    return S.top == S.elem ? OK : ERROR;
}

// 获取栈的长度
int StackLength(SqStack S) {
    return S.top - S.elem; // 栈的长度为 top 指针和 elem 基址之间的距离
}

// 获取栈顶元素
Status GetTop(SqStack S, ElemType &e) {
    if (S.top == S.elem) return ERROR; // 栈空
    e = *(S.top - 1); // 栈顶元素在 top - 1 位置
    return OK;
}

// 入栈操作
Status Push(SqStack &S, ElemType e) {
    if (S.top - S.elem >= S.size) { // 如果栈满，则需要扩容
        int new_size = S.size + S.increment;
        ElemType *newbase = (ElemType *)realloc(S.elem, new_size * sizeof(ElemType));
        if (!newbase) return OVERFLOW; // 分配失败
        S.top = newbase + (S.top - S.elem); // 更新 top 指针位置
        S.elem = newbase;
        S.size = new_size;
    }
    *(S.top++) = e; // 元素入栈，top 后移
    return OK;
}

// 出栈操作
Status Pop(SqStack &S, ElemType &e) {
    if (S.top == S.elem) return ERROR; // 栈空
    e = *(--S.top); // 栈顶元素出栈，top 前移
    return OK;
}

// 销毁栈
Status DestroyStack(SqStack &S) {
    if (S.elem) {
        free(S.elem);
        S.elem = NULL;
    }
    S.top = NULL;
    S.size = 0;
    return OK;
}

// 清空栈
Status ClearStack(SqStack &S) {
    S.top = S.elem; // 只需将 top 重置为 elem 基址
    return OK;
}

// 遍历栈并打印栈中的所有元素
void TraverseStack(SqStack S) {
    printf("Stack elements: ");
    for (ElemType *p = S.elem; p < S.top; p++) {
        printf("%d ", *p);
    }
    printf("\n");
}

int main() {
    SqStack S;
    ElemType e;
    
    // 初始化栈
    if (InitStack(S, 10, 5) == OK) {
        printf("Stack initialized successfully.\n");
    }

    // 入栈操作
    for (int i = 0; i < 15; i++) {
        if (Push(S, i) == OK) {
            printf("Element %d pushed onto stack.\n", i);
        }
    }
    
    // 获取栈顶元素
    if (GetTop(S, e) == OK) {
        printf("Top element: %d\n", e);
    }

    // 遍历栈
    TraverseStack(S);
    
    // 出栈操作
    while (Pop(S, e) == OK) {
        printf("Element %d popped from stack.\n", e);
    }

    // 销毁栈
    DestroyStack(S);

    return 0;
}

4. 使用 top 表示栈顶元素位置

typedef struct {
	ElemType *elem; // 存储空间的基址   
	int top;        // 栈顶元素的位置
	int size;       // 当前分配的存储容量
	int increment;  // 扩容时，增加的存储容量
} SqStack;

特点

1.top 直接表示栈顶元素的位置。栈顶元素的索引为 top，栈顶上方的空位为 top + 1。

2.这种表示方式与上面几种方式相比稍有不同，但可以更直接地索引栈顶元素。

常见接口操作

  1. InitStack：初始化栈，分配初始的存储空间，并设置 top 为 -1，表示栈为空。
  2. StackEmpty：判断栈是否为空，空栈时 top 为 -1。
  3. StackLength：返回栈的当前长度，top + 1 即为栈中元素的数量。
  4. GetTop：获取栈顶元素，栈顶元素通过参数 e 返回。
  5. Push：将元素入栈，如果栈满则自动扩容。
  6. Pop：将栈顶元素出栈，并通过参数 e 返回该元素。
  7. DestroyStack：销毁栈，释放所有分配的内存。
  8. ClearStack：清空栈，只需将 top 重置为 -1。
  9. TraverseStack：遍历栈并打印所有栈中的元素。
#include <stdio.h>
#include <stdlib.h>

typedef int ElemType; // 根据实际需要定义元素类型
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;

typedef struct {
    ElemType *elem; // 存储空间的基址   
    int top;        // 栈顶位置
    int size;       // 当前分配的存储容量
    int increment;  // 扩容时，增加的存储容量
} SqStack;

// 初始化栈
Status InitStack(SqStack &S, int initial_size, int increment) {
    S.elem = (ElemType *)malloc(initial_size * sizeof(ElemType));
    if (!S.elem) return OVERFLOW; // 分配失败
    S.top = -1;  // 栈顶位置初始化为-1，表示栈为空
    S.size = initial_size;
    S.increment = increment;
    return OK;
}

// 判断栈是否为空
Status StackEmpty(SqStack S) {
    return S.top == -1 ? OK : ERROR;
}

// 获取栈的长度
int StackLength(SqStack S) {
    return S.top + 1; // 栈的长度为 top + 1
}

// 获取栈顶元素
Status GetTop(SqStack S, ElemType &e) {
    if (S.top == -1) return ERROR; // 栈空
    e = S.elem[S.top]; // 栈顶元素在 top 位置
    return OK;
}

// 入栈操作
Status Push(SqStack &S, ElemType e) {
    if (S.top >= S.size - 1) { // 如果栈满，则需要扩容
        ElemType *newbase = (ElemType *)realloc(S.elem, (S.size + S.increment) * sizeof(ElemType));
        if (!newbase) return OVERFLOW; // 分配失败
        S.elem = newbase;
        S.size += S.increment;
    }
    S.elem[++S.top] = e; // 元素入栈，top 增加
    return OK;
}

// 出栈操作
Status Pop(SqStack &S, ElemType &e) {
    if (S.top == -1) return ERROR; // 栈空
    e = S.elem[S.top--]; // 栈顶元素出栈，top 减少
    return OK;
}

// 销毁栈
Status DestroyStack(SqStack &S) {
    if (S.elem) {
        free(S.elem);
        S.elem = NULL;
    }
    S.top = -1;
    S.size = 0;
    return OK;
}

// 清空栈
Status ClearStack(SqStack &S) {
    S.top = -1; // 只需将 top 重置为 -1
    return OK;
}

// 遍历栈并打印栈中的所有元素
void TraverseStack(SqStack S) {
    printf("Stack elements: ");
    for (int i = 0; i <= S.top; i++) {
        printf("%d ", S.elem[i]);
    }
    printf("\n");
}

int main() {
    SqStack S;
    ElemType e;
    
    // 初始化栈
    if (InitStack(S, 10, 5) == OK) {
        printf("Stack initialized successfully.\n");
    }

    // 入栈操作
    for (int i = 0; i < 15; i++) {
        if (Push(S, i) == OK) {
            printf("Element %d pushed onto stack.\n", i);
        }
    }
    
    // 获取栈顶元素
    if (GetTop(S, e) == OK) {
        printf("Top element: %d\n", e);
    }

    // 遍历栈
    TraverseStack(S);
    
    // 出栈操作
    while (Pop(S, e) == OK) {
        printf("Element %d popped from stack.\n", e);
    }

    // 销毁栈
    DestroyStack(S);

    return 0;
}

5. 使用指针 top 指向栈顶元素位置

typedef struct {
	ElemType *elem; // 存储空间的基址   
	ElemType *top;  // 栈顶指针，指向栈顶元素的位置
	int size;       // 当前分配的存储容量
	int increment;  // 扩容时，增加的存储容量
} SqStack;

特点

1.top 是指针，指向栈顶元素的位置，而不是下一个位置。通过指针运算可以直接获取或修改栈顶元素的值。

2.这种表示方式更接近实际的硬件栈指针操作，用于需要精确控制栈顶元素的场景。

常见操作接口

  1. InitStack：初始化栈，分配初始的存储空间，并设置 top 为 elem - 1，表示栈为空。
  2. StackEmpty：判断栈是否为空，空栈时 top 指针位置小于 elem 基址。
  3. StackLength：返回栈的当前长度，即 top 和 elem 基址之间的距离加1。
  4. GetTop：获取栈顶元素，栈顶元素通过参数 e 返回。
  5. Push：将元素入栈，如果栈满则自动扩容。
  6. Pop：将栈顶元素出栈，并通过参数 e 返回该元素。
  7. DestroyStack：销毁栈，释放所有分配的内存。
  8. ClearStack：清空栈，只需将 top 重置为 elem - 1。
  9. TraverseStack：遍历栈并打印所有栈中的元素。
#include <stdio.h>
#include <stdlib.h>

typedef int ElemType; // 根据实际需要定义元素类型
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;

typedef struct {
    ElemType *elem; // 存储空间的基址   
    ElemType *top;  // 栈顶指针，指向栈顶元素位置
    int size;       // 当前分配的存储容量
    int increment;  // 扩容时，增加的存储容量
} SqStack;

// 初始化栈
Status InitStack(SqStack &S, int initial_size, int increment) {
    S.elem = (ElemType *)malloc(initial_size * sizeof(ElemType));
    if (!S.elem) return OVERFLOW; // 分配失败
    S.top = S.elem - 1; // 初始化时，top 指向栈底元素前一个位置，表示栈为空
    S.size = initial_size;
    S.increment = increment;
    return OK;
}

// 判断栈是否为空
Status StackEmpty(SqStack S) {
    return S.top < S.elem ? OK : ERROR;
}

// 获取栈的长度
int StackLength(SqStack S) {
    return S.top - S.elem + 1; // 栈的长度为 top 和 elem 基址之间的距离
}

// 获取栈顶元素
Status GetTop(SqStack S, ElemType &e) {
    if (S.top < S.elem) return ERROR; // 栈空
    e = *S.top; // 栈顶元素
    return OK;
}

// 入栈操作
Status Push(SqStack &S, ElemType e) {
    if (S.top - S.elem + 1 >= S.size) { // 如果栈满，则需要扩容
        int new_size = S.size + S.increment;
        ElemType *newbase = (ElemType *)realloc(S.elem, new_size * sizeof(ElemType));
        if (!newbase) return OVERFLOW; // 分配失败
        S.top = newbase + (S.top - S.elem); // 更新 top 指针位置
        S.elem = newbase;
        S.size = new_size;
    }
    *(++S.top) = e; // 元素入栈，top 后移
    return OK;
}

// 出栈操作
Status Pop(SqStack &S, ElemType &e) {
    if (S.top < S.elem) return ERROR; // 栈空
    e = *(S.top--); // 栈顶元素出栈，top 前移
    return OK;
}

// 销毁栈
Status DestroyStack(SqStack &S) {
    if (S.elem) {
        free(S.elem);
        S.elem = NULL;
    }
    S.top = NULL;
    S.size = 0;
    return OK;
}

// 清空栈
Status ClearStack(SqStack &S) {
    S.top = S.elem - 1; // 只需将 top 重置为 elem 前一个位置
    return OK;
}

// 遍历栈并打印栈中的所有元素
void TraverseStack(SqStack S) {
    printf("Stack elements: ");
    for (ElemType *p = S.elem; p <= S.top; p++) {
        printf("%d ", *p);
    }
    printf("\n");
}

int main() {
    SqStack S;
    ElemType e;
    
    // 初始化栈
    if (InitStack(S, 10, 5) == OK) {
        printf("Stack initialized successfully.\n");
    }

    // 入栈操作
    for (int i = 0; i < 15; i++) {
        if (Push(S, i) == OK) {
            printf("Element %d pushed onto stack.\n", i);
        }
    }
    
    // 获取栈顶元素
    if (GetTop(S, e) == OK) {
        printf("Top element: %d\n", e);
    }

    // 遍历栈
    TraverseStack(S);
    
    // 出栈操作
    while (Pop(S, e) == OK) {
        printf("Element %d popped from stack.\n", e);
    }

    // 销毁栈
    DestroyStack(S);

    return 0;
}

6. 基于固定大小的数组实现顺序栈

#define MAXSIZE 1000
ElemType S[MAXSIZE];
typedef struct {
    ElemType elem[MAXSIZE];  // 固定大小的数组用于存储栈中的元素
    int top;                 // 栈顶位置，指向栈顶元素的下一个位置
} SqStack_Fixed;

特点

1.使用一个固定大小的数组 S 来表示顺序栈，MAXSIZE 是栈的最大容量。

2.这种表示方式简单且直接，适用于栈容量固定且不需要扩展的情况，如静态栈或嵌入式系统中。

常见接口操作

  1. InitStack：初始化栈，设置 top 为 0，表示栈为空。
  2. StackEmpty：判断栈是否为空，空栈时 top 为 0。
  3. StackLength：返回栈的当前长度，直接返回 top 的值。
  4. GetTop：获取栈顶元素，栈顶元素通过参数 e 返回。
  5. Push：将元素入栈，如果栈满则返回错误。
  6. Pop：将栈顶元素出栈，并通过参数 e 返回该元素。
  7. ClearStack：清空栈，只需将 top 重置为 0。
  8. TraverseStack：遍历栈并打印所有栈中的元素。
#include <stdio.h>

#define MAXSIZE 100  // 根据实际需求设置栈的最大容量
typedef int ElemType; // 根据实际需要定义元素类型
#define OK 1
#define ERROR 0
typedef int Status;

typedef struct {
    ElemType elem[MAXSIZE]; // 固定大小的数组用于存储栈中的元素
    int top;                // 栈顶位置，指向栈顶元素的下一个位置
} SqStack_Fixed;

// 初始化栈
Status InitStack(SqStack_Fixed &S) {
    S.top = 0;  // 初始化时，top 为 0，表示栈为空
    return OK;
}

// 判断栈是否为空
Status StackEmpty(SqStack_Fixed S) {
    return S.top == 0 ? OK : ERROR;
}

// 获取栈的长度
int StackLength(SqStack_Fixed S) {
    return S.top;  // 栈的长度为 top
}

// 获取栈顶元素
Status GetTop(SqStack_Fixed S, ElemType &e) {
    if (S.top == 0) return ERROR; // 栈空
    e = S.elem[S.top - 1];  // 栈顶元素在 top - 1 位置
    return OK;
}

// 入栈操作
Status Push(SqStack_Fixed &S, ElemType e) {
    if (S.top >= MAXSIZE) return ERROR; // 栈满
    S.elem[S.top++] = e;  // 元素入栈，top 后移
    return OK;
}

// 出栈操作
Status Pop(SqStack_Fixed &S, ElemType &e) {
    if (S.top == 0) return ERROR; // 栈空
    e = S.elem[--S.top];  // 栈顶元素出栈，top 前移
    return OK;
}

// 清空栈
Status ClearStack(SqStack_Fixed &S) {
    S.top = 0;  // 只需将 top 重置为 0
    return OK;
}

// 遍历栈并打印栈中的所有元素
void TraverseStack(SqStack_Fixed S) {
    printf("Stack elements: ");
    for (int i = 0; i < S.top; i++) {
        printf("%d ", S.elem[i]);
    }
    printf("\n");
}

int main() {
    SqStack_Fixed S;
    ElemType e;
    
    // 初始化栈
    if (InitStack(S) == OK) {
        printf("Stack initialized successfully.\n");
    }

    // 入栈操作
    for (int i = 0; i < 10; i++) {
        if (Push(S, i) == OK) {
            printf("Element %d pushed onto stack.\n", i);
        }
    }
    
    // 获取栈顶元素
    if (GetTop(S, e) == OK) {
        printf("Top element: %d\n", e);
    }

    // 遍历栈
    TraverseStack(S);
    
    // 出栈操作
    while (Pop(S, e) == OK) {
        printf("Element %d popped from stack.\n", e);
    }

    // 清空栈
    ClearStack(S);

    // 遍历栈，检查是否清空
    TraverseStack(S);

    return 0;
}

7.基于动态数组实现顺序栈

typedef struct {
    ElemType *elem;   // 动态分配的数组基址
    int top;          // 栈顶位置，指向栈顶元素的下一个位置
    int size;         // 当前栈的容量
} SqStack_Dynamic;

特点

这种方式使用动态分配的数组来实现顺序栈，并在需要时扩展栈的容量。它比固定大小的数组更灵活。

常见操作接口

  1. InitStack：初始化栈，分配初始的存储空间，并设置 top 为 0，表示栈为空。
  2. StackEmpty：判断栈是否为空，空栈时 top 为 0。
  3. StackLength：返回栈的当前长度，直接返回 top 的值。
  4. GetTop：获取栈顶元素，栈顶元素通过参数 e 返回。
  5. ExpandStack：扩容操作，当栈满时，增加栈的存储容量。
  6. Push：将元素入栈，如果栈满则自动扩容。
  7. Pop：将栈顶元素出栈，并通过参数 e 返回该元素。
  8. DestroyStack：销毁栈，释放所有分配的内存。
  9. ClearStack：清空栈，只需将 top 重置为 0。
  10. TraverseStack：遍历栈并打印所有栈中的元素。
#include <stdio.h>
#include <stdlib.h>

typedef int ElemType; // 根据实际需要定义元素类型
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;

typedef struct {
    ElemType *elem;   // 动态分配的数组基址
    int top;          // 栈顶位置，指向栈顶元素的下一个位置
    int size;         // 当前栈的容量
} SqStack_Dynamic;

// 初始化栈
Status InitStack(SqStack_Dynamic &S, int initial_size) {
    S.elem = (ElemType *)malloc(initial_size * sizeof(ElemType));
    if (!S.elem) return OVERFLOW; // 分配失败
    S.top = 0;  // 初始化时，top 为 0，表示栈为空
    S.size = initial_size;
    return OK;
}

// 判断栈是否为空
Status StackEmpty(SqStack_Dynamic S) {
    return S.top == 0 ? OK : ERROR;
}

// 获取栈的长度
int StackLength(SqStack_Dynamic S) {
    return S.top;  // 栈的长度为 top
}

// 获取栈顶元素
Status GetTop(SqStack_Dynamic S, ElemType &e) {
    if (S.top == 0) return ERROR; // 栈空
    e = S.elem[S.top - 1];  // 栈顶元素在 top - 1 位置
    return OK;
}

// 扩容操作
Status ExpandStack(SqStack_Dynamic &S, int increment) {
    ElemType *newbase = (ElemType *)realloc(S.elem, (S.size + increment) * sizeof(ElemType));
    if (!newbase) return OVERFLOW; // 分配失败
    S.elem = newbase;
    S.size += increment;
    return OK;
}

// 入栈操作
Status Push(SqStack_Dynamic &S, ElemType e) {
    if (S.top >= S.size) { // 如果栈满，则需要扩容
        if (ExpandStack(S, S.size) != OK) { // 扩容失败返回错误
            return OVERFLOW;
        }
    }
    S.elem[S.top++] = e;  // 元素入栈，top 后移
    return OK;
}

// 出栈操作
Status Pop(SqStack_Dynamic &S, ElemType &e) {
    if (S.top == 0) return ERROR; // 栈空
    e = S.elem[--S.top];  // 栈顶元素出栈，top 前移
    return OK;
}

// 销毁栈
Status DestroyStack(SqStack_Dynamic &S) {
    if (S.elem) {
        free(S.elem);
        S.elem = NULL;
    }
    S.top = 0;
    S.size = 0;
    return OK;
}

// 清空栈
Status ClearStack(SqStack_Dynamic &S) {
    S.top = 0;  // 只需将 top 重置为 0
    return OK;
}

// 遍历栈并打印栈中的所有元素
void TraverseStack(SqStack_Dynamic S) {
    printf("Stack elements: ");
    for (int i = 0; i < S.top; i++) {
        printf("%d ", S.elem[i]);
    }
    printf("\n");
}

int main() {
    SqStack_Dynamic S;
    ElemType e;

    // 初始化栈
    if (InitStack(S, 5) == OK) {
        printf("Stack initialized successfully.\n");
    }

    // 入栈操作
    for (int i = 0; i < 10; i++) {
        if (Push(S, i) == OK) {
            printf("Element %d pushed onto stack.\n", i);
        }
    }
    
    // 获取栈顶元素
    if (GetTop(S, e) == OK) {
        printf("Top element: %d\n", e);
    }

    // 遍历栈
    TraverseStack(S);
    
    // 出栈操作
    while (Pop(S, e) == OK) {
        printf("Element %d popped from stack.\n", e);
    }

    // 清空栈
    ClearStack(S);

    // 销毁栈
    DestroyStack(S);

    return 0;
}

8.带有最小栈功能的顺序栈

typedef struct {
    ElemType *elem;      // 动态分配的数组基址
    int top;             // 栈顶位置，指向栈顶元素的下一个位置
    int size;            // 当前栈的容量
    ElemType *minElem;   // 存储最小值的栈
    int minTop;          // 最小值栈的栈顶位置
} SqStack_Min;

特点

这种顺序栈在每次操作栈时，同时维护一个存储最小值的栈，用于实现快速获取栈中的最小值。

常见操作接口

  1. InitStack：初始化栈，分配初始的存储空间，并设置 top 和 minTop 为 0，表示栈为空。
  2. StackEmpty：判断栈是否为空，空栈时 top 为 0。
  3. StackLength：返回栈的当前长度，直接返回 top 的值。
  4. GetTop：获取栈顶元素，栈顶元素通过参数 e 返回。
  5. GetMin：获取栈中的最小值，通过维护一个最小值栈实现，最小值通过参数 e 返回。
  6. ExpandStack：扩容操作，当栈满时，增加栈和最小值栈的存储容量。
  7. Push：将元素入栈，如果栈满则自动扩容，同时更新最小值栈。
  8. Pop：将栈顶元素出栈，并通过参数 e 返回该元素，同时更新最小值栈。
  9. DestroyStack：销毁栈，释放所有分配的内存，包括最小值栈。
  10. ClearStack：清空栈，并清空最小值栈。
  11. TraverseStack：遍历栈并打印所有栈中的元素。
#include <stdio.h>
#include <stdlib.h>

typedef int ElemType; // 根据实际需要定义元素类型
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;

typedef struct {
    ElemType *elem;      // 动态分配的数组基址
    int top;             // 栈顶位置，指向栈顶元素的下一个位置
    int size;            // 当前栈的容量
    ElemType *minElem;   // 存储最小值的栈
    int minTop;          // 最小值栈的栈顶位置
} SqStack_Min;

// 初始化栈
Status InitStack(SqStack_Min &S, int initial_size) {
    S.elem = (ElemType *)malloc(initial_size * sizeof(ElemType));
    S.minElem = (ElemType *)malloc(initial_size * sizeof(ElemType));
    if (!S.elem || !S.minElem) return OVERFLOW; // 分配失败
    S.top = 0;
    S.minTop = 0;
    S.size = initial_size;
    return OK;
}

// 判断栈是否为空
Status StackEmpty(SqStack_Min S) {
    return S.top == 0 ? OK : ERROR;
}

// 获取栈的长度
int StackLength(SqStack_Min S) {
    return S.top;  // 栈的长度为 top
}

// 获取栈顶元素
Status GetTop(SqStack_Min S, ElemType &e) {
    if (S.top == 0) return ERROR; // 栈空
    e = S.elem[S.top - 1];  // 栈顶元素在 top - 1 位置
    return OK;
}

// 获取栈中的最小值
Status GetMin(SqStack_Min S, ElemType &e) {
    if (S.minTop == 0) return ERROR; // 最小值栈为空
    e = S.minElem[S.minTop - 1];  // 最小值栈顶元素
    return OK;
}

// 扩容操作
Status ExpandStack(SqStack_Min &S, int increment) {
    ElemType *newbase = (ElemType *)realloc(S.elem, (S.size + increment) * sizeof(ElemType));
    ElemType *newMinBase = (ElemType *)realloc(S.minElem, (S.size + increment) * sizeof(ElemType));
    if (!newbase || !newMinBase) return OVERFLOW; // 分配失败
    S.elem = newbase;
    S.minElem = newMinBase;
    S.size += increment;
    return OK;
}

// 入栈操作
Status Push(SqStack_Min &S, ElemType e) {
    if (S.top >= S.size) { // 如果栈满，则需要扩容
        if (ExpandStack(S, S.size) != OK) { // 扩容失败返回错误
            return OVERFLOW;
        }
    }
    S.elem[S.top++] = e;  // 元素入栈，top 后移
    
    // 处理最小值栈
    if (S.minTop == 0 || e <= S.minElem[S.minTop - 1]) {
        S.minElem[S.minTop++] = e; // 将当前元素入最小值栈
    }
    return OK;
}

// 出栈操作
Status Pop(SqStack_Min &S, ElemType &e) {
    if (S.top == 0) return ERROR; // 栈空
    e = S.elem[--S.top];  // 栈顶元素出栈，top 前移
    
    // 处理最小值栈
    if (e == S.minElem[S.minTop - 1]) {
        --S.minTop; // 同步从最小值栈中出栈
    }
    return OK;
}

// 销毁栈
Status DestroyStack(SqStack_Min &S) {
    if (S.elem) {
        free(S.elem);
        S.elem = NULL;
    }
    if (S.minElem) {
        free(S.minElem);
        S.minElem = NULL;
    }
    S.top = 0;
    S.minTop = 0;
    S.size = 0;
    return OK;
}

// 清空栈
Status ClearStack(SqStack_Min &S) {
    S.top = 0;    // 只需将 top 重置为 0
    S.minTop = 0; // 同时清空最小值栈
    return OK;
}

// 遍历栈并打印栈中的所有元素
void TraverseStack(SqStack_Min S) {
    printf("Stack elements: ");
    for (int i = 0; i < S.top; i++) {
        printf("%d ", S.elem[i]);
    }
    printf("\n");
}

int main() {
    SqStack_Min S;
    ElemType e;

    // 初始化栈
    if (InitStack(S, 5) == OK) {
        printf("Stack initialized successfully.\n");
    }

    // 入栈操作
    for (int i = 0; i < 10; i++) {
        if (Push(S, i) == OK) {
            printf("Element %d pushed onto stack.\n", i);
        }
    }
    
    // 获取栈顶元素
    if (GetTop(S, e) == OK) {
        printf("Top element: %d\n", e);
    }

    // 获取最小值
    if (GetMin(S, e) == OK) {
        printf("Minimum element: %d\n", e);
    }

    // 遍历栈
    TraverseStack(S);
    
    // 出栈操作
    while (Pop(S, e) == OK) {
        printf("Element %d popped from stack.\n", e);
    }

    // 清空栈
    ClearStack(S);

    // 销毁栈
    DestroyStack(S);

    return 0;
}

9.顺序栈的环形数组实现

typedef struct {
    ElemType *elem;   // 动态分配的数组基址
    int top;          // 栈顶位置，指向栈顶元素的下一个位置
    int size;         // 当前栈的容量
    int bottom;       // 栈底位置，指向栈底元素
} SqStack_Circular;

特点

这种方式通过环形数组来实现顺序栈，栈满时，指针可以绕回栈底，适用于需要循环使用栈空间的情况。

常见操作接口

  1. InitStack：初始化栈，分配初始的存储空间，并设置 top 和 bottom 为 0，表示栈为空。
  2. StackEmpty：判断栈是否为空，空栈时 top 等于 bottom。
  3. StackLength：返回栈的当前长度，通过 (S.top - S.bottom + S.size) % S.size 计算循环栈的长度。
  4. GetTop：获取栈顶元素，栈顶元素通过参数 e 返回。
  5. ExpandStack：扩容操作，当栈满时，增加栈的存储容量，调整栈的顺序。
  6. Push：将元素入栈，如果栈满则自动扩容。
  7. Pop：将栈顶元素出栈，并通过参数 e 返回该元素。
  8. DestroyStack：销毁栈，释放所有分配的内存。
  9. ClearStack：清空栈，只需将 top 和 bottom 重置为 0。
  10. TraverseStack：遍历栈并打印所有栈中的元素。
#include <stdio.h>
#include <stdlib.h>

typedef int ElemType; // 根据实际需要定义元素类型
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;

typedef struct {
    ElemType *elem;   // 动态分配的数组基址
    int top;          // 栈顶位置，指向栈顶元素的下一个位置
    int size;         // 当前栈的容量
    int bottom;       // 栈底位置，指向栈底元素
} SqStack_Circular;

// 初始化栈
Status InitStack(SqStack_Circular &S, int initial_size) {
    S.elem = (ElemType *)malloc(initial_size * sizeof(ElemType));
    if (!S.elem) return OVERFLOW; // 分配失败
    S.top = 0;
    S.bottom = 0;
    S.size = initial_size;
    return OK;
}

// 判断栈是否为空
Status StackEmpty(SqStack_Circular S) {
    return S.top == S.bottom ? OK : ERROR;
}

// 获取栈的长度
int StackLength(SqStack_Circular S) {
    return (S.top - S.bottom + S.size) % S.size; // 循环计算栈的长度
}

// 获取栈顶元素
Status GetTop(SqStack_Circular S, ElemType &e) {
    if (StackEmpty(S)) return ERROR; // 栈空
    e = S.elem[(S.top - 1 + S.size) % S.size]; // 栈顶元素在 top - 1 位置
    return OK;
}

// 扩容操作
Status ExpandStack(SqStack_Circular &S, int increment) {
    ElemType *newbase = (ElemType *)malloc((S.size + increment) * sizeof(ElemType));
    if (!newbase) return OVERFLOW; // 分配失败

    int length = StackLength(S);
    for (int i = 0; i < length; i++) {
        newbase[i] = S.elem[(S.bottom + i) % S.size];
    }

    free(S.elem);
    S.elem = newbase;
    S.size += increment;
    S.bottom = 0;
    S.top = length; // 调整栈顶和栈底位置

    return OK;
}

// 入栈操作
Status Push(SqStack_Circular &S, ElemType e) {
    if ((S.top + 1) % S.size == S.bottom) { // 判断栈是否满
        if (ExpandStack(S, S.size) != OK) { // 扩容失败返回错误
            return OVERFLOW;
        }
    }

    S.elem[S.top] = e;  // 元素入栈
    S.top = (S.top + 1) % S.size; // 循环调整栈顶位置

    return OK;
}

// 出栈操作
Status Pop(SqStack_Circular &S, ElemType &e) {
    if (StackEmpty(S)) return ERROR; // 栈空
    S.top = (S.top - 1 + S.size) % S.size; // 循环调整栈顶位置
    e = S.elem[S.top];  // 栈顶元素出栈

    return OK;
}

// 销毁栈
Status DestroyStack(SqStack_Circular &S) {
    if (S.elem) {
        free(S.elem);
        S.elem = NULL;
    }
    S.top = 0;
    S.bottom = 0;
    S.size = 0;
    return OK;
}

// 清空栈
Status ClearStack(SqStack_Circular &S) {
    S.top = 0;    // 清空栈只需重置 top 和 bottom
    S.bottom = 0;
    return OK;
}

// 遍历栈并打印栈中的所有元素
void TraverseStack(SqStack_Circular S) {
    printf("Stack elements: ");
    for (int i = S.bottom; i != S.top; i = (i + 1) % S.size) {
        printf("%d ", S.elem[i]);
    }
    printf("\n");
}

int main() {
    SqStack_Circular S;
    ElemType e;

    // 初始化栈
    if (InitStack(S, 5) == OK) {
        printf("Stack initialized successfully.\n");
    }

    // 入栈操作
    for (int i = 0; i < 10; i++) {
        if (Push(S, i) == OK) {
            printf("Element %d pushed onto stack.\n", i);
        }
    }

    // 获取栈顶元素
    if (GetTop(S, e) == OK) {
        printf("Top element: %d\n", e);
    }

    // 遍历栈
    TraverseStack(S);

    // 出栈操作
    while (Pop(S, e) == OK) {
        printf("Element %d popped from stack.\n", e);
    }

    // 清空栈
    ClearStack(S);

    // 销毁栈
    DestroyStack(S);

    return 0;
}

10.支持多栈的顺序栈

#define NUM_STACKS 3  // 假设我们实现3个栈

typedef struct {
    ElemType *elem;            // 动态分配的数组基址
    int tops[NUM_STACKS];       // 每个栈的栈顶指针
    int size;                  // 每个栈的容量，假设所有栈容量相同
} SqStack_Multi;

特点

这种方式在一个数组中同时实现多个栈，每个栈有独立的栈顶指针。

常见操作接口

  1. InitStack：初始化栈，分配一个动态数组用于存储所有栈的元素，并设置每个栈的栈顶指针为对应栈的起始位置。
  2. StackEmpty：判断指定栈是否为空，空栈时 top 等于栈的起始位置。
  3. StackLength：返回指定栈的当前长度，通过栈顶指针减去栈的起始位置计算得到。
  4. GetTop：获取指定栈的栈顶元素，栈顶元素通过参数 e 返回。
  5. Push：将元素入指定栈，如果栈满则返回错误。
  6. Pop：将指定栈的栈顶元素出栈，并通过参数 e 返回该元素。
  7. DestroyStack：销毁栈，释放所有分配的内存。
  8. ClearStack：清空指定栈，只需将对应栈的栈顶指针重置为该栈的起始位置。
  9. TraverseStack：遍历指定栈并打印所有栈中的元素。
#include <stdio.h>
#include <stdlib.h>

typedef int ElemType; // 根据实际需要定义元素类型
#define NUM_STACKS 3  // 假设实现3个栈
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;

typedef struct {
    ElemType *elem;            // 动态分配的数组基址
    int tops[NUM_STACKS];       // 每个栈的栈顶指针
    int size;                  // 每个栈的容量
} SqStack_Multi;

// 初始化栈
Status InitStack(SqStack_Multi &S, int stack_size) {
    S.elem = (ElemType *)malloc(NUM_STACKS * stack_size * sizeof(ElemType));
    if (!S.elem) return OVERFLOW; // 分配失败
    S.size = stack_size;
    for (int i = 0; i < NUM_STACKS; i++) {
        S.tops[i] = i * stack_size;  // 每个栈的初始栈顶指针设置为对应的初始位置
    }
    return OK;
}

// 判断某个栈是否为空
Status StackEmpty(SqStack_Multi S, int stack_num) {
    if (stack_num < 0 || stack_num >= NUM_STACKS) return ERROR; // 无效的栈号
    return S.tops[stack_num] == stack_num * S.size ? OK : ERROR;
}

// 获取某个栈的长度
int StackLength(SqStack_Multi S, int stack_num) {
    if (stack_num < 0 || stack_num >= NUM_STACKS) return ERROR; // 无效的栈号
    return S.tops[stack_num] - stack_num * S.size;
}

// 获取某个栈的栈顶元素
Status GetTop(SqStack_Multi S, int stack_num, ElemType &e) {
    if (stack_num < 0 || stack_num >= NUM_STACKS) return ERROR; // 无效的栈号
    if (StackEmpty(S, stack_num) == OK) return ERROR; // 栈空
    e = S.elem[S.tops[stack_num] - 1];
    return OK;
}

// 入栈操作
Status Push(SqStack_Multi &S, int stack_num, ElemType e) {
    if (stack_num < 0 || stack_num >= NUM_STACKS) return ERROR; // 无效的栈号
    if (S.tops[stack_num] >= (stack_num + 1) * S.size) { // 栈满
        return OVERFLOW;
    }
    S.elem[S.tops[stack_num]++] = e;  // 元素入栈，top 后移
    return OK;
}

// 出栈操作
Status Pop(SqStack_Multi &S, int stack_num, ElemType &e) {
    if (stack_num < 0 || stack_num >= NUM_STACKS) return ERROR; // 无效的栈号
    if (StackEmpty(S, stack_num) == OK) return ERROR; // 栈空
    e = S.elem[--S.tops[stack_num]];  // 栈顶元素出栈，top 前移
    return OK;
}

// 销毁栈
Status DestroyStack(SqStack_Multi &S) {
    if (S.elem) {
        free(S.elem);
        S.elem = NULL;
    }
    for (int i = 0; i < NUM_STACKS; i++) {
        S.tops[i] = 0;
    }
    S.size = 0;
    return OK;
}

// 清空某个栈
Status ClearStack(SqStack_Multi &S, int stack_num) {
    if (stack_num < 0 || stack_num >= NUM_STACKS) return ERROR; // 无效的栈号
    S.tops[stack_num] = stack_num * S.size;  // 重置栈顶指针
    return OK;
}

// 遍历某个栈并打印栈中的所有元素
void TraverseStack(SqStack_Multi S, int stack_num) {
    if (stack_num < 0 || stack_num >= NUM_STACKS) {
        printf("Invalid stack number\n");
        return;
    }
    printf("Stack %d elements: ", stack_num);
    for (int i = stack_num * S.size; i < S.tops[stack_num]; i++) {
        printf("%d ", S.elem[i]);
    }
    printf("\n");
}

int main() {
    SqStack_Multi S;
    ElemType e;

    // 初始化栈
    if (InitStack(S, 5) == OK) {
        printf("Stack initialized successfully.\n");
    }

    // 入栈操作
    for (int i = 0; i < 10; i++) {
        if (Push(S, i % NUM_STACKS, i) == OK) {
            printf("Element %d pushed onto stack %d.\n", i, i % NUM_STACKS);
        }
    }

    // 获取栈顶元素
    for (int i = 0; i < NUM_STACKS; i++) {
        if (GetTop(S, i, e) == OK) {
            printf("Top element of stack %d: %d\n", i, e);
        }
    }

    // 遍历栈
    for (int i = 0; i < NUM_STACKS; i++) {
        TraverseStack(S, i);
    }

    // 出栈操作
    for (int i = 0; i < NUM_STACKS; i++) {
        if (Pop(S, i, e) == OK) {
            printf("Element %d popped from stack %d.\n", e, i);
        }
    }

    // 清空栈
    for (int i = 0; i < NUM_STACKS; i++) {
        ClearStack(S, i);
    }

    // 销毁栈
    DestroyStack(S);

    return 0;
}


11.用链表实现的顺序栈

typedef struct Node {
    ElemType data;        // 节点存储的数据
    struct Node *next;    // 指向下一个节点的指针
} StackNode;

typedef struct {
    StackNode *top;       // 指向栈顶节点的指针
    int length;           // 栈中元素的数量
} LinkStack;

特点

虽然这种实现不是严格的“顺序栈”，但可以模拟顺序栈的行为。链表节点相当于栈中的每个元素，这样的栈没有容量限制。

常见操作接口

  1. InitStack：初始化栈，将栈顶指针 top 设为 NULL，并将栈长度 length 设为 0。
  2. StackEmpty：判断栈是否为空，空栈时 length 为 0。
  3. StackLength：返回栈的当前长度，即栈中的元素数量。
  4. GetTop：获取栈顶元素，栈顶元素通过参数 e 返回。
  5. Push：将元素入栈，分配新的栈节点，将其放在栈顶。
  6. Pop：将栈顶元素出栈，并通过参数 e 返回该元素，释放栈顶节点。
  7. DestroyStack：销毁栈，释放所有节点的内存。
  8. ClearStack：清空栈，实际操作和销毁栈一样，将所有节点释放掉。
  9. TraverseStack：遍历栈并打印所有栈中的元素。
#include <stdio.h>
#include <stdlib.h>

typedef int ElemType; // 根据实际需要定义元素类型
#define OK 1
#define ERROR 0
typedef int Status;

typedef struct Node {
    ElemType data;        // 节点存储的数据
    struct Node *next;    // 指向下一个节点的指针
} StackNode;

typedef struct {
    StackNode *top;       // 指向栈顶节点的指针
    int length;           // 栈中元素的数量
} LinkStack;

// 初始化栈
Status InitStack(LinkStack &S) {
    S.top = NULL;
    S.length = 0;
    return OK;
}

// 判断栈是否为空
Status StackEmpty(LinkStack S) {
    return S.length == 0 ? OK : ERROR;
}

// 获取栈的长度
int StackLength(LinkStack S) {
    return S.length;
}

// 获取栈顶元素
Status GetTop(LinkStack S, ElemType &e) {
    if (StackEmpty(S) == OK) return ERROR; // 栈空
    e = S.top->data;  // 栈顶元素
    return OK;
}

// 入栈操作
Status Push(LinkStack &S, ElemType e) {
    StackNode *newNode = (StackNode *)malloc(sizeof(StackNode));
    if (!newNode) return ERROR; // 分配失败
    newNode->data = e;
    newNode->next = S.top;  // 新节点指向当前栈顶节点
    S.top = newNode;        // 栈顶指针指向新节点
    S.length++;             // 栈长度增加
    return OK;
}

// 出栈操作
Status Pop(LinkStack &S, ElemType &e) {
    if (StackEmpty(S) == OK) return ERROR; // 栈空
    StackNode *temp = S.top;  // 暂存栈顶节点
    e = temp->data;           // 取出栈顶元素
    S.top = S.top->next;      // 栈顶指针指向下一个节点
    free(temp);               // 释放原栈顶节点
    S.length--;               // 栈长度减少
    return OK;
}

// 销毁栈
Status DestroyStack(LinkStack &S) {
    StackNode *current = S.top;
    while (current) {
        StackNode *temp = current;
        current = current->next;
        free(temp); // 逐个释放节点
    }
    S.top = NULL;
    S.length = 0;
    return OK;
}

// 清空栈
Status ClearStack(LinkStack &S) {
    DestroyStack(S); // 清空栈和销毁栈是相同的操作
    return OK;
}

// 遍历栈并打印栈中的所有元素
void TraverseStack(LinkStack S) {
    StackNode *current = S.top;
    printf("Stack elements: ");
    while (current) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");
}

int main() {
    LinkStack S;
    ElemType e;

    // 初始化栈
    if (InitStack(S) == OK) {
        printf("Stack initialized successfully.\n");
    }

    // 入栈操作
    for (int i = 0; i < 10; i++) {
        if (Push(S, i) == OK) {
            printf("Element %d pushed onto stack.\n", i);
        }
    }

    // 获取栈顶元素
    if (GetTop(S, e) == OK) {
        printf("Top element: %d\n", e);
    }

    // 遍历栈
    TraverseStack(S);

    // 出栈操作
    while (Pop(S, e) == OK) {
        printf("Element %d popped from stack.\n", e);
    }

    // 清空栈
    ClearStack(S);

    // 销毁栈
    DestroyStack(S);

    return 0;
}

12.带有扩展属性的顺序栈

typedef struct {
    ElemType *elem;     // 动态分配的数组基址
    int top;            // 栈顶位置，指向栈顶元素的下一个位置
    int size;           // 当前栈的容量
    int max_size;       // 栈的最大容量
    int min_size;       // 栈的最小容量
} SqStack_Extended;

特点

这种顺序栈除了基本的栈功能外，还可以添加额外的属性，例如栈的最大容量、栈的最小容量等。

常见操作接口

  1. InitStack：初始化栈，分配初始的存储空间，并设置 top 为 0，指定栈的最大容量和最小容量。
  2. StackEmpty：判断栈是否为空，空栈时 top 为 0。
  3. StackLength：返回栈的当前长度，即栈中的元素数量。
  4. GetTop：获取栈顶元素，栈顶元素通过参数 e 返回。
  5. ExpandStack：扩容操作，当栈满时，容量加倍，确保容量不超过最大限制。
  6. ShrinkStack：缩容操作，当栈使用量低于容量的四分之一时，将容量减半，但不低于最小限制。
  7. Push：将元素入栈，如果栈满则自动扩容。
  8. Pop：将栈顶元素出栈，并通过参数 e 返回该元素，出栈后可能自动缩容。
  9. DestroyStack：销毁栈，释放所有分配的内存。
  10. ClearStack：清空栈，将 top 重置为 0。
  11. TraverseStack：遍历栈并打印所有栈中的元素。
#include <stdio.h>
#include <stdlib.h>

typedef int ElemType; // 根据实际需要定义元素类型
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define UNDERFLOW -3
typedef int Status;

typedef struct {
    ElemType *elem;     // 动态分配的数组基址
    int top;            // 栈顶位置，指向栈顶元素的下一个位置
    int size;           // 当前栈的容量
    int max_size;       // 栈的最大容量
    int min_size;       // 栈的最小容量
} SqStack_Extended;

// 初始化栈
Status InitStack(SqStack_Extended &S, int initial_size, int max_size, int min_size) {
    if (initial_size < min_size || initial_size > max_size) return ERROR;
    
    S.elem = (ElemType *)malloc(initial_size * sizeof(ElemType));
    if (!S.elem) return OVERFLOW; // 分配失败
    S.top = 0;
    S.size = initial_size;
    S.max_size = max_size;
    S.min_size = min_size;
    
    return OK;
}

// 判断栈是否为空
Status StackEmpty(SqStack_Extended S) {
    return S.top == 0 ? OK : ERROR;
}

// 获取栈的长度
int StackLength(SqStack_Extended S) {
    return S.top;
}

// 获取栈顶元素
Status GetTop(SqStack_Extended S, ElemType &e) {
    if (StackEmpty(S) == OK) return ERROR; // 栈空
    e = S.elem[S.top - 1];  // 栈顶元素
    return OK;
}

// 扩容操作
Status ExpandStack(SqStack_Extended &S) {
    int new_size = S.size * 2;
    if (new_size > S.max_size) return OVERFLOW; // 超过最大容量

    ElemType *newbase = (ElemType *)realloc(S.elem, new_size * sizeof(ElemType));
    if (!newbase) return OVERFLOW; // 分配失败
    
    S.elem = newbase;
    S.size = new_size;

    return OK;
}

// 缩容操作
Status ShrinkStack(SqStack_Extended &S) {
    if (S.size <= S.min_size) return ERROR; // 已经是最小容量

    int new_size = S.size / 2;
    if (new_size < S.min_size) new_size = S.min_size;

    ElemType *newbase = (ElemType *)realloc(S.elem, new_size * sizeof(ElemType));
    if (!newbase) return OVERFLOW; // 分配失败
    
    S.elem = newbase;
    S.size = new_size;

    return OK;
}

// 入栈操作
Status Push(SqStack_Extended &S, ElemType e) {
    if (S.top >= S.size) { // 栈满
        if (ExpandStack(S) != OK) { // 扩容失败返回错误
            return OVERFLOW;
        }
    }

    S.elem[S.top++] = e;  // 元素入栈

    return OK;
}

// 出栈操作
Status Pop(SqStack_Extended &S, ElemType &e) {
    if (StackEmpty(S) == OK) return ERROR; // 栈空
    e = S.elem[--S.top];  // 栈顶元素出栈

    // 自动缩容
    if (S.top <= S.size / 4 && S.size > S.min_size) {
        ShrinkStack(S);
    }

    return OK;
}

// 销毁栈
Status DestroyStack(SqStack_Extended &S) {
    if (S.elem) {
        free(S.elem);
        S.elem = NULL;
    }
    S.top = 0;
    S.size = 0;
    S.max_size = 0;
    S.min_size = 0;
    return OK;
}

// 清空栈
Status ClearStack(SqStack_Extended &S) {
    S.top = 0;
    return OK;
}

// 遍历栈并打印栈中的所有元素
void TraverseStack(SqStack_Extended S) {
    printf("Stack elements: ");
    for (int i = 0; i < S.top; i++) {
        printf("%d ", S.elem[i]);
    }
    printf("\n");
}

int main() {
    SqStack_Extended S;
    ElemType e;

    // 初始化栈
    if (InitStack(S, 5, 20, 5) == OK) {
        printf("Stack initialized successfully.\n");
    }

    // 入栈操作
    for (int i = 0; i < 15; i++) {
        if (Push(S, i) == OK) {
            printf("Element %d pushed onto stack.\n", i);
        }
    }

    // 获取栈顶元素
    if (GetTop(S, e) == OK) {
        printf("Top element: %d\n", e);
    }

    // 遍历栈
    TraverseStack(S);

    // 出栈操作
    while (Pop(S, e) == OK) {
        printf("Element %d popped from stack.\n", e);
    }

    // 清空栈
    ClearStack(S);

    // 销毁栈
    DestroyStack(S);

    return 0;
}

以上就是一些顺序栈的表示和实现，不同的顺序栈要放在合适的地方使用，确保代码的正确运行。

俺是答案
关注
（数据结构）1.实现顺序栈的各种基本运算 2.实现环形队列的各种基本运算
weixin_41032720的博客
07-06 7620
实验内容 1.编写一个程序，实现顺序栈（假设栈中元素类型ElemType为char）的各种基本运算，并在此基础上完成以下功能。 （1）初始化栈s。 （2）判断栈s是否为空。 （3）依次进栈元素a、b、c、d、e。 （4）判断栈s是否为空。 （5）输出出栈序列。 （6）判断栈s是否为空。 （7）释放栈。 2.编写一个程序,实现环形队列（假设栈中元素类型ElemType为char）的各种基本运算，并在...
顺序栈的表示和实现
Bee_Darker的博客
10-24 934
顺序栈的定义 typedef struct{ SElemType  *base;        //存储空间基址 SElemType    *top;        //栈指针 int           stacksize;       //分配容量 )SqStack; 2.基本操作的函数原型 1）创建 Status InitStack(SqStack &amp;S); 操作...
栈的顺序表示和实现
sumi_的博客
10-20 4569
栈是仅限定在表位进行插入和删除的线性表。因此，对栈来说，表尾端有其特殊含义，称为栈顶，相应的表头端称为栈底。不含元素的空表称为空栈。 假设栈S=(a1,a2,...,an)，则称a1为栈底元素，an为栈顶元素。栈中元素按啊a1，a2，...，an的次序进栈，退栈的第一个元素应是栈顶元素。换句话说，栈的修改是按后进先出的原则进行的。因此，栈又称后进先出的戏线性表（简称LIFO结构）。 栈
顺序栈的表示和实现（有详细注释）
weixin_46422883的博客
03-29 1083
#include <iostream.h> #define OVERFLOW 0//定义“溢出”为0 #define ERROR 0 #define OK 1 #define MAXSIZE 100//顺序栈存储空间的初始分配量 typedef int SElemType;//SElemType为数据类型 typedef int Status;//定义结构体 //顺序栈的类型定义...
实现顺序栈的各种基本运算的算法
weixin_45959708的博客
08-19 9564
#include <stdio.h> #include <malloc.h> #define MaxSize 100 typedef char ElemType; typedef struct { ElemType data[MaxSize]; int top; } SqStack; /* 1.初始化栈InitStack(&s)，该运算创建一个空栈，由s指向它 实际上就是分配一个顺序栈空间，并将栈顶指针设置为-1 */ void InitStack(SqStack
数据结构——顺序栈详解
weixin_51785373的博客
10-20 2022
1、栈：特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则2、初始化栈（init）：创建一个空栈，把栈顶指针设为-1.3、入栈（Push)：插入元素到栈顶元素的操作4、出栈(pop)：从栈顶删除最后一个元素的操作5、判断是否为空：检查栈顶指针是否指向存储空间的起始位置top为-1。
顺序栈ADT数据结构代码
12-02
总结，顺序栈是一种重要的数据结构，它在C语言中通过结构体和数组实现。`SqStack.c`和`SqStack.h`文件定义了顺序栈的操作，`main.c`提供了测试代码，而`RandomElementFactory.c/h`文件则可能提供了辅助的随机元素...
数据结构　顺序栈（C++）
06-07
在C++中，我们可以自定义一个顺序栈类来实现这种数据结构。 顺序栈的基本操作包括初始化、入栈（push）、出栈（pop）、查看栈顶元素（top）以及判断栈是否为空（isEmpty）。下面我们将详细介绍这些操作的实现及其...
顺序栈的表示和实现源码
11-12
顺序栈是一种常见的数据结构，它遵循“后进先出”（LIFO...以上是顺序栈的基本操作及其实现原理。实际编程中，还可以根据需求实现其他功能，如查找、合并栈等。顺序栈简单易懂，效率高，适用于许多算法和数据处理场景。
数据结构中栈和队列思想的停车场管理系统
02-25
基于c语言数据结构中栈和队列思想的简单停车场管理系统，以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车...
顺序栈的实现
程序猿的挨踢人生
02-15 1622
其实栈也是线性表，只是其为操作有限制的线性表，栈的插入和删除被限制为只能在表尾进行。栈也有两种表示方式：顺序表示和链式表示。栈的基本操作除了在栈顶进行插入、删除之外还有栈的初始化、栈顶元素等操作。顺序栈使用一组连续的内存空间存放数据，附设两个指针分别指向栈顶和栈底，通过栈顶和栈底是否相等可判断栈是否为空。
5.顺序栈和链栈的基本算法实现
qq_73893594的博客
11-08 487
至此栈的存储结构告一段落，下期将实现环形队列与链队的基本算法^_^值得注意的是，在栈中判断栈是否为空的条件应该是。内容：编写一个程序实现链栈（假设栈中元素类型。(3）依次进栈元素a、b、c、d、e。编写一个程序实现顺序栈（假设栈中元素类型。（3）依次进栈元素a、b、c、d、e。ElemType为char。（2）判断栈s是否非空。（4）判断栈s是否非空。（6）判断栈s是否非空。（2）判断栈s是否非空。（4）判断栈s是否非空。（6）判断栈s是否非空。（5）输出出栈序列。而不是top==0.（5）输出出栈序列。
实验一 -2-1：栈的典型算法实现
最新发布
此人很懒
01-06 410
本实验的设计思想是使用C++语言实现顺序栈的基本操作，包括初始化、判断是否为空、进栈、出栈和释放等操作。在设计顺序栈时，需要考虑如何初始化、判断是否为空、进栈、出栈和释放等操作的具体实现方式。编写及实现顺序栈的定义及基本操作函数编写一个程序sqstack.cpp，实现顺序栈（假设栈的基本元素类型为char）的各种基本运算，并在此基础上设计一个程序完成下述功能。5.出栈时，将指针指向数组的起始位置，并返回该位置的元素值。3.实现判断栈是否非空的函数，用于判断栈是否为空。6.释放栈时，清空数组和指针即可。
10.栈的定义，表示与实现
qq_54708219的博客
08-19 229
栈和队列是两种常用的，重要的数据结构。栈和队列是限定的线性表。其中，栈只能插入在表尾，删除也只能在表尾。由于栈的操作具有的固有特性，栈成为程序设计中的有用工具。
实验二栈和队列
qq_57611608的博客
06-04 3733
实验二 栈和队列 一、实验目的和要求 1、理解栈的存储结构及基本操作实现。 2、掌握应用栈解决问题的方法。 3、掌握队列的存储结构及基本操作实现，并能在相应的应用问题中正确选用它们。 二、实验仪器和设备 微型计算机 三、实验内容与过程 1、验证性实验：实现顺序栈的基本操作 实验内容：编写一个程序sqstack.cpp (或.c)，实现顺序栈的各种基本运算（假设栈中元素类型SElemType为char），并在此基础上设计一个程序exp3-1.cpp (或.c)完成以下功能。 (1) 初..
栈的top指针指向哪里_栈和队列
热门推荐
weixin_39893042的博客
12-03 1万+
栈： 后进先出（Last In First Out，LIFO）的线性序列，称为“栈”。栈也是一种线性表，只不过它是操作受限的线性表，只能在一端进出操作。进出的一端称为栈顶（top）,另一端称为栈底（base）。栈可以用顺序存储，也可以用链式存储，分别称为顺序栈和链栈。顺序栈： 顺序栈需要两个指针，base表示栈底指针（指向首地址或基地址），top表示栈顶指针。（top指针永远指向...
【数据结构（13）】3.3 栈的表示和操作的实现
shangguanxiu的博客
12-30 1482
严蔚敏版【数据结构】 一、栈的抽象数据类型的类型定义 1. 栈的基本操作 二、顺序栈的表示和实现 1. 顺序栈的表示 2. 顺序栈的实现 2.1 顺序栈的初始化 2.2 判断顺序栈是否为空 2.3 求顺序栈长度 2.4 清空顺序栈 2.5 销毁顺序栈 2.6 顺序栈的入栈 2.7 顺序栈的出栈 三、链栈的表示和实现 1. 链栈的表示 2. 链栈的实现 2.1 链栈的初始化 2.2 判断链栈是否为空 2.3 链栈的入栈 2.4 链栈的出栈 2.5 取链栈的栈顶元素
c语言怎样计算栈的长度,C语言 栈的表示和实现详细介绍
weixin_30979229的博客
05-22 2514
C语言 栈的表示和实现详细介绍定义：栈是限定仅在表尾进行插入和删除操作的线性表。栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据(最后一个数据被第一个读出来)。栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底指针。栈是允许在同一端进行插入和删除操作的特殊线性表。允许进...
数据结构讲义：顺序栈的表示与实现
"顺序栈表示与实现的详细讲解，包括数据结构的基础知识，以及栈作为线性结构的一种应用。" 顺序栈是数据结构中的一个重要概念，它是一种特殊的线性表，具有后进先出（LIFO）的特性。在顺序栈中，元素按照进入的顺序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值