顺序栈是一种常见的数据结构，它在内存中按顺序分配元素，通常用于临时存储和处理一组数据。本主题将深入探讨顺序栈的实现，包括C、C++和Java三种编程语言的源码分析。
我们从C语言的角度来理解顺序栈。在C中，我们通常使用数组作为基础数据结构来实现顺序栈。以下是一个简单的顺序栈定义：
```c
#define MAX_SIZE 100 // 定义栈的最大容量
typedef int ElementType; // 定义栈元素的类型
typedef struct {
ElementType data[MAX_SIZE]; // 用于存储元素的数组
int top; // 栈顶指针，表示栈中元素的个数
} SeqStack;
```
接下来是栈的基本操作，如初始化、压栈（push）、弹栈（pop）和查看栈顶元素（top）：
```c
void InitStack(SeqStack* s) {
s->top = -1; // 初始化栈顶指针为-1，表示空栈
}
int IsEmpty(SeqStack s) {
return s.top == -1; // 如果栈顶指针为-1，则栈为空
}
void Push(SeqStack* s, ElementType x) {
if (s->top < MAX_SIZE - 1) {
s->top++;
s->data[s->top] = x; // 将元素压入栈顶
} else {
printf("Stack overflow!\n"); // 栈溢出，无法压入元素
}
}
ElementType Pop(SeqStack* s) {
if (!IsEmpty(*s)) {
ElementType x = s->data[s->top];
s->top--;
return x; // 弹出栈顶元素并返回
} else {
printf("Stack underflow!\n"); // 栈为空，无法弹出元素
return 0;
}
}
ElementType Top(SeqStack s) {
if (!IsEmpty(s)) {
return s.data[s.top]; // 返回栈顶元素，但不弹出
} else {
printf("Stack is empty!\n");
return 0;
}
}
```
现在我们转向C++。C++提供了类的概念，使得顺序栈的实现更加面向对象：
```cpp
#include <iostream>
using namespace std;
const int MAX_SIZE = 100;
class SeqStack {
private:
int data[MAX_SIZE];
int top;
public:
SeqStack() { top = -1; } // 构造函数，初始化栈顶指针
bool isEmpty() { return top == -1; }
void push(int x) {
if (top < MAX_SIZE - 1) {
top++;
data[top] = x;
} else {
cout << "Stack overflow!" << endl;
}
}
int pop() {
if (!isEmpty()) {
int x = data[top];
top--;
return x;
} else {
cout << "Stack underflow!" << endl;
return 0;
}
}
int topValue() {
if (!isEmpty()) {
return data[top];
} else {
cout << "Stack is empty!" << endl;
return 0;
}
}
};
```
我们来看Java的实现。Java中同样使用类来封装顺序栈：
```java
import java.util.Arrays;
public class SeqStack {
private int[] data;
private int top;
private final int MAX_SIZE = 100;
public SeqStack() {
data = new int[MAX_SIZE];
top = -1;
}
public boolean isEmpty() {
return top == -1;
}
public void push(int x) {
if (top < MAX_SIZE - 1) {
top++;
data[top] = x;
} else {
System.out.println("Stack overflow!");
}
}
public int pop() {
if (!isEmpty()) {
int x = data[top];
top--;
return x;
} else {
System.out.println("Stack underflow!");
return 0;
}
}
public int getTop() {
if (!isEmpty()) {
return data[top];
} else {
System.out.println("Stack is empty!");
return 0;
}
}
}
```
以上代码展示了C、C++和Java三种语言中顺序栈的基本实现。顺序栈的优势在于其操作简单高效，但由于数组的固定大小，可能导致栈溢出问题。在实际应用中，可以考虑使用动态数组或链表等数据结构来改进顺序栈，以适应不同规模的数据存储需求。
