栈的操作c与java

描述

请你实现一个栈。

操作：

push x：将 加x\x 入栈，保证 x\x 为 int 型整数。

pop：输出栈顶，并让栈顶出栈

top：输出栈顶，栈顶不出栈

代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define maxsize 100000 //栈存储空间的初始分配量
//存储的栈结构
typedef struct{
    int a[maxsize];//构造一个空栈，动态分配一个最大容量为maxsize的数组空间
    int top;//栈顶指针 就代表是一个空栈
}stack;
//初始化栈
void InitStack(stack *s){
    s->top=-1;//空是-1 栈低是从0开始的 0是一个值 也就是一个栈顶
}
//入栈
void push(stack *s,int x){
    if(s->top==maxsize) printf("error\n");//就是说判断一下这个栈是否是栈满
    else{
        s->a[s->top]=x;//第一次就将这个栈顶的值个这个数组
        s->top++;//栈顶加加
    }
}
//出栈
void pop(stack *s){
    if(s->top==-1) printf("error\n");//栈空了
    else{
        s->top--;//就是先进后出 将后边的栈顶的元素进行出栈，
        printf("%d\n",s->a[s->top]);//将这个栈的数据输出一下，实际就是将栈清楚了一格
        
    }
}
//取出栈顶元素 栈顶指针保持不变
void top(stack *s){
    if(s->top==-1) printf("error\n");//要求栈不能是空栈
    else {
        printf("%d\n",s->a[--s->top]);//取出栈顶元素
        s->top++;
         }
}
int main(){
    int n;
    scanf("%d",&n);
    //malloc动态申请连续的存储空间
    stack *s=(stack*)malloc(sizeof(stack));
    //调用初始化栈
    InitStack(s);
    while(n--){
        
        char *str=(char*)malloc(6*sizeof(char));//连续的char类型的存储空间
        scanf("%s",str);//一次一输入
        if(!strcmp(str,"top")) top(s);
        if(!strcmp(str,"pop")) pop(s);
        if(!strcmp(str,"push")){
            int num;
            scanf("%d",&num);
            push(s, num);
        }
    }
    return 0;
}

java代码实现：

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
 
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    private static Scanner sc = new Scanner(System.in);
    public static void main(String[] args) {
        Stack stack = new Stack();
        List<String> res = new ArrayList<>();
        int n = Integer.parseInt(sc.nextLine());
        for (int i = 0; i < n; i++) {
            String line = sc.nextLine();
            if (line.startsWith("push")) {
                stack.push(Integer.parseInt(line.split(" ")[1]));
            } else if ("pop".equals(line)) {
                res.add(stack.pop());
            } else {
                res.add(stack.top());
            }
        }
        for (String elem : res) {
            System.out.println(elem);
        }
    }
}
 
class Stack {
    // 存储数组
    private int[] innerArr = new int[10];
    // 栈顶
    private int top = -1;
 
    /**
     * 检查剩余空间是否满足要求
     */
    private boolean checkSize() {
        if (top>=innerArr.length-1) return false;
        return true;
    }
 
    /**
     * 为 innerArr 重新分配空间
     */
    private void resize() {
        int newSize = innerArr.length * 2;
        int[] newInnerArr = new int[newSize];
        for (int i = 0; i < innerArr.length; i++) {
            newInnerArr[i]=innerArr[i];
        }
        innerArr = newInnerArr;
    }
 
    /**
     * 栈输入
     * @param num
     */
    public void push(int num) {
        if (!checkSize()) resize();
        innerArr[++top]=num;
    }
 
    /**
     * 输出栈顶，不出栈
     * @return
     */
    public String top() {
        if (top==-1) return "error";
        return String.valueOf(innerArr[top]);
    }
 
    /**
     * 出栈
     * @return
     */
    public String pop() {
        if (top==-1) return "error";
        return String.valueOf(innerArr[top--]);
    }
 
}

测试结果：

输入：

6
push 1
pop
top
push 2
push 3
pop

复制

输出：

1
error
3