数据结构【六】- 链表实现栈和队列

最新推荐文章于 2023-05-28 18:24:15 发布
最新推荐文章于 2023-05-28 18:24:15 发布
阅读量343 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunshine77_/article/details/97945995
版权

一. 使用链表实现栈

1. 原理

    需求：由于栈是一个后入先出的结构，它只对栈的一段操作。无论是增加元素，删除元素，查看元素，都在栈顶进行。所以对于链表来说，我们的在添加和删除链表头的时间复杂度是O(1)。所以我们这里将链表头作为栈顶。

    解决：

       （1）利用我们在【数据结构【二】-栈】中的栈的接口，来使用链表实现栈

public interface Stack<E> {
   int getSize();
   boolean isEmpty();
   void push(E e);
   E pop();
   E peek();
}

              

 

      （2）创立一个新的类LinkedListStack,实现基本的方法

2. 代码

这里的代码LinkedList，请参考上一节的博客的链表代码。

public class LinkedListStack<E> implements Stack<E> {
    private LinkedList<E> list;
    public LinkedListStack(){
        list = new LinkedList<E>();
    }
    @Override
    public int getSize() {
        return list.getSize();
    }
    @Override
    public boolean isEmpty() {
        return list.isEmpty();
    }
    @Override
    public void push(E e) {
        list.addFist(e);
    }
    @Override
    public E pop() {
        return list.removeFirst();
    }
    @Override
    public E peek() {
        return list.getFirst();
    }
    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append("Stack : top ");
        res.append(list);
        return res.toString();
    }
    public static void main(String[] args){
        LinkedListStack<Integer> stack = new LinkedListStack<Integer>();
        for(int i=0;i<5;i++){
            stack.push(i);
            System.out.println(stack);
        }
        stack.pop();
        System.out.println(stack);
    }
}

测试

Stack : top 0->NULL
Stack : top 1->0->NULL
Stack : top 2->1->0->NULL
Stack : top 3->2->1->0->NULL
Stack : top 4->3->2->1->0->NULL
Stack : top 3->2->1->0->NULL

3. 链表实现栈和动态数组实现栈的时间差异

就一个操作分析：比如push()操作

1. 对于链表实现栈：在所操作的时候，我们每次都要new一个Node，这个过程也会耗时。因为它会不停的在内存中寻找新可以开辟空间的地方开辟空间。通常push()操作越多，new操作的耗时就越明显。

2. 对于动态数组实现栈：时不时就要一个新的数组，将原来数组中的元素拷贝到新的数组中（扩容）。这个过程相对耗时。

3. 其实ArrayStack和LinkedListStack，都是同一复杂度的。所以不同情况下，二者的耗时由差异是正常情况。不存在复杂度的巨大差异。我这边测试当push()操作执行200000次的时候，LinkedListStack所需的时间短。当push()操作执行2000000次的时候，ArrayStack所需的时间短。

二.带有尾指针的链表：使用链表实现队列

1. 原理

    需求：用链表的结构来实现队列【队列：先进先出的结构】

    解决：

       （1）由于队列是先进先出的结构，需要在队列头删除元素，在对列尾加入元素。但是对于链表来说，在链表头添加和删除元素都是O(1)的复杂度，但是在链表尾添加和删除元素都是O(n)的复杂度，所以为了使得用链表实现的队列的复杂度降低，我们在链表尾部在设立一个Node节点，命名为tail。对于tail来说，在tail之后添加元素很容易，但是在删除tail位置的元素的复杂度是O(n)。所以我们应该在链表头来删除元素，在链表尾部来添加元素。所以我们将链表头作为队首，将链表尾部作为队尾。

       （2）在这里不使用虚拟头节点了，是因为这里不牵扯到对链表中的操作。所以没必要统一对链表中间元素进行的操作和链表两边元素的操作他们之间带来的逻辑不统一的情况。

       （3）当链表为空的时候，head和tail也是null。由于没有dummyHead，要注意链表为空的情况。

2. 代码

public interface Queue<E> {
    void enQueue(E e);
    E deQueue();
    E getFront();
    int getSize();
    boolean isEmpty();
}
public class LinkedListQueue<E> implements Queue<E> {
    //使用内部类来表示节点
    private class Node{
        public E e;
        public Node next;
        public Node(E e, Node next){
            this.e = e;
            this.next = next;
        }
        public Node(E e) {
            this(e, null);
        }
        public Node() {
            this(null, null);
        }
        @Override
        public String toString(){
            return e.toString();
        }
    }
    private Node head,tail;
    private int size;
    public LinkedListQueue(){
        head = null;
        tail = null;
        size = 0;
    }
    @Override
    public int getSize() {
        return size;
    }
    @Override
    public boolean isEmpty() {
        return size==0;
    }
    @Override
    public void enQueue(E e) {
        if(tail == null){
            tail = new Node(e);
            head = tail;
        }else{
            tail.next = new Node(e);
            tail = tail.next;
        }
        size++;
    }

    @Override
    public E deQueue() {
        if(isEmpty()){
            throw new IllegalArgumentException("Cannot dequeue from empty queue.");
        }
        Node delNode = head;
        head = head.next;//head指向了原来头节点的下一个节点
        delNode.next = null;//将delNode从链表中断开
        if(head == null){
            tail = null;
        }
        size--;
        return delNode.e;
    }
    @Override
    public E getFront() {
        if(isEmpty()){
            throw new IllegalArgumentException("Queue is empty.");
        }
        return head.e;
    }
    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append("Queue: front ");
        Node curr = head;
        while(curr != null){
            res.append(curr+"->");
            curr = curr.next;
        }
        res.append("NULL tail");
        return res.toString();
    }
}

3. 链表实现栈和动态数组实现栈的时间差异

就一个操作分析：比如push()操作

1. 对于用数组实现队列：由于它的时间复杂度是O(n^2)的，所以它的速度是最慢的。

2. 对于用循环数组来实现队列：它的时间复杂度是O(n)的

3. 对于用链表实现来实现队列：它的时间复杂度是O(n)的。所以和用循环数组实现队列所用的时间差不多。

 

三.使用链表实现队列【在有dummyHead的情况下】

1. 需求

    用链表的结构来实现队列【队列：先进先出的结构】。上一节用的是没有DummyHead的情况下的代码，这里实现的是有dummyHead节点的代码。

参考：数据结构【五】- 链表【链表的介绍和实现：增删改查】

2.代码

package Queue;

public interface Queue<E> {
    void enQueue(E e);
    E deQueue();
    E getFront();
    int getSize();
    boolean isEmpty();
}
package LinkedList;

import Queue.Queue;

public class LinkedListQueueDummy<E> implements Queue<E> {
//1. 使用内部类来表示节点
    public class Node{
        E val;
        Node next;

        public Node(E val, Node next){
            this.val = val;
            this.next = next;
        }
        public Node(E val){this(val,null);}
        public Node() {
            this(null, null);
        }
        @Override
        public String toString(){
            return val.toString();
        }
    }
//2.构建节点
    //设置虚拟头节点
    private Node dummyHead;
    //设置尾节点
    private Node tail;
    //链表的大小
    private int size;
//3. 初始化链表
    public LinkedListQueueDummy(){
        dummyHead = new Node(null,null);//初始化dummyHead
        tail = null;
        size =0;
    }
//4. getSize()方法
    @Override
    public int getSize() {
        return size;
    }
//5. isEmpty()方法
    @Override
    public boolean isEmpty() {
        return size==0;
    }
//6.添加数据
    @Override
    public void enQueue(E e) {
        if(isEmpty()){
            tail =  new Node(e);
            dummyHead.next = tail;
        }else{
            tail.next = new Node(e);
            tail = tail.next;
        }
        size++;
    }
//7.删除节点
    @Override
    public E deQueue() {
        if(isEmpty()){
            throw new IllegalArgumentException("Cannot dequeue from empty queue.");
        }
        Node prev = dummyHead;
        Node delNode = prev.next;
        prev.next = delNode.next;
        delNode.next = null;
        if( prev.next == null){
            tail = null;
        }
        size--;
        return delNode.val;
    }

    @Override
    public E getFront() {
        if(isEmpty()){
            throw new IllegalArgumentException("Queue is empty.");
        }
        return dummyHead.next.val;
    }
    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append("Queue: front ");
        LinkedListQueueDummy.Node curr = dummyHead.next;
        while(curr != null){
            res.append(curr+"->");
            curr = curr.next;
        }
        res.append("NULL tail");
        return res.toString();
    }
}

3.测试

    public static void main(String[] args){
        LinkedListQueueDummy<Integer> linkedListQueue = new LinkedListQueueDummy<Integer>();
        linkedListQueue.enQueue(8);
        linkedListQueue.enQueue(9);
        System.err.println(linkedListQueue);
        System.err.println(linkedListQueue.deQueue());
        System.err.println(linkedListQueue);
        linkedListQueue.enQueue(10);
        System.err.println(linkedListQueue);
    }

Queue: front 8->9->NULL tail
8
Queue: front 9->NULL tail
Queue: front 9->10->NULL tail

                                    以上所有内容都是通过"慕课网"听"liuyubobobo"的《玩转数据结构》课程后总结


 

你的橙子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构实验-链表及栈的应用-天津理工大学
05-04
在这个实验中，学生需要深入理解链表和栈这两种重要的数据结构，并利用它们解决实际问题。 链表是一种线性数据结构，其中的元素并不在物理内存中连续存储。每个元素（节点）包含数据和指向下一个节点的指针，这允许...
数据结构之链表
玲珑骰子安红豆，入骨相思知不知
05-27 420
三种常见的链表结构 1、单链表 2、循环链表 3、双向链表 单链表 链表通过指针将一组零散的内存块串联在一起。把内存块称为链表的“结点”。为了将所有的结点串起来，每个链表的结点除了存储数据之外，还需要记录链上的下一个结点的地址。把这个记录下个结点地址的指针叫做后继指针next。第一个结点叫做头结点，最后一个结点叫做尾结点。头结点用来记录链表的基地址，有了头结点，就可以遍历整条链表，而尾结点特殊的地方是：指针不是指向下一个结点，而是指向一个空地址NULL，表示这是链表上最后一个结点。 单链表的插入和删除操作
数据结构与算法04：队列
浮尘笔记
05-28 1722
队列主要包含两个操作：入队（在队列尾部插入一个数据）和出队（从队列头部删除一个数据） ，队列也是一种操作受限的线性表数据结构，队列可以用数组来实现，也可以用链表来实现。队列中需要定义两个指针：一个是指向队头的head 指针，另一个是指向队尾的 tail 指针。在循环队列中，最关键是要确定好队空和队满的判定条件，循环队列的入队操作和出队操作的时间复杂度都是O(1)。阻塞队列是一个 “生产者——消费者模型”。
使用数组和链表实现栈和队列的复杂度分析
mcrwayfun，欢迎你
11-13 2546
​ 抽象数据类型（abstract data type，ADT）是带有一组操作的一些对象的集合 1 表ADT A1,A2,⋯&amp;ThinSpace;,AN A_1,A_2,\cdots,A_N A1​,A2​,⋯,AN​ ​ 如上，这是一个大小为N的表。当然，若N为0，则称其为空表。 ​ 对于除空表以外的任何表，A1可以看作是A2的前驱，而A2则是A1的后继。在一个表中，表中第一个元素是A1...
数据结构——栈与队列
醉风的博客
06-29 628
目录一 栈1.1 定义1.2 顺序栈1.3 链式栈1.4 时间复杂度1.5 顺序栈和链式栈的区别二 队列2.1 定义2.2 顺序队列2.3 循环队列2.3 链式队列2.4 时间复杂度2.5 循环队列和链式队列的区别 一 栈 1.1 定义 是指仅限在表尾进行插入删除操作的线性表。 特点是先进后出。 1.2 顺序栈 数组的简化， 限制了插入删除只能在表尾进行。 1.3 链式栈 1.在单链表的基础上加一层限制， 只能在表尾做插入插入删除的操作。 1.4 时间复杂度 1.顺序栈和链式栈的出栈（pop）和进栈
数据结构之链表，使用链表实现栈以及使用链表实现队列
Biexiansheng的博客
03-24 348
1、结合之前实现的链表这个数据结构，如果只对链表的头部进行增加和删除，时间复杂度是O(1)的，只对链表的头部进行查询的话，时间复杂度是O(1)的。那么，满足这样的数据结构是什么呢，就是栈，栈这种数据结构是后入先出的，或者先进后出的，只对栈的一端，就是栈顶进行操作，无论是添加元素、删除元素、查询元素，都是在栈顶进行的。所以对于链表来说，可以将链表的头部当作栈顶，用链表做为栈的底层实现来实现一个栈。 ...
数据结构---栈和队列之链栈（C语言）
05-05
本话题主要探讨的是数据结构中的两种特殊结构：栈和队列，特别是如何使用C语言实现链栈。栈是一种后进先出（LIFO, Last In First Out）的数据结构，而队列则是先进先出（FIFO, First In First Out）的数据结构。链栈...
Java数据结构之链表、栈、队列、树的实现方法示例
08-26
"Java数据结构之链表、栈、队列、树的实现方法示例" 在计算机科学中，数据结构是一种组织和存储数据的方式，以便实现高效的数据存取和处理。Java数据结构中常用的数据结构有链表、栈、队列、树等，本文将详细介绍...
链表-使用Python基于链表实现栈数据结构.zip
最新发布
03-13
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在实现其他数据结构如栈、队列和图时。与数组不同，链表的元素不需要在内存中连续存储，每个元素（节点）包含数据以及指向下一个元素的引用...
链表实现栈和队列（经典程序）
11-13
用链表实现栈和队列的操作，使链表操作更加成熟，熟练栈和队列的机制
代码随想录算法训练营第三期day03-链表01
weixin_57614037的博客
10-29 2236
链表用Java写总感觉不带感，觉得还是用C++写一遍才能更好地理解哈哈
算法笔记（链表篇）
weixin_57263654的博客
05-24 284
链表经典算法题 移除链表元素 203.移除链表元素 给你一个链表的头节点head和一个整数val，请你删除链表中所有满足Node.val == val的节点，并返回新的头节点。 设计链表 707.设计链表 设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val和next。val是当前节点的值，next是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性...
链表基础概念与经典题目（Leetcode题解-Python语言）
自动化研究生在读，此博客记录了我的学习与刷题经验，欢迎大家阅读交流
11-04 792
所谓链表，就是由链节点元素组成的表，那什么是链节点呢？直接上定义： class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next 很简单，链节点就是只记录自身的值 val，还有其指向的下一个链节点的位置 next。 707. 设计链表 class ListNode: def __init__(self, val=0, next=None):
链表、栈、队列
qq_45243783的博客
06-27 640
基础数据结构
链表方式实现栈和队列（C语言）
weixin_73567058的博客
04-21 882
栈（Stack）是一种常见的数据结构，它是一种线性数据结构，具有后进先出（Last In First Out, LIFO）的特点。栈可以看作是一个容器，只能在容器的一端进行插入和删除操作，这一端被称为栈顶（Top），另一端被称为栈底（Bottom）。栈的基本操作有入栈（Push）、出栈（Pop）、获取栈顶元素（Top）和判断栈是否为空（Empty）。入栈操作将一个元素插入到栈顶，出栈操作将栈顶元素删除并返回，获取栈顶元素操作返回栈顶元素但不删除，判断栈是否为空操作返回一个布尔值。
数据结构（栈/队列/链表）
weixin_47667133的博客
07-20 916
线性数据结构 2. 什么叫做数据结构 数据结构是计算机存储、组织数据的方式。指的是相互之间存在一种或多种特定关系的数据元素的集合。 ​ – 百度百科 可比喻成一个企业的组织结构，组织结构其实就是部门与部门之间的关系结构。 数据结构就是用来描述数据与数据之间的关系 线性和非线性数据结构 线性结构：数据元素之间一对一的关系 非线性结构：数据元素之间一对多的关系 存储方式 顺序存储：Set、Array 散列存储：Map、Object
C语言实现栈和队列
qq_49613557的博客
04-22 802
C语言实现栈和队列 目录栈队列栈和队列完整代码实现 栈 1.栈 1.1栈的概念及结构 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据也在顶。 1.2栈的实现 栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值