java数据结构之栈结构之算法（上）--用数组和链表模拟栈结构

1. 栈（Stack）的概念：

•   栈是一个先进后出的有序列表。
•  栈是限制线性表中元素的出入和删除只能在线性表的一段进行的一种特殊线性表。允许插入和删除的一端，为变化的一              端，成为栈顶 ，另一端为固定的一端，成为栈底。
•   最先存放入栈中的元素在栈底，最后放入栈中的元素在栈顶。删除元素时正好相反，最后放入的元素最先删除，最先放入的元素最后删除。

          

 2.  用数组来模拟栈结构：

        由于栈是一种有序列表，可以通过数组的结构来存储栈的数据内容。

   实现思路：

          1. 定义一个top变量来表示栈顶，初始化为-1.

          2. 入栈的操作，当有数据加入到栈时，top++; Stack [top]=data;

          3. 出栈的操作，int value=Stack.pop();  top--;  return  value

  3. 代码实现：

方法1：

package Stack.ArrayStack;

import java.util.Scanner;
import java.util.Stack;

public class ArrayStackDemo {
    public static void main(String[] args) {
        //测试一下ArrayStack是否正确
        //创建一个ArrayStack对象  表示栈
        ArrayStack Stack = new ArrayStack(4);
        String key="";
        boolean loop=true;//控制是否退出菜单。
        Scanner scanner=new Scanner(System.in);

        while (loop){
            System.out.println("show； 显示栈");
            System.out.println("exit； 退出栈");
            System.out.println("push； 入栈");
            System.out.println("pop； 出栈");
            System.out.println("请输出你的选择：");
            key=scanner.next();

            switch (key){
                case "show":
                    Stack.list();
                    break;
                case "exit":
                    scanner.close();
                    loop=false;
                    break;
                case "push":
                    System.out.println("请输入一个数：");
                    int value=scanner.nextInt();
                    Stack.push(value);
                    break;
                case "pop":
                    try {
                        int res=Stack.pop();
                        System.out.printf("出栈的数据是 %d\n",res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());;
                    }
                    break;
            }

        }
        System.out.println("程序退出!");

    }
}


// 定义一个ArrayStack 表示栈
class ArrayStack{
    private int maxSize;//栈的大小
    private int[] stack;//数组，数组模拟栈，数据就放在这个数组中。
    private int top=-1;//top表示栈顶，初始化为-1
    private Object Stack;

    //构造函数
    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        stack=new int[this.maxSize];
    }

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

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

    //出栈
    public int pop(){
        //先判断栈是否为空
        if(isEmpty()){
            //抛出异常
            throw new RuntimeException("栈空，没有数据");
        }else {
            int value=stack[top];
            top--;
            return value;
        }
    }

    //入栈
    public void push(int value){
        //先判断栈是否满了
        if(isFull()){
            System.out.println("栈满了不能再添加数据了");
            return;
        }else {
            top++;
            stack[top]=value;
        }
    }

    //遍历栈，需要从栈顶开始遍历
    public void list(){
        if(isEmpty()){
            System.out.println("栈是空的，没有数据");
            return;
        }
        for (int i=top;i>=0;i--){
            System.out.printf("stack[%d]=%d\n",i,stack[i]);
        }
    }

}

    方法2：

package Stack.virtulStack;

import java.util.ArrayList;

 class ArrayStack<E> {
    private ArrayList<E> array;//定义一个泛型变量数组，用来存储stack的元素
    private int StackSize;

    public ArrayStack() {
        StackSize=0;           //初始化初始栈的大小
        array=new ArrayList<E>();
    }

    //判断栈是否为空
    Boolean isEmpty(){
        return StackSize==0;
    }

    //返回栈的大小
    int size(){
        return StackSize;
    }
    //返回栈顶元素
    E top(){
        if (isEmpty()){
            return null;
        }
        return array.get(StackSize-1);
    }
    //弹栈
    E pop(){
        if (StackSize>0){
            return array.get(--StackSize);
        }else {
            System.out.println("栈中没有元素");
            return null;
        }
    }

    //压栈
    void push(E item){
        array.add(item);
        StackSize++;
    }
}

class Test{
    public static void main(String[] args) {
        ArrayStack arrayStack=new ArrayStack();
        arrayStack.push(1);
        arrayStack.push(3);
        arrayStack.push(4);
        int size1 = arrayStack.size();
        System.out.println("栈中的元素的个数"+size1);
        System.out.println("栈是否为空"+arrayStack.isEmpty());
        System.out.println("弹栈"+arrayStack.pop());
        System.out.println("弹栈"+arrayStack.pop());
        System.out.println("栈顶的元素"+arrayStack.top());
    }
}

     

 

用链表模拟栈结构

 

package Stack.virtulStack;

public class Liststacktest {
    public static void main(String[] args) {
        ListStack listStack=new ListStack();
        listStack.push(2);
        listStack.push(4);
        listStack.push(5);
        listStack.push(7);
        System.out.println("栈中元素的个数"+listStack.size());
        System.out.println("栈是否为空栈"+listStack.Empty());
        System.out.println("栈顶元素"+listStack.top());
        System.out.println("弹栈"+listStack.pop());
        System.out.println("弹栈"+listStack.pop());
        System.out.println("栈顶元素"+listStack.top());
        System.out.println("栈中元素的个数"+listStack.size());
    }


}
class ListStack<T>{
    private LNode<T> head;//私有头结点

    //构造函数
    public ListStack() {
        head =new LNode<T>();
        head.data=null;
        head.next=null;
    }
    //判断是否是空栈
    Boolean Empty(){
        return head==null;
    }
    //栈中的元素多少
    int size(){
        int size=0;
        LNode<T> p=new LNode<>();
        p=head.next;
        while (p!=null){
            p=p.next;
            size++;
        }
        return size;
    }
    //压栈
    void push(T item){
        LNode<T> p=new LNode<>();
        p.data=item;
        p.next=head.next;
        head.next=p;
    }
    //弹栈
    T pop(){
        LNode<T> p= head.next;
        while (p!=null){
            head.next=p.next;
            return p.data;
        }
        System.out.println("栈空");
        return null;
    }
    //取栈顶元素
    T top(){
        if (head.next!=null){
            return head.next.data;
        }
        System.out.println("空");
        return null;
    }
}

class LNode<T>{
    T data;
    LNode<T> next;
}