学习 TypeScript 栈和队列数据结构

陈浩源同学2025-02-22 16:42

栈和队列都是「操作受限」的数据结构。和基本的数组和链表相比，它们提供的 API 是不完整的。

队列只允许在队尾插入元素，在队头删除元素，栈只允许在栈顶插入元素，从栈顶删除元素。

本篇文章重点介绍栈和队列两种数据结构的 TypeScript 代码实现。

栈代码实现

首先，我们要知道栈数据结构的基本 API 如下：

typescript 复制代码 
export class Stack<T> {
  // 栈增操作，从栈顶插入元素
  push(element: T): void {

  }

  // 栈删操作，移除栈顶的元素并返回
  pop(): T | undefined {

  }

  // 删查操作，获取栈顶的元素，但不删除
  peek(): T | undefined {

  }

  // 辅助方法，判断栈是否为空
  isEmpty(): boolean {

  }

  // 辅助方法，返回栈的大小
  size(): number {

  }
}

然后我们要考虑到，在 TypeScript 中，栈可以基于三种数据结构来实现：

  1. 基于数组实现
  2. 基于对象实现
  3. 基于链表实现

下面我们依次来看这三种实现方式。

基于数组代码实现

我们直接看代码吧：

typescript 复制代码 
export class Stack<T> {
  // 存储栈元素的数组
  private items: T[] = [];

  constructor() {
    this.items = [];
  }

  // 栈增操作，从栈顶插入元素
  push(element: T): void {
    this.items.push(element);
  }

  // 栈删操作，移除栈顶的元素并返回
  pop(): T | undefined {
    if (this.isEmpty()) {
      return undefined;
    }
    return this.items.pop();
  }

  // 删查操作，获取栈顶的元素，但不删除
  peek(): T | undefined {
    if (this.items.length === 0) {
      return undefined;
    }
    return this.items[this.count - 1];
  }

  // 辅助方法，判断栈是否为空
  isEmpty(): boolean {
    return this.size() === 0;
  }

  // 辅助方法，返回栈的大小
  size(): number {
    return this.items.length;
  }
}

基于对象代码实现

我们直接看代码吧：

typescript 复制代码 
export class Stack<T> {
  // 栈的元素数量
  private count: number;
  // 存储栈元素的对象
  private items: Record<number, T> = {};

  // 栈增操作，从栈顶插入元素
  push(element: T): void {
    this.items[this.count] = element;
    this.count++;
  }

  // 栈删操作，移除栈顶的元素并返回
  pop(): T | undefined {
    if (this.isEmpty()) {
      return undefined;
    }
    const element = this.items[this.count - 1];
    delete this.items[this.count - 1];
    this.count--;
    return element;
  }

  // 删查操作，获取栈顶的元素，但不删除
  peek(): T | undefined {
    if (this.isEmpty()) {
      return undefined;
    }
    return this.items[this.count - 1];
  }

  // 辅助方法，判断栈是否为空
  isEmpty(): boolean {
    return this.size() === 0;
  }

  // 辅助方法，返回栈的大小
  size(): number {
    return this.count;
  }
}

基于链表代码实现

我们考虑用双向链表来实现栈，看下面的代码：

typescript 复制代码 
export class Stack<T> {
  // 存储栈元素的双向链表
  private items: DoublyLinkedList<T>;

  constructor() {
    this.items = new DoublyLinkedList();
  }

  // 栈增操作，从栈顶插入元素
  push(element: T): void {
    this.items.push(element);
  }

  // 栈删操作，移除栈顶的元素并返回
  pop(): T | undefined {
    if (this.items.isEmpty()) {
      return undefined;
    }
    return this.items.pop();
  }

  // 删查操作，获取栈顶的元素，但不删除
  peek(): T | undefined {
    if (this.items.isEmpty()) {
      return undefined;
    }
    return this.items.getTail().element;
  }

  // 辅助方法，判断栈是否为空
  isEmpty(): boolean {
    return this.items.isEmpty();
  }

  // 辅助方法，返回栈的大小
  size(): number {
    return this.items.size();
  }
}

队列

首先，我们要知道队列数据结构的基本 API 如下：

typescript 复制代码 
export class Queue<T> {
  // 队列增操作，在队尾添加一个元素
  enquque(element: T): void {

  }

  // 队列删操作，移除队头的元素并返回
  dequeue(): T | undefined {

  }

  // 队列查操作，查看队头元素
  peek(): T | undefined {

  }

  // 辅助方法，判断队列是否为空
  isEmpty(): boolean {

  }

  // 辅助方法，返回队列的长度
  size(): number {

  }
}

然后我们要考虑到，在 TypeScript 中，队列可以基于三种数据结构来实现：

  1. 基于数组实现
  2. 基于对象实现
  3. 基于链表实现

下面我们依次来看这三种实现方式。

基于数组代码实现

我们直接看代码吧：

typescript 复制代码 
export class Queue<T> {
  // 存储队列元素的数组
  private items: T[];

  constructor() {
    this.items = [];
  }

  // 队列增操作，在队尾添加一个元素
  enquque(element: T): void {
    this.items.push(element);
  }

  // 队列删操作，移除队头的元素并返回
  dequeue(): T | undefined {
    if (this.isEmpty()) {
      return undefined;
    }
    return this.items.pop();
  }

  // 队列查操作，查看队头元素
  peek(): T | undefined {
    if (this.isEmpty()) {
      return undefined;
    }
    return this.items[this.size() - 1];
  }

  // 辅助方法，判断队列是否为空
  isEmpty(): boolean {
    return this.size() === 0;
  }

  // 辅助方法，返回队列的长度
  size(): number {
    return this.items.length;
  }
}

基于对象代码实现

我们直接看代码吧：

typescript 复制代码 
export class Queue<T> {
  private count: number;
  private lowestCount: number;
  private items: Record<number, T>;

  contructor() {
    this.count = 0;
    this.lowestCount = 0;
    this.items = {};
  }

  // 队列增操作，在队尾添加一个元素
  enquque(element: T): void {
    this.items[this.count] = element;
    this.count++;
  }

  // 队列删操作，移除队头的元素并返回
  dequeue(): T | undefined {
    if (this.isEmpty()) {
      return undefined;
    }
    const element = this.items[this.lowestCount];
    delete this.items[this.lowestCount];
    this.lowestCount++;
    return element;
  }

  // 队列查操作，查看队头元素
  peek(): T | undefined {
    if (this.isEmpty()) {
      return undefined;
    }
    return this.items[this.lowestCount];
  }

  // 辅助方法，判断队列是否为空
  isEmpty(): boolean {
    return this.size() === 0;
  }

  // 辅助方法，返回队列的长度
  size(): number {
    return this.count - this.lowestCount;
  }
}

基于链表代码实现

我们考虑用双向链表来实现栈，看下面的代码：

typescript 复制代码 
export class Queue<T> {
  private items: DoublyLinkedList<T>;

  constructor() {
    this.items = new DoublyLinkedList();
  }

  // 队列增操作，在队尾添加一个元素
  enquque(element: T): void {
    this.items.push(element);
  }

  // 队列删操作，移除队头的元素并返回
  dequeue(): T | undefined {
    if (this.items.isEmpty()) {
      return undefined;
    }
    const element = this.items.getHead().element;
    this.items.shift();
    return element;
  }

  // 队列查操作，查看队头元素
  peek(): T | undefined {
    if (this.items.isEmpty()) {
      return undefined;
    }
    return this.items.getHead().element;
  }

  // 辅助方法，判断队列是否为空
  isEmpty(): boolean {
    return this.items.isEmpty();
  }

  // 辅助方法，返回队列的长度
  size(): number {
    return this.items.size();
  }
}

双端队列

标准队列只能在队尾插入元素，队头删除元素，而双端队列的队头和队尾都可以插入或删除元素。

我们要知道双端队列数据结构的基本 API 如下：

typescript 复制代码 
export class Deque<T> {
  // 双端队列增操作，在队尾添加一个元素
  addLast(element: T): void {

  }

  // 双端队列增操作，在队头添加一个元素
  addFirst(element: T): void {

  }

  // 双端队列删操作，移除队尾的元素并返回
  removeLast(): T | undefined {

  }

  // 双端队列删操作，移除队头的元素并返回
  removeFirst(): T | undefined {

  }

  // 双端队列查操作，查看队尾的元素
  peekLast(): T | undefined {

  }

  // 双端队列查操作，查看队头的元素
  peekFirst(): T | undefined {

  }

  // 辅助方法，判断双端队列是否为空
  isEmpty(): boolean {

  }

  // 辅助方法，返回双端队列的长度。
  size(): number {

  }
}

基于数组代码实现

我们直接看代码吧：

typescript 复制代码 
export class Deque<T> {
  // 存储队列元素的数组
  private items: T[];

  constructor() {
    this.items = [];
  }

  // 双端队列增操作，在队尾添加一个元素
  addLast(element: T): void {
    this.items.push(element);
  }

  // 双端队列增操作，在队头添加一个元素
  addFirst(element: T): void {
    this.items.unshift(element);
  }

  // 双端队列删操作，移除队尾的元素并返回
  removeLast(): T | undefined {
    if (this.isEmpty()) {
      return undefined;
    }
    return this.items.pop();
  }

  // 双端队列删操作，移除队头的元素并返回
  removeFirst(): T | undefined {
    if (this.isEmpty()) {
      return undefined;
    }
    return this.items.shift();
  }

  // 双端队列查操作，查看队尾的元素
  peekLast(): T | undefined {
    if (this.isEmpty()) {
      return undefined;
    }
    return this.items[this.size() - 1];
  }

  // 双端队列查操作，查看队头的元素
  peekFirst(): T | undefined {
    if (this.isEmpty()) {
      return undefined;
    }
    return this.items[0];
  }

  // 辅助方法，判断双端队列是否为空
  isEmpty(): boolean {
    return this.size() === 0;
  }

  // 辅助方法，返回双端队列的长度。
  size(): number {
    return this.items.length;
  }
}

基于对象代码实现

我们直接看代码吧：

typescript 复制代码 
export class Deque<T> {
  private count: number;
  private lowestCount: number;
  private items: Record<number, T>;

  constructor() {
    this.count = 0;
    this.lowestCount = 0'
    this.items = {};
  }

  // 双端队列增操作，在队尾添加一个元素
  addLast(element: T): void {
    this.items[this.count] = element;
    this.count++;
  }

  // 双端队列增操作，在队头添加一个元素
  addFirst(element: T): void {
    if (this.lowestCount > 0) {
      this.items[this.lowestCount] = element;
      this.lowestCount--;
    } else {
      for (let i = this.count; i > this.lowestCount; i--) {
        this.items[i] = this.items[i - 1];
      }
      this.items[this.lowestCount] = element;
      this.count++;
    }
  }

  // 双端队列删操作，移除队尾的元素并返回
  removeLast(): T | undefined {
    if (this.isEmpty()) {
      return undefined;
    }
    const element = this.items[this.count - 1];
    delete this.items[this.count - 1];
    this.count--;
    return element;
  }

  // 双端队列删操作，移除队头的元素并返回
  removeFirst(): T | undefined {
    if (this.isEmpty()) {
      return undefined;
    }
    const element = this.items[this.lowestCount];
    delete this.items[this.lowestCount];
    this.lowestCount++;
    return element;
  }

  // 双端队列查操作，查看队尾的元素
  peekLast(): T | undefined {
    if (this.isEmpty()) {
      return undefined;
    }
    return this.items[this.count - 1];
  }

  // 双端队列查操作，查看队头的元素
  peekFirst(): T | undefined {
    if (this.isEmpty()) {
      return undefined;
    }
    return this.items[this.lowestCount];
  }

  // 辅助方法，判断双端队列是否为空
  isEmpty(): boolean {
    return this.size() === 0;
  }

  // 辅助方法，返回双端队列的长度。
  size(): number {
    return this.count - this.lowestCount;
  }
}

基于链表代码实现

我们考虑用双向链表来实现栈，看下面的代码：

typescript 复制代码 
export class Deque<T> {
  private items: DoublyLinkedList<T>;

  // 双端队列增操作，在队尾添加一个元素
  addLast(element: T): void {
    this.items.push(element);
  }

  // 双端队列增操作，在队头添加一个元素
  addFirst(element: T): void {
    this.items.unshift(element);
  }

  // 双端队列删操作，移除队尾的元素并返回
  removeLast(): T | undefined {
    if (this.isEmpty()) {
      return undefined;
    }
    return this.items.pop();
  }

  // 双端队列删操作，移除队头的元素并返回
  removeFirst(): T | undefined {
    if (this.isEmpty()) {
      return undefined;
    }
    return this.items.shift();
  }

  // 双端队列查操作，查看队尾的元素
  peekLast(): T | undefined {
    if (this.isEmpty()) {
      return undefined;
    }
    return this.items.getTail().element;
  }

  // 双端队列查操作，查看队头的元素
  peekFirst(): T | undefined {
    if (this.isEmpty()) {
      return undefined;
    }
    return this.items.getHead().element;
  }

  // 辅助方法，判断双端队列是否为空
  isEmpty(): boolean {
    return this.items.isEmpty();
  }

  // 辅助方法，返回双端队列的长度。
  size(): number {
    return this.items.size();
  }
}
相关推荐
平头哥技术团队1 小时前
Day 16 | 用 ul、ol、li 一个标签,把散资料收成有序的技能清单页
开发语言·前端·html·html5
代码青铜z1 小时前
不会写代码做小程序，模板开发和AI 编程靠谱吗？创业前先看这 5 件事
前端
小傅哥1 小时前
Java + DDD，1:1 复刻 Deepseek Harness 项目
前端·后端·ai编程
积硅步致千里2 小时前
Word 里的 .wmf 其实是 EMF：一次 metafile 转 PNG 排障
前端·后端
mayaairi2 小时前
Vue2 组件通讯（二）：ref、自定义事件与provide/inject实战
前端·javascript·vue.js
wabs6662 小时前
关于二叉树【429.N叉树的层序遍历的思考】
数据结构·c++·算法·leetcode·二叉树
开开心心就好2 小时前
PDF图片去水印软件，支持批量处理页面
前端·javascript·人工智能·智能手机·pdf·语音识别
hetao17338372 小时前
2026-09-08 hetao1733837 的刷题记录
c++·算法
爱敲代码的小杨.2 小时前
【Spring】Spring Web MVC
前端·spring·mvc
C++ 老炮儿的技术栈2 小时前
MFC CPtrArray的用法
开发语言·数据结构·c++·算法·mfc·c
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02GitHub 镜像站点03如何新建文件夹？ 电脑新建文件夹的4种方法04历年考研数学一、数学二、数学三真题试卷及答案PDF052026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？06蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接07微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新08ZCode 周末送额度活动开启：3 亿 Token 免费领取09Agnes AI 免费 API 接入指南：文本、生图、生视频，一套接口全免费10AI 编程 IDE 全景解析 2026：Agent 全面接管开发链路