java链栈基本操作

链栈是一种使用链表实现的栈。它的基本操作包括初始化链栈、判断链栈是否为空、获取链栈的长度、获取链栈的栈顶元素、向链栈中压入元素、从链栈中弹出元素以及显示链栈的内容。

链栈的基本操作可按照以下步骤实现：

1. 链栈的初始化：创建一个头结点，并将头结点的指针指向null，表示链栈为空。

2. 判断链栈是否为空：通过判断链栈的头结点是否为空来判断链栈是否为空。如果头结点为空，说明链栈中没有元素，返回true；否则，返回false。

3. 获取链栈的长度：从链栈的头结点开始，遍历整个链栈，每遍历一个结点，计数器加1，直到遍历到链栈的末尾。最后返回计数器的值即为链栈的长度。

4. 获取链栈的栈顶元素：直接返回链栈的头结点的数据项。

5. 向链栈中压入元素：创建一个新的结点，将新结点的数据项设置为要压入的元素，然后将新结点的指针指向链栈的头结点，最后将链栈的头结点指向新结点。

6. 从链栈中弹出元素：首先判断链栈是否为空，如果为空，则无法弹出元素；否则，将链栈的头结点指向下一个结点，然后返回弹出的元素。

7. 显示链栈的内容：从链栈的头结点开始，遍历整个链栈，并依次打印每个结点的数据项。

相关问题

编写程序实现链栈的建立、入栈、出栈、输出的基本操作

链栈是一种基于链表的数据结构，其基本操作通常包括以下几个步骤：

1. **建立链栈** (创建栈)：
首先，你需要定义一个节点类，包含数据域和指向下一个节点的引用（通常是`next`）。然后，你可以定义一个链栈类，初始化时保持一个头节点为空（`top = null`）。

class Node {
    int data;
    Node next;
}

class Stack {
    private Node top;
}

2. **入栈 (Push)**：
当需要将元素添加到栈顶时，创建一个新的节点，存储数据，并设置新节点的`next`指向当前的栈顶。然后更新栈顶指针。

void push(int value) {
    Node newNode = new Node();
    newNode.data = value;
    newNode.next = top;
    top = newNode;
}

3. **出栈 (Pop)**：
如果栈非空，移除并返回栈顶元素，同时将栈顶指针指向下一个节点。如果栈空，则抛出异常。

int pop() {
    if (top == null) {
        throw new EmptyStackException();
    }
    int value = top.data;
    top = top.next;
    return value;
}

4. **查看栈顶元素 (Peek 或者 Top)**：
只能查看栈顶元素，但不删除它。同样，如果栈空则抛出异常。

int peek() {
    if (top == null) {
        throw new EmptyStackException();
    }
    return top.data;
}

5. **判断栈是否为空 (IsEmpty)**：
检查栈顶是否为`null`即可。

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

链表、链栈、链队列、二叉树、图java代码实现

链表是一种线性的数据结构，每个节点包含数据和指向下一个节点的引用。链栈（Stack）是一种特殊的线性表，数据只能在一端进行插入和删除操作，类似于书本的一叠纸张，通常是最后一个进栈的元素第一个出栈。链队列（Queue）则是另一端，数据先进先出，就像排队一样。

以下是简单的Java代码实现：

// 链表节点类
class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
}

// 链表实现
public class LinkedList {
    private ListNode head;

    // 添加节点到链表头部
    public void push(int value) {
        ListNode newNode = new ListNode(value);
        newNode.next = head;
        head = newNode;
    }

    // 添加节点到链表尾部
    public void add(int value) {
        ListNode newNode = new ListNode(value);
        if (head == null) {
            head = newNode;
        } else {
            ListNode current = head;
            while (current.next != null) {
                current = current.next;
            }
            current.next = newNode;
        }
    }
}

// 链栈实现（使用单向链表）
public class StackUsingLinkedList {
    private LinkedList list;

    // 入栈
    public void push(int value) {
        list.push(value);
    }

    // 出栈
    public int pop() {
        return list.head.val;
        list.head = list.head.next; // 更新头节点
    }
}

// 链队列实现（双端队列）
public class QueueUsingLinkedList {
    private LinkedList front, rear;

    // 入队
    public void enqueue(int value) {
        rear.add(value);
    }

    // 出队
    public int dequeue() {
        if (front == null) return -1; // 如果队列为空
        int value = front.head.val;
        front.head = front.head.next;
        return value;
    }
}

// 二叉树基本概念，Java中通常会定义Node类和递归方法用于遍历等操作，这里简化为类名：
public class BinaryTree {
    private TreeNode root;

    // 插入节点等基本操作...
}

// 图（Graph）是一个更复杂的数据结构，可以有多种实现，比如邻接矩阵或邻接表。这里给出一个简化的邻接列表示例：
public class Graph {
    private List<List<Node>> adjList;

    // 添加边、遍历等操作...
}