【面试官】谈谈你对顺序栈和链式栈的认识

qq_384136844

已于 2024-10-08 15:51:29 修改

阅读量509

点赞数 17

分类专栏：数据结构文章标签： python 开发语言

于 2024-10-08 15:46:28 首次发布

本文链接：https://blog.csdn.net/C384136844/article/details/142757561

版权

数据结构专栏收录该内容

3 篇文章 0 订阅

订阅专栏

思维导图

栈（Stack）是一种数据结构，遵循后进先出（LIFO）原则。在java中Stack在java.util.Stack中。

一.常用方法的使用

1. push(E item)：把元素压入栈顶。

代码示例：

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        stack.push(1);
        stack.push(2);
        stack.push(3);
    }
}

2. pop()：弹出并返回栈顶元素。

代码示例：

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        int topElement = stack.pop();
        System.out.println("弹出的元素：" + topElement);
    }
}

注意：如果栈为空，会抛出EmptyStackException异常。

3. peek()：查看栈顶元素，但不弹出。

代码示例：


import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        stack.push(1);
        int top = stack.peek();
        System.out.println("栈顶元素：" + top);
    }
}

注意：如果栈为空，会抛出EmptyStackException异常。

4. empty()：判断栈是否为空，返回true或false。

代码示例:

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        boolean isEmpty = stack.empty();
        System.out.println("栈是否为空：" + isEmpty);
    }
}

二.细节问题

1.空栈操作

在调用pop和peek方法前，一定要先检查栈是否为空。如果对空栈执行pop或peek操作，会抛出EmptyStackException异常。

正确写法：


Stack<Integer> stack = new Stack<>();
if (!stack.isEmpty()) {
    Integer topElement = stack.peek();

    // 进一步处理栈顶元素
}

2.同步问题

java.util.Stack是同步的，这在多线程环境下可能会带来性能开销。如果不需要线程安全，可以考虑使用非同步的数据结构或者采取其他同步策略以提高性能。但如果错误地假设它是非同步的，在多线程环境下可能会导致数据不一致等问题。

代码示例：

// 错误示例：在多线程环境下未正确同步对栈的操作

Stack<Integer> stack = new Stack<>();
Thread t1 = new Thread(() -> {
    stack.push(1);
});
Thread t2 = new Thread(() -> {
    stack.pop();
});
t1.start();
t2.start();

3.为什么Stack是同步的？

三.栈的模拟实现

1.顺序栈（源码实现也是顺序栈）

代码示例：

//实现类
public class ArrayStack<T> {
    private T[] stack;
    private int top;
    private int capacity;

    public ArrayStack(int capacity) {
        this.capacity = capacity;
        stack = (T[]) new Object[capacity];
        top = -1;
    }

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

    public boolean isFull() {
        return top == capacity - 1;
    }

    public void push(T item) {
        if (isFull()) {
            throw new RuntimeException("Stack is full");
        }
        stack[++top] = item;
    }

    public T pop() {
        if (isEmpty()) {
            return null;
        }
        return stack[top--];
    }

    public T peek() {
        if (isEmpty()) {
            return null;
        }
        return stack[top];
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        ArrayStack<Integer> stack = new ArrayStack<>(10);
        stack.push(1);
        stack.push(2);
        System.out.println(stack.isFull());
        System.out.println(stack.isEmpty());
        System.out.println(stack.pop());
        System.out.println(stack.peek());
    }
}

运行结果：

2.链式栈

代码示例：

//实现类
class StackNode<T> {
    T data;
    StackNode<T> next;

    public StackNode(T data) {
        this.data = data;
        this.next = null;
    }
}

class LinkedStack<T> {
    private StackNode<T> top;

    public LinkedStack() {
        top = null;
    }

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

    public void push(T item) {
        StackNode<T> newNode = new StackNode<>(item);
        newNode.next = top;
        top = newNode;
    }

    public T pop() {
        if (isEmpty()) {
            return null;
        }
        T item = top.data;
        top = top.next;
        return item;
    }

    public T peek() {
        if (isEmpty()) {
            return null;
        }
        return top.data;
    }
}

//测试类
public class Main {
    public static void main(String[] args) {
        LinkedStack<Integer> stack = new LinkedStack<>();
        stack.push(1);
        stack.push(2);
        stack.push(3);

        System.out.println("栈顶元素：" + stack.peek());
        System.out.println("弹出元素：" + stack.pop());
        System.out.println("弹出元素：" + stack.pop());

        stack.push(4);
        while (!stack.isEmpty()) {
            System.out.println("弹出元素：" + stack.pop());
        }
    }
}

使用链式栈需要注意内存管理

如果使用自定义的链式栈，要注意内存泄漏问题。当从栈中弹出节点时，如果没有正确地处理节点的引用，可能会导致被弹出的节点无法被垃圾回收器回收，从而占用不必要的内存。

class LinkedStack<T> {
    // 需要做的事
    public T pop() {
        if (isEmpty()) {
            return null;
        }
        T item = top.data;
        StackNode<T> oldTop = top;
        top = top.next;
        // 解除对被弹出节点的引用，帮助垃圾回收
        oldTop.next = null;
        return item;
    }
    //需要做的事
}

四.顺序栈链式栈的优缺点

1.顺序栈

优点：

1. 简单直观：实现相对容易，操作也比较直接，易于理解和使用。

2. 随机访问：如果是基于数组实现的顺序栈，可以通过索引快速访问特定位置的元素，例如获取栈顶元素的操作非常高效。

3. 内存连续：存储在连续的内存空间中，有利于 CPU 缓存的利用，可能会提高访问速度。

缺点：

1. 固定容量：通常需要预先指定栈的大小，如果栈的大小设置不当，可能会导致空间浪费或者栈溢出。当栈的容量不够时，需要进行扩容操作，这可能涉及到创建新的数组并复制元素，比较耗时。

2. 灵活性差：难以动态地调整大小，对于一些不确定大小的应用场景可能不太适用。

二、链式栈

优点：

1. 动态大小：可以根据需要动态地增加或减少栈的大小，无需预先指定固定的容量，具有很高的灵活性。

2. 内存分配灵活：节点可以在内存中的任意位置分配，不会受到连续内存空间的限制。

缺点：

1. 额外开销：每个节点需要额外的空间来存储指向下一个节点的引用，相比顺序栈会占用更多的内存。

2. 访问效率：由于节点在内存中不一定连续存储，无法像顺序栈那样通过索引快速访问元素，访问特定位置的元素需要遍历链表，效率较低。