基础数据结构—栈（一），Java模拟栈，Java判断栈弹出序列是否可能

栈的相关操作：

• push()，将一个元素压栈
• pop()，将一个元素弹栈，在栈中删除它，只有栈顶元素才能被弹出。
• top()，返回栈顶元素值

一个题目

实现栈，完成相应的输入输出。
如果操作为push，则不输出任何东西。
如果为另外两种，若栈为空，则输出 "error“
否则按对应操作输出。
输入：

6  //正整数 n，代表接下来的操作次数
push 1
pop
top
push 2
push 3
pop

目标输出

1
error
3

通过数组模拟栈

import java.util.*;
/**
 * 使用int[]数组模拟栈
 */
public class stack1{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入操作次数n");
        int n = sc.nextInt();   
        // 获取总操作次数n
        // 这里需要自己写个Stack类来模拟栈。
        myStack s = new myStack(n);//假设n次操作都在压栈，那么数组也就最多n个元素
        for(int i=0;i<n;i++){
            System.out.println("请输入第"+(i+1)+"次操作");
            Scanner sc2 = new Scanner(System.in);
            String str = sc2.nextLine();//push 1之间是有个空格的
            String strArr[] = str.split(" ");   //通过spilt将push 1放入数组strArr
            if(strArr[0].equals("push")){ 
                //通过s使用push方法压栈
                s.push(Integer.parseInt(strArr[1]));
             }else if(strArr[0].equals("pop")){
                 //弹栈
                 s.pop();
             }else{
                 //返回栈顶元素
                 s.top();
             }
        }
        sc.close();
    }
}

class myStack{
    int[] data; //用数组来模拟栈中存放的数据
    int size=0; //栈中元素的个数
    int maxSize;    //栈中最多存放数据的个数
    myStack(){}
    myStack(int maxSize){ 
        this.maxSize=maxSize;
        data = new int[maxSize];    //一定记得初始化数组，不然后续操作空指针
    }
    //压栈
    void push(int val){
        if(this.size==this.maxSize){
            System.out.println("error");
        }else{
            data[this.maxSize-size-1]=val;
            this.size++;
        }
    }
    //弹栈
    void pop(){
        if(this.size==0){ System.out.println("error"); }
        else{
            System.out.println(data[this.maxSize-size]);
            this.size--;
        }
    }
    //查看栈顶元素
    void top(){
        if(this.size==0){ System.out.println("error"); }
        else{ System.out.println(data[maxSize-size]); }
    }
}

通过ArrayList模拟栈

import java.util.ArrayList;
import java.util.Scanner;
/**
 * 使用ArrayList模拟栈
 */
public class stack2 {
    static ArrayList list = new ArrayList<>();
    static void push(int x){
        list.add(x);
    }
    //注意Object返回值类型
    static Object pop(){
        if(!list.isEmpty()){
            int str = (Integer)list.get(list.size()-1);
            list.remove(list.size()-1);
            return str;
        }else{ return "error"; }
    }
    static Object top(){
        if(!list.isEmpty()){
            return list.get(list.size()-1);
        }else{
            return "error";
        }
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入操作次数i");
        int i = sc.nextInt();
        for(;i>=0;i--){
            String str = sc.nextLine();
            String[] strArr = str.split(" ");
            switch(strArr[0]){
                case "push":
                push(Integer.parseInt(strArr[1]));
                break;
                case "pop":
                System.out.println(pop());
                break;
                case "top":
                System.out.println(top());
                break;
            }
        }
    }
    
}

判断一个栈的弹出序列是否可能

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。

/**
 * 给一个栈的压栈顺序、弹栈顺序，判断该弹栈顺序是否可能
 */
import java.util.*;
public class stack3{
    public static void main(String[] args){
        int[] push1 = {1,2,3,4,5};
        int[] pop1 = {4,5,3,2,1};
        int[] pop2 ={4,3,5,1,2};    //这样压入的顺序，1又不能在2之前弹出，所以无法形成的，返回false
        System.out.println(maybe(push1, pop1));
        System.out.println(maybe(push1, pop2));
    }
    //判断boolean的思路
    static boolean maybe(int[] arr1,int[] arr2){
        if(arr1.length==0) return false;
        myStack s = new myStack(arr1.length);	//用vector模拟栈，也可以用数组，集合都行
        boolean bool = false;
        for(int i=0,j=0;i<arr1.length;){
            s.push(arr1[i++]);	//按压栈顺序进行push
            while(j<arr1.length&&(int)s.top()==arr2[j]){
                //j=0，如果j<出栈顺序的size进行循环。并且当前栈stack的top等于出战顺序pop1的第一个元素，那么就对stack栈进行弹栈
                s.pop();
                j++;
                if(j==arr2.length){
                    bool=true;
                }
            }
        }
        return bool;
    }
}

class myStack{
    int[] data; //用数组来模拟栈中存放的数据
    int size=0; //栈中元素的个数
    int maxSize;    //栈中最多存放数据的个数
    myStack(){}
    myStack(int maxSize){ 
        this.maxSize=maxSize;
        data = new int[maxSize];    //一定记得初始化数组，不然后续操作空指针
    }
    //压栈
    void push(int val){
        if(this.size==this.maxSize){
            System.out.println("error");
        }else{
            data[this.maxSize-size-1]=val;
            this.size++;
        }
    }
    //弹栈
    Object pop(){
        if(this.size==0){ return "error"; }
        else{
            return data[this.maxSize-(size--)];
        }
    }
    //查看栈顶元素
    Object top(){
        if(this.size==0){ return "error"; }
        else{ return data[maxSize-size]; }
    }
}