数据结构入门:栈与队列详解

1. 栈(Stack)

栈:一种特殊的线性表,其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶,另一端称为栈底。栈中的数据元素遵守后进先出LIFO(Last In First Out)的原则。

压栈:栈的插入操作叫做进栈/压栈/入栈,入数据在栈顶。

出栈:栈的删除操作叫做出栈。出数据在栈顶。

栈的使用

方法 功能
Stack() 构造一个空的栈
E push(E e) 将e入栈,并返回e
E pop() 将栈顶元素出栈并返回
E peek() 获取栈顶元素
int size() 获取栈中有效元素个数
boolean empty() 检测栈是否为空
java 复制代码
public static void main(String[] args) {
  Stack<Integer> s = new Stack();
  s.push(1);
  s.push(2);
  s.push(3);
  s.push(4);
  System.out.println(s.size()); // 获取栈中有效元素个数---> 4
  System.out.println(s.peek()); // 获取栈顶元素---> 4
  s.pop(); // 4出栈,栈中剩余1 2 3,栈顶元素为3
  System.out.println(s.pop()); // 3出栈,栈中剩余1 2 栈顶元素为3
  if(s.empty()){
    System.out.println("栈空");
  }else{
    System.out.println(s.size());
  }
}

栈的模拟实现

java 复制代码
public class MyStack {
  int[] array;
  int size;
  
  public MyStack(){
    array = new int[3];
  }
  
  public int push(int e){
    ensureCapacity();
    array[size++] = e;
    return e;
  }
  //拿出栈顶元素
  public int pop(){
    int e = peek();
    size--;
    return e;
  }
  //获取栈顶元素
  public int peek(){
    if(empty()){
      throw new RuntimeException("栈为空,无法获取栈顶元素");
    } 
    return array[size-1];
  }
  //栈中放了多少元素
  public int size(){
    return size;
  }
  //检测栈是否为空
  public boolean empty(){
     return 0 == size;
  }
  //判断栈的空间是否满,满了扩容
  private void ensureCapacity(){
    if(size == array.length){
      array = Arrays.copyOf(array, size*2);
    }
  }
}

2. 队列(Queue)

概念

队列:只允许在一端进行插入数据操作,在另一端进行删除数据操作的特殊线性表,队列具有先进先出FIFO(FirstIn First Out) 入队列:进行插入操作的一端称为队尾(Tail/Rear) 出队列:进行删除操作的一端称为队头(Head/Front)

队列的使用

在Java中,Queue是个接口,底层是通过链表实现的。

方法 功能
offer(E e) 入队列
E poll() 出队列
peek() 获取队头元素
int size() 获取队列中有效元素个数
boolean isEmpty() 检测队列是否为空

注意:Queue是个接口,在实例化时必须实例化LinkedList的对象,因为LinkedList实现了Queue接口。

java 复制代码
public static void main(String[] args) {
Queue<Integer> q = new LinkedList<>();
  q.offer(1);
  q.offer(2);
  q.offer(3);
  q.offer(4);
  q.offer(5); // 从队尾入队列
  System.out.println(q.size());
  System.out.println(q.peek()); // 获取队头元素
  q.poll();
  System.out.println(q.poll()); // 从队头出队列,并将删除的元素返回
  if(q.isEmpty()){
    System.out.println("队列空");
  }else{
    System.out.println(q.size());
  }
}

队列模拟实现

java 复制代码
public class Queue {

  // 双向链表节点
  public static class ListNode{
    ListNode next;
    ListNode prev;
    int value;
    ListNode(int value){
      this.value = value;
    }
  } 
  
  ListNode first; // 队头
  ListNode last; // 队尾
  int size = 0;
  
  // 入队列---向双向链表位置插入新节点
  public void offer(int e){
    ListNode newNode = new ListNode(e);
    if(first == null){
        first = newNode;
      // last = newNode;
    }else{
        last.next = newNode;
        newNode.prev = last;
        // last = newNode;
    } 
    last = newNode;
    size++;
  } 
  
  // 出队列---将双向链表第一个节点删除掉
  public int poll(){
    // 1. 队列为空
    // 2. 队列中只有一个元素----链表中只有一个节点---直接删除
    // 3. 队列中有多个元素---链表中有多个节点----将第一个节点删除
    int value = 0;
    if(first == null){
      return null;
    }else if(first == last){
      last = null;
      first = null;
    }else{
      value = first.value;
      first = first.next;
      first.prev.next = null;
      first.prev = null;
    } 
    --size;
    return value;
  } 
  
  // 获取队头元素---获取链表中第一个节点的值域
  public int peek(){
  if(first == null){
    return null;
  } 
    return first.value;
  }
  
  public int size() {
    return size;
  }
  
  public boolean isEmpty(){
    return first == null;
  }
}

循环队列

环形队列通常使用数组实现。

数组下标循环的小技巧

  1. 下标最后再往后(offset 小于 array.length): index = (index + offset) % array.length

  2. 下标最前再往前(offset 小于 array.length): index = (index + array.length - offset) % array.length

如何区分空与满

  1. 通过添加 size 属性记录
  2. 保留一个位置
  3. 使用标记

双端队列 (Deque)

双端队列(deque)是指允许两端都可以进行入队和出队操作的队列,deque 是 "double ended queue" 的简称。那就说明元素可以从队头出队和入队,也可以从队尾出队和入队。

Deque是一个接口,使用时必须创建LinkedList的对象。

在实际工程中,使用Deque接口是比较多的,栈和队列均可以使用该接口

java 复制代码
Deque<Integer> stack = new ArrayDeque<>();//双端队列的线性实现
Deque<Integer> queue = new LinkedList<>();//双端队列的链式实现
相关推荐
特立独行的猫A3 小时前
别再用 nohup 了:让应用在后台常驻的正确姿势与 systemd 服务详解
java·后端·python
一起_java3 小时前
技术文章-基于Dify-Agent的智能问答系统设计与实现
java·spring boot·后端·agent·dify
Flynn Liang5 小时前
I/O 密集型高并发实战:Java 服务 10 维优化,从线程打满到 10 万 QPS
java·spring boot·性能优化·高并发·系统设计·虚拟线程·io密集型
吃我一窝jio6 小时前
Python与Go线程模型深度对比
java·开发语言·python
这个昵称不容易6 小时前
SpringBoot 购物推荐网站的设计与实现:120 个 Java 文件、147 个接口、13 张表,附真实运行截图
java·springboot·毕设
文丑颜不良啊6 小时前
LeetCode3041~3060题目解析
java·leetcode
eggwyw6 小时前
C++ union 的一种妙用法
开发语言·c++
文丑颜不良啊7 小时前
LeetCode3101~3120题目解析
java·leetcode
Resean02238 小时前
SpringMVC 6+源码分析(十一)视图渲染与异步请求(收尾篇)
java·spring·springmvc
starzy19908 小时前
深入理解Scala隐式函数:自动类型转换
开发语言·后端·scala