java栈的实现

最新推荐文章于 2024-09-06 06:33:15 发布

晴天ﾉBye~

最新推荐文章于 2024-09-06 06:33:15 发布

阅读量2.9k

点赞数 5

文章标签： java 数据结构

本文链接：https://blog.csdn.net/honeywpp/article/details/122279726

版权

栈的介绍

栈是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据。”特点：先进后出。

如图

入栈：

第一个元素在栈底，最后以个入栈的在栈顶

出栈

出栈是移出栈顶元素

两种方法实现栈

1.数组栈

数组栈，听名字就知道这是用数组简单实现的栈

数组的构造：

注意：Maxsize指的是最大存储元素个数

  Object[] list;
    int cur;
    public Stack(int Maxsize) {
        list = new Object[Maxsize];
        cur = 0;
    }

入栈操作

定义了一个cur来做数组下标，当栈中没元素时，进行元素添加，cur++，即长度加1

 /**
     * 入栈
     * @param x 入栈元素
     */
    public void push(Object x){
        if (cur>list.length){
            System.out.println("栈溢出");
            return;
        }
        list[cur]=x;
        cur++;
    }

出栈:

出栈操作因为和入栈类似，当栈中有元素时进行一个cur--的操作，即当前栈的长度减一从而达到

出栈的目的

  /**
     * 出栈
     * @return
     */
    public Object pop(){
        if(isEmpty()){
            System.out.println("栈为空");
            return null;
        }
        Object x=list[cur-1];
        cur--;
        return x;
    }

打印数组栈

前面可以看出来，数组并没有达到先进后出的特点，但是，如果你将数组添加的一位当成开头，第一位当作结尾，那么这就是明显的先进后出的特点实际上，打印数组栈用的就是数组的逆序

 /**
     * 打印栈
     */
    public void display(){
        if(isEmpty()){
            System.out.println("栈为空");
           return;
        }
        for (int i=cur-1;i>=0;i--){
            System.out.print(list[i]+" ");
        }

    }

2.链栈

链栈的结点构造

和链表的结点构造是一样的

public class Node {
    private Object data;
    public Node next;//指向下一个节点
    //构造器
    public Node(Object data){
        this.data=data;
    }
    public Object getData() {
        return data;
    }

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

链栈入栈操作

链栈入栈操作，实际上就是运用头插法进行链表连接操作

  /**
     * 栈的添加
     * @param x 添加的元素
     */
    public void push(Object x){
        Node newNode=new Node(x);
        if(headNode.next==null){
            headNode.next=newNode;
        }else {
            Node temp=headNode.next;
            headNode.next=newNode;
            newNode.next=temp;
        }
    }

链表的出栈操作

使用头插法，headNode.next中所储存的元素即为栈顶元素，所以直接将headNode.next指向栈顶的下一个元素，即headNode.next=headNode.next.next;

  /**
     * 出栈
     * @return
     */
    public Object pop(){
        if(isEmpty()){
            System.out.println("栈为空");
            return null;
        }
        Node x=headNode.next;
        headNode.next=headNode.next.next;
        return x.getData();
    }

链栈的打印

和链表的打印是一样的

 /**
     * 打印栈
     */
    public void display(){
        Node p=headNode;
        while (p.next != null) {
            System.out.print(p.next.getData() + " ");
            p = p.next;
        }
    }

总结：

栈的特点是先进后出，这是重点，理清对栈的认识很重要

附录

数组栈代码：

public class Stack {
    Object[] list;
    int cur;
    public Stack(int Maxsize) {
        list = new Object[Maxsize];
        cur = 0;
    }

    /**
     * 清空栈
     */
    public void clear(){
        cur=0;
    }
    /**
     *
     * @return
     */
    public boolean isEmpty(){
        return cur==0;
    }

    /**
     * 返回栈顶元素
     * @return
     */
    public Object peek(){
        return list[cur-1];
    }

    /**
     * 返回当前栈长度
     * @return
     */
    public int length(){
        return cur;
    }

    /**
     * 入栈
     * @param x 入栈元素
     */
    public void push(Object x){
        if (cur>list.length){
            System.out.println("栈溢出");
            return;
        }
        list[cur]=x;
        cur++;
    }

    /**
     * 出栈
     * @return
     */
    public Object pop(){
        if(isEmpty()){
            System.out.println("栈为空");
            return null;
        }
        Object x=list[cur-1];
        cur--;
        return x;
    }

    /**
     * 打印栈
     */
    public void display(){
        if(isEmpty()){
            System.out.println("栈为空");
           return;
        }
        for (int i=cur-1;i>=0;i--){
            System.out.print(list[i]+" ");
        }

    }
}

链栈代码：

public class LinkStack {
   private Node headNode=new Node(null);

    public void clear(){
        headNode.next=null;
    }
    /**
     * 判空
     * @return
     */
    public boolean isEmpty(){
        return headNode.next.getData()==null;
    }

    /**
     * 当前栈的长度
     * @return
     */
    public int length(){
        int cur=0;
        if (isEmpty()){
            System.out.println("栈为空");
            return cur;
        }
        Node p=headNode;
        while (p.next != null) {
            p = p.next;
            cur++;
        }
        return cur;
    }

    /**
     * 栈的添加
     * @param x 添加的元素
     */
    public void push(Object x){
        Node newNode=new Node(x);
        if(headNode.next==null){
            headNode.next=newNode;
        }else {
            Node temp=headNode.next;
            headNode.next=newNode;
            newNode.next=temp;
        }
    }

    /**
     * 返回栈顶元素
     * @return
     */
    public Object peek(){
        return headNode.next.getData();
    }

    /**
     * 出栈
     * @return
     */
    public Object pop(){
        if(isEmpty()){
            System.out.println("栈为空");
            return null;
        }
        Node x=headNode.next;
        headNode.next=headNode.next.next;
        return x.getData();
    }

    /**
     * 打印栈
     */
    public void display(){
        Node p=headNode;
        while (p.next != null) {
            System.out.print(p.next.getData() + " ");
            p = p.next;
        }
    }
}