java链式栈基本操作

java链式栈的基本操作包括入栈(push)和出栈(pop)两个操作。入栈操作是将元素添加到栈顶，出栈操作是将栈顶元素移除并返回。

在给出的代码中，push操作通过创建新的节点并将其作为头节点来实现入栈。如果头节点为空，将创建一个新的节点作为头节点；否则，将创建一个新的节点，并将头节点作为新节点的下一个节点，然后将新节点设置为头节点。

pop操作通过将头节点的值保存到一个临时变量中，然后将头节点的下一个节点设置为新的头节点来实现出栈。

除了基本操作外，还有一个toString方法用于将链式栈转换为字符串形式，方便打印输出。

相关问题

Java链式栈逆置

实现Java链式栈逆置可以通过以下步骤：

1. 定义一个链式栈类，包括节点类和栈类。
2. 创建一个新的空栈，用于存放逆置后的元素。
3. 依次从原栈中弹出元素，并将其压入新栈中。
4. 最后返回新栈作为逆置后的结果。

下面是Java链式栈逆置的示例代码：

public class Node {
    private int data;
    private Node next;

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

    public int getData() {
        return data;
    }

    public Node getNext() {
        return next;
    }

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

public class LinkedStack {
    private Node top;

    public LinkedStack() {
        top = null;
    }

    public boolean isEmpty() {
        return top == null;
    }

    public void push(int data) {
        Node newNode = new Node(data);
        newNode.setNext(top);
        top = newNode;
    }

    public int pop() {
        int data = top.getData();
        top = top.getNext();
        return data;
    }

    public int peek() {
        return top.getData();
    }

    public LinkedStack reverse() {
        LinkedStack reversedStack = new LinkedStack();
        while (!isEmpty()) {
            reversedStack.push(pop());
        }
        return reversedStack;
    }
}

public class Main {
    public static void main(String[] args) {
        LinkedStack stack = new LinkedStack();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);

        LinkedStack reversedStack = stack.reverse();
        while (!reversedStack.isEmpty()) {
            System.out.println(reversedStack.pop());
        }
    }
}

上述代码中，我们定义了一个链式栈类 LinkedStack，包括节点类 Node 和栈类 LinkedStack。其中 reverse() 方法实现了栈的逆置，返回一个新的逆置后的栈。在 main() 方法中，我们创建了一个栈，压入了四个元素，并将其逆置后输出。

栈的基本操作java

栈是一种常见的数据结构，它的特点是后进先出（LIFO）。在Java中，可以使用Stack类来实现栈的基本操作，包括push（入栈）、pop（出栈）、peek（查看栈顶元素）和getSize（获取栈的大小）等操作。下面是一个示例代码：

import java.util.Stack;

public class MyStack {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        System.out.println(stack.size()); // 输出：4
        System.out.println("===========");
        System.out.println(stack.peek()); // 输出：4
        System.out.println(stack.pop()); // 输出：4
        System.out.println(stack.peek()); // 输出：3
    }
}

在这个示例代码中，我们首先创建了一个Stack对象，然后使用push方法将4个整数依次入栈。接着，我们使用size方法获取栈的大小，并使用peek方法查看栈顶元素，使用pop方法将栈顶元素出栈，并再次使用peek方法查看栈顶元素。