链栈的初始化、入栈、出栈、取栈顶元素的算法代码

好的，我可以帮您提供链栈的算法代码。

链栈的初始化算法代码：

void InitStack(LinkStack &S){
    S.top = NULL;
}

链栈的入栈算法代码：

void Push(LinkStack &S, ElemType x){
    StackNode *s = new StackNode;
    s->data = x;
    s->next = S.top;
    S.top = s;
}

链栈的出栈算法代码：

ElemType Pop(LinkStack &S){
    if (S.top == NULL){
        // 栈空
        return ERROR;
    }
    StackNode *p = S.top;
    S.top = p->next;
    ElemType x = p->data;
    delete p;
    return x;
}

链栈的取栈顶元素算法代码：

ElemType GetTop(LinkStack S){
    if (S.top == NULL){
        // 栈空
        return ERROR;
    }
    return S.top->data;
}

希望能够帮助到您。

相关问题

C语言1.写出顺序栈和链栈的存储结构及初始化。2、写出顺序栈的入栈、出栈、取栈顶元素算法描述，代码表示。3、写出链栈的入栈、出栈、取栈顶元素算法描述，代码表示。

C语言中的顺序栈（基于数组实现）和链栈（基于链表实现）的存储结构和初始化如下：

1. **顺序栈（Array Stack）**:
-1`（假设数组大小为n）。
- 初始化：创建数组并初始化`top`为-1，如：

     int stack[n]; // 定义栈
     top = -1; // 栈顶初始为空

2. **顺序栈操作**:
- 入栈（Push）: 新元素插入到栈顶，`top++`，然后将元素存入`stack[top]`。
- 出栈（Pop）: 删除栈顶元素，返回`stack[top--]`。
- 取栈顶元素（Top）: 返回`stack[top]`，但不删除，保持`top`不变。
- 代码表示（使用数组索引）:

     void push(int value) {
       if (top < n - 1) {
         stack[++top] = value;
       } else {
         printf("Stack overflow.\n");
       }
     }

     int pop() {
       if (top >= 0) {
         return stack[top--];
       } else {
         printf("Stack underflow.\n");
         return -1; // 或者抛出异常
       }
     }

     int peek() {
       return top >= 0 ? stack[top] : -1;
     }

3. **链栈（Linked List Stack）**:
- 存储结构：每个节点包含数据域`data`和指向下一个节点的指针`next`，栈顶指针`top`指向链表头节点。
- 初始化：创建一个空链表，并设置`top`为NULL。
- 示例：

     struct Node {
       int data;
       struct Node* next;
     };
     
     struct Node* stack_top = NULL; // 栈顶初始为空

4. **链栈操作**:
- 入栈（Push）: 创建新节点，将其`next`指向当前`top`，然后`top`指向新节点。
- 出栈（Pop）: 删除`top`节点，如果`top`非NULL，则更新`top`为`top->next`。
- 取栈顶元素（Top）: 返回`top->data`，但不删除，保持`top`不变。
- 代码表示（链表形式）:

     void push(int value) {
       struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
       newNode->data = value;
       newNode->next = top;
       top = newNode;
     }

     void pop() {
       if (top != NULL) {
         struct Node* temp = top;
         top = top->next;
         free(temp);
       } else {
         printf("Stack underflow.\n");
       }
     }

     int peek() {
       return top != NULL ? top->data : -1;
     }

链栈的初始化，入栈，出栈，取栈顶元素算法实现的程序

非常感谢您的提问！以下是链栈的初始化、入栈、出栈、取栈顶元素的算法实现的程序:

#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10

typedef struct{
ElemType *base;
ElemType *top;
int stacksize;
}Stack;

//初始化栈
void InitStack(Stack &S){
S.base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));
if(!S.base) exit(0);
S.top = S.base;
S.stacksize = STACK_INIT_SIZE;
}

//进栈操作
void Push(Stack &S, ElemType e){
if(S.top - S.base >= S.stacksize){
S.base = (ElemType *)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(ElemType));
if(!S.base) exit(0);
S.top = S.base + S.stacksize;
S.stacksize += STACKINCREMENT;
}
*S.top++ = e;
}

//出栈操作
void Pop(Stack &S, ElemType &e){
if(S.top == S.base) exit(0);
e = *--S.top;
}

//获取栈顶元素
ElemType GetTop(Stack S){
if(S.top != S.base) return *(S.top - 1);
else exit(0);
}

注意：以上代码仅供参考，具体实现需要根据具体需求进行优化和修改。