使用双向链表实现栈的相关操作【1.3】

创建节点：

class Node {
    private Node next;
    private Node pre;
    private int no;

    public Node getNext() {
        return next;
    }

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

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

    public Node getPre() {
        return pre;
    }

    public void setPre(Node pre) {
        this.pre = pre;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    @Override
    public String toString() {
        return "Node{" + "no =" + no +
                '}';
    }
}

创建双向链表类：

class NodeListed {
    private Node head = new Node(0);
    private int maxSize;

    public NodeListed(int maxSize){
        this.maxSize = maxSize;
    }

    //判断栈中有多少个元素
    public int size(){
        if(head.getNext()==null){
            return 0;
        }
        Node temp = head.getNext();
        int length = 1;
        while (true){
            if(temp.getNext() == null){
                break;
            }
            temp = temp.getNext();
            length++;
        }
        return length;
    }

    //判断栈是否为满
    public boolean isFull(){
        return size() == maxSize;
    }

    //判断栈是否为空
    public boolean isEmpty(){
        return size() == 0;
    }

    //入栈操作
    public void push(Node newNode) {
        Node temp = head; //将temp指向头节点，因为元素可能为空
        if (isFull()){ //如果链表满
            System.out.println("栈已经满了，不能继续添加元素~");
        } else {
            while (temp.getNext() != null) {//将链表指向最后一个元素
                temp = temp.getNext();
            }
            temp.setNext(newNode);//设置next指针
            newNode.setPre(temp);//设置pre指针
            //方式二
//            temp.setNext(newNode);
//            temp.getNext().setPre(temp);
            System.out.printf("元素 %d 入栈\n",newNode.getNo());
        }
    }

    //出栈操作
    public Node pop() {
        Node temp = head; //指向头节点
        Node next = head.getNext(); //指向头节点的后一个节点
        System.out.println("元素出栈操作....");
        if(isEmpty()){
            throw new RuntimeException("栈空，无可用元素出栈~");
        }
        while (true) {
            if (next.getNext() == null) {
                break;
            }
            //将两个指针向后移动
            temp = temp.getNext();
            next = next.getNext();
        }
        //将next指向需要出栈的元素，将指针销毁，以便回收
        temp.setNext(null);
        next.setPre(null);
        //销毁方式2
//        next.getNext().setNext(null);
        return next;
    }


    //遍历栈元素
    public void showList() {
        Node temp = head;// 将临时指针指向头节点
        System.out.println("======打印栈元素======");
        if(temp.getNext() == null){
            System.out.println("栈空，无元素进行遍历~");
        }
        //逆序打印链表
//        while (true) {
//            if (temp.getNext() == null) {
//                break;
//            }
//            temp = temp.getNext();
//        }
        while (true) {
            if (temp.getNext() != null) {
                System.out.printf("元素 %d \n", temp.getNext().getNo());
            }
            if(temp.getNext() == null){
                break;
            }
            temp = temp.getNext();
        }
    }

    //链表逆向输出
    public void reverseShow(){
        Node temp = head; //临时指针，指向头节点
        System.out.println("======栈的逆向输出======");
        if(head.getNext() == null || head == null){
            System.out.println("无元素进行遍历~");
        }else{
            while (temp.getNext() != null){
                temp = temp.getNext();
            }
            while (temp.getPre()!= null){
                System.out.printf("元素 %d \n",temp.getNo());
                temp = temp.getPre();
            }
        }

    }
}

测试类：

public class ArrayStackDemo2 {
    public static void main(String[] args) {

        //测试
        NodeListed nodeListed = new NodeListed(4);

        //测试栈元素
        Node node1 = new Node(10);
        Node node2 = new Node(20);
        Node node3 = new Node(30);
        Node node4 = new Node(40);
        Node node5 = new Node(50);

        //入栈操作
        nodeListed.push(node1);
        nodeListed.push(node2);
        nodeListed.push(node3);
        nodeListed.push(node4);
        nodeListed.push(node5);

        //打印栈元素
        nodeListed.showList();

        //出栈操作：
        System.out.println("出栈元素为："+nodeListed.pop());
        System.out.println("出栈元素为："+nodeListed.pop());
//        System.out.println("出栈元素为："+nodeListed.pop());
//        System.out.println("出栈元素为："+nodeListed.pop());

        //打印栈元素
        nodeListed.showList();

        //逆向打印栈元素
        nodeListed.reverseShow();
    }
}

控制台输出：

相关文章：使用单项链表实现栈的相关操作 

                  使用数组实现栈的相关操作