java中栈(Stack)创建的学习

栈的定义

1、栈是一个先入后出的有序列表
2、栈是限制线性表中的插入和删除只能在线性表是同一端进行的一种特殊法。插入和删除的一端，为变化的一端
   称为栈顶(Top)，另一端称为栈底(Bottom).
3、出栈(pop)和入栈(push)的概念

栈的创建：

第一种：通过数组来创建
 利用数组模拟栈：
      1、定义一个top来表示栈顶,初始化为-1
      2、入栈的操作时，当有数据加入到栈中，top++;   stack[top]=data;
      3、出栈的操作，当有数据出栈时，int value=stack[top]; top--; return value;
      		出栈的操作比较简单。
第二种：通过链表来创建

数组模拟栈

1. 先定义一个栈

class ArrayStack{
        // 栈的大小
        private int maxSize;
        // 模拟栈的数组
        private int[] stack;
        private int top=-1;   // 初始化栈顶为-1

    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        stack=new int[this.maxSize];
    }
}

2. 然后在栈类里面加入各种方法

• 判断栈满和栈空

    // 栈满
    public boolean ifFull(){
        return top==maxSize-1;
    }
    // 栈空
    public boolean isEmpty(){
        return top==-1;
    }

• 入栈操作

    //入栈
    public void push(int value){
        if(ifFull()){
            System.out.println("栈已满");
            return;
        }
        top++;
        stack[top]=value;
    }

• 出栈操作

   // 出栈
    public int  pop(){
        if(isEmpty()){
            System.out.println("栈为空");
        }
        int value=stack[top];
        top--;
        return value;
    }

• 遍历栈

   // 遍历
    public void show(){
        if(isEmpty()){
            System.out.println("栈为空");
        }
        for(int i=top;i>-1;i--){
            System.out.print(stack[i]);
        }
        System.out.println();
    }

3. 创建主类里的东西

import java.util.Scanner;
public class ArrayStackDemo {
    public static void main(String[] args){
        // 创建对象
        ArrayStack arrayStack=new ArrayStack(5);
        String fin=" ";
        boolean flag=true;
        Scanner sc=new Scanner(System.in);
		// 在这用了while+switch方法来通过显示窗口进行入栈，出栈，遍历等功能，flag作用是退出循环，fin是通过输入的数字来进行相应的功能。
        while(flag){
            System.out.println("1:show");
            System.out.println("2:push");
            System.out.println("3:pop");
            System.out.println("4:exit");
            fin=sc.next();
            switch (fin){
                case "1":
                    arrayStack.show();
                    break;
                case "2":
                    System.out.println("请输入一个数：");
                    int value=sc.nextInt();
                    arrayStack.push(value);
                    break;
                case "3":
                    try{
                    int res=arrayStack.pop();
                    System.out.println(res);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case "4":
                    sc.close();
                    flag=false;
                    break;
            }
        }
    }

}

用链表模拟栈

1. 先定义一个链表类

class Node{
    private int data;
    private Node next;

    public Node() {
    }

    public Node(Node next) {
        this.next = next;
    }

    public Node(int data) {
        this.data = data;
    }

    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }

    public Node getNext() {
        return next;
    }
	// a.setNext(b)的意思是a.next=b
    public void setNext(Node next) {
        this.next = next;
    }
}

2.定义栈类

• 栈类

// 表
class LinkedStack{
    // 定义一个头结点
    Node head=new Node();
    public Node getHead(){
        return head;
    }
    // 定义栈大小
    private int maxSize=5;
    private int top=-1;
    // 用来出栈的时候，循环用的
    private int sum=-1;
    // 判断栈是否为满
    public boolean isFull(){
        return top==maxSize-1;
    }
    // 判断栈是否为空
    public boolean isEmpty(){
        return top==-1;
    }
 }

• 入栈方法（由于栈是先进后出，所以我每加一个数据，就插入到链表头结点后面，当然也可以在最后加数据，这种最后加的出栈时需要反转链表）

    // 入栈
    public void push(int value) {
        Node temp = head;
        Node res = new Node(value);
        // 如果链表为空，就直接在头结点后面添加数据
        
        if(temp.getNext() == null) {
            temp.setNext(res);
            top++;
            sum++;
        } else {
        // 如果链表不为空，就要把数据插入到头结点后面，头结点原本的next要等于你插入的链，而且你插入的next要等于头结点原本的next
            res.setNext(temp.getNext());
            temp.setNext(res);
            top++;
            sum++;
        }
          System.out.println("top的值："+top);
 }

• 出栈方法（我这里可以多次出栈）

    // 出栈
    public int pop(){
        Node temp=head;
        if(isEmpty()){
            return -1;
        }
        int res=0 ;
        top--;
        for (int i = 0; i <sum-top; i++) {
            temp=temp.getNext();
            res=temp.getData();
        }
//        if(temp!=null) {
//            System.out.println("出栈的数为：" + res);
//        }
        return res;
    }

• 遍历方法

 // 遍历
    public void show(){
        Node temp=head.getNext();
        if(isEmpty()){
            return;
        }
        while(temp!=null){
            System.out.print(temp.getData()+" ");
            temp=temp.getNext();
        }
        System.out.println();
    }

3.定义主类

public class LinkedStackDemo {
    public static void main(String[] args) {
        LinkedStack linkedStack=new LinkedStack();
        Scanner sc=new Scanner(System.in);
        String key="";
        boolean flag=true;
        while (flag) {
            System.out.println("1:push");
            System.out.println("2:show");
            System.out.println("3:pop");
            System.out.println("4:exit");
            key=sc.next();
            switch (key){
                case "1":
                    System.out.println("请输入一个数：");
                    int value=sc.nextInt();
                    linkedStack.push(value);
                    break;
                case "2":
                    linkedStack.show();
                    break;
                case "3":
                    int popValue=linkedStack.pop();
                    if(popValue!=-1)
                        System.out.println("出栈的数为："+popValue);
                    else
                        System.out.println("栈空了");
                    break;
                case "4":
                    sc.close();
                    flag=false;
                    break;
            }
        }
    }
}

效果图