初识栈和队列

已于 2022-05-20 14:03:23 修改
阅读量148 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构
于 2022-05-17 15:20:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/k1159/article/details/124708290
版权
本文深入介绍了线性表的概念，包括栈和队列这两种特殊形式的线性表。栈遵循先进后出（FILO）原则，常用于表达式求值等；队列遵循先进先出（FIFO）原则，适用于任务调度。文章详细讲解了循环队列、双端队列和优先级队列（堆）的实现及操作，如堆的上浮、下沉和堆化，并展示了如何使用优先级队列解决TopK问题。此外，还讨论了堆的性质和在数据排序中的应用。
摘要由CSDN通过智能技术生成

1、什么是线性表？:
一次保存单个同类型元素，多个元素之间逻辑上连续

栈

【栈和队列是操作受限的线性表】
【FILO，先进后出，仅能从栈顶增加或者删除元素】
1、栈的实现:
基于数组实现的栈 --顺序栈
在这里插入图片描述

队列

【FIFO，先进先出，元素从“队尾”添加，元素从“队首”删除】
常用： 链式队列
在这里插入图片描述

1、队列的子类：
FIFO、双端队列Deque、循环队列LoopQueue、优先级队列 PriorityQueue
[由于子类较多，实现Queue接口]

public interface Queue<E> {
    void offer(E val);//入队
    E poll();//出队
    E peek();//查看队首
    boolean isEmpty();//判空
}

循环队列

例：os生产者消费者模型，MySQL数据库的InnoDB存储引擎中的redo日志

使用长度固定的数组实现，数组头部就是队首（head）,数组末尾就是队尾（tail）,数组[head,tail)是有效元素
【tail一直指向循环队列有效元素的后一个位置】
【所谓循环队列，就是当head或者tail引用走到末尾时，下一次再继续向后移动，其实就是返回数组的头部继续操作】

步骤：

1、当" tail + 1 "= head;就认为队列已满
2、head和tail的移动：使用取模操作 ---------> tail = (tail +1) %n;
在这里插入图片描述

双端队列

Deque -> Queue的子接口
既可以尾插头出，也可以头插尾出
在这里插入图片描述

【注】无论使用栈还是接口，统一使用双端队列不推荐使用Stack类，被淘汰了

在这里插入图片描述

优先级队列

1、什么是优先级队列（堆）：
按照优先级的大小动态出队
2、基于二叉树的堆（二叉堆，应用最广泛的堆）
①特点1、:完全二叉树，基于数组存储（ 元素都是靠左排列，数组中存储不会浪费空间）
2、堆中根节点的值>= 子树节点中的值（最大堆）-------堆中根节点的值<=子树中节点的值（最小堆）
【PriorityQueue 默认基于最小堆实现】
在这里插入图片描述

3、堆中基本操作

【基于int型最大堆】
①上浮siftUp–添加一个元素
不断将索引K和其父节点大小对比，若大于则交换顺序，直到＜=父节点

/**
     * 元素上浮
     *
     * @param k
     */
    private void siftUp(int k) {
        while (k > 0 && elementData.get(k) > elementData.get(parent(k))) {
            swap(k, parent(k));
            k = parent(k);
        }
    }

    private void swap(int k, int parent) {
        int childVal = elementData.get(k);
        int parentVal = elementData.get(parent);
        elementData.set(k, parentVal);
        elementData.set(parent, childVal);
    }

②下沉–取出最大值（若一直取最大值，降序）

/**
     * 元素下沉
     */
    private void siftDown(int k) {
        //还有左子树，
        while (leftChild(k) < size) {
            int j = leftChild(k);
            if (j + 1 < size && elementData.get(j) < elementData.get(j + 1)) {
                j++;
            }
            if (elementData.get(k) >= elementData.get(j)) {
                break;
            } else {
                swap(k, j);
                k = j;
            }
        }
    }

③heapify-堆化
方法一：建立新堆，依次添加元素（nlongn）
方法二：原地堆化–从最后一个非叶子节点开始进行元素siftDown操作(n)

/**
     * 将任意整型数组调整为优先级队列--堆
     *
     * @param arr
     */
    public MaxHeap(int[] arr) {
        elementData = new ArrayList<>(arr.length);
        //1、所有元素入堆
        for (int i : arr) {
            elementData.add(i);
        }
        size = elementData.size();
        //2、从最后一个非叶子节点开始siftDowm操作
        for (int i = parent(size-1); i >=0 ; i--) {
            siftDown(i);
        }
    }
    //时间复杂度O（n）

堆的TopK问题

【取小用大/取大用小】
在这里插入图片描述
在这里插入图片描述

import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Queue;

/**
 * @work: 面试题 17.14. 最小K个数
 */
public class Offer17_14 {
    //方法一：排序，时间复杂度高O（n^2）;
    public int[] smallestK(int[] arr, int k) {
        Arrays.sort(arr);
        int[] arr1 = new int[k];
        for (int i = 0; i < k; i++) {
            arr1[i] = arr[i];
        }
        return arr1;
    }

    //方法二：优先级队列
    //取大用小
    //取小用大
    public int[] smallestK1(int[] arr, int k) {
        int[] ret = new int[k];
        if (arr.length == 0 || k == 0) {
            return ret;
        }
        //JDK默认最小堆--(o1, o2) -> o2 - o1改造成最大堆
        Queue<Integer> queue = new PriorityQueue<>((o1, o2) -> o2 - o1);
        //1、队列中先保存K个元素
        for (int i = 0; i < arr.length; i++) {
            if (queue.size() < k) {
                queue.offer(arr[i]);
            } else {
                int max = queue.peek();
                if (max > arr[i]) {
                    queue.poll();
                    queue.offer(arr[i]);
                }
            }
        }
        int i = 0;
        while (!queue.isEmpty()) {
            ret[i++] = queue.poll();
        }
        return ret;
    }
}

在这里插入图片描述
在这里插入图片描述

public class Num347 {
    public int[] topKFrequent(int[] nums, int k) {
        int[] ret = new int[k];
        Map<Integer, Integer> map = new HashMap<>();
        for (int i : nums) {
            if (map.containsKey(i)) {
                int time = map.get(i);
                map.put(i, time + 1);
            } else {
                map.put(i, 1);
            }
        }
        Queue<Freq> queue = new PriorityQueue<>();
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            if (queue.size() < k) {
                queue.offer(new Freq(entry.getKey(), entry.getValue()));
            } else {
                Freq freq = queue.peek();
                if (entry.getValue() > freq.val) {
                    queue.poll();
                    queue.offer(new Freq(entry.getKey(), entry.getValue()));
                }
            }
        }
        int i = 0;
        while (!queue.isEmpty()) {
            ret[i++] = queue.poll().key;
        }
        return ret;
    }
}

class Freq implements Comparable<Freq> {
    int key;//元素
    int val;//频次

    public Freq(int key, int val) {
        this.key = key;
        this.val = val;
    }


    @Override
    public int compareTo(Freq o) {
        return this.val - o.val;
    }
}

在这里插入图片描述

public class Num347 {
    public int[] topKFrequent(int[] nums, int k) {
        int[] ret = new int[k];
        Map<Integer, Integer> map = new HashMap<>();
        for (int i : nums) {
            if (map.containsKey(i)) {
                int time = map.get(i);
                map.put(i, time + 1);
            } else {
                map.put(i, 1);
            }
        }
        Queue<Freq> queue = new PriorityQueue<>();
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            if (queue.size() < k) {
                queue.offer(new Freq(entry.getKey(), entry.getValue()));
            } else {
                Freq freq = queue.peek();
                if (entry.getValue() > freq.val) {
                    queue.poll();
                    queue.offer(new Freq(entry.getKey(), entry.getValue()));
                }
            }
        }
        int i = 0;
        while (!queue.isEmpty()) {
            ret[i++] = queue.poll().key;
        }
        return ret;
    }
}

class Freq implements Comparable<Freq> {
    int key;//元素
    int val;//频次

    public Freq(int key, int val) {
        this.key = key;
        this.val = val;
    }


    @Override
    public int compareTo(Freq o) {
        return this.val - o.val;
    }
}

堆的原地排序

在这里插入图片描述

java中比较两个元素的大小

1、equals
2、类继承Comparable接口，覆写comparaTo方法
3、comparator比较器接口（一个类若实现了此接口表示天生为了别的类大小关系来服务）

package interface_practice;

import java.util.Arrays;
import java.util.Comparator;

/**
 * @work: 练习comparator接口使用方法。
 */
public class ComparatorTest {
    public static void main(String[] args) {
        Student[] students = new Student[]{
                new Student(18, "小张"),
                new Student(20, "小李"),
                new Student(30, "小王")
        };
        Arrays.sort(students, new StudentSec());
        System.out.println(Arrays.toString(students));//[Student{age=18, name='小张'}, Student{age=20, name='小李'}, Student{age=30, name='小王'}]
        Student[] student1 = new Student[]{
                new Student(18, "小张小"),
                new Student(20, "小"),
                new Student(30, "小王把把")
        };
        Arrays.sort(student1, new StudentName());
        System.out.println(Arrays.toString(student1));//[Student{age=20, name='小'}, Student{age=18, name='小张小'}, Student{age=30, name='小王把把'}]
    }
}

class Student {
    private int age;
    private String name;

    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

class StudentSec implements Comparator<Student> {//比较器接口，为别的类服务

    @Override
    public int compare(Student o1, Student o2) {
        return o1.getAge() - o2.getAge();
    }
}

class StudentName implements Comparator<Student> {

    @Override
    public int compare(Student o1, Student o2) {
        return o1.getName().length() - o2.getName().length();
    }
}
蕾姆的48六
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
头歌初识redis答案
06-06
- **列表（List）**：有序的数据集合，适合于实现队列或者栈。 - **集合（Set）**：无序且不重复的元素集合，可用于实现成员检查、交集并集等操作。 - **哈希（Hash）**：存储多个字段的映射表，非常适合用于存储...
第01课时-初识数据结构.pptx
12-06
第01课时-初识数据结构 数据结构是计算机程序设计的基础，涉及数据抽象、建模、算法设计、编写程序等多个方面。数据结构的概念是指数据元素之间的相互关系，即数据的组织形式。它包括了三个方面的内容：数据元素...
初识栈和队列/栈和队列的实现
m0_73265646的博客
12-10 185
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表。
初识栈和队列（1）
weixin_53831496的博客
07-13 171
栈的概念及结构 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈，出数据也在栈顶。 栈的实现 栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些，因为数组在尾上插入数据的代价比较小。 相对而言，如果选一个来实现，双向带头循环列表被排除掉，太过麻烦。 如果选一
基本数据结构：初识栈和队列
weixin_43031313的博客
04-15 158
栈 栈：后进先出（last-in, first-out,LIFO)策略 用一维数组S[1…n]实现，最多容纳n个元素 当S.top = 0时，栈为空(empty)，可用查询操作STACK_EMPTY测试一个栈是否为空 栈的操作 STACK_EMPTY(S) //测试栈是否为空 if S.top == 0 return TRUE else return FALSE PUSH(S,x) ...
Python数据结构第三章第一节--初识栈和队列
2301_81989907的博客
04-07 272
队列：像排队打饭一样，先进先出（First in First out, 简称：FIFO）栈：像叠盘子一样，后进先出（Last in First out:简称：LIFO)6.栈底：Stack_Base。5.栈顶：Stack_Top。2. 队列：Queue。
初识队列和栈
qq_56967325的博客
08-05 91
队列特点 先进先出 队列基本用法 public static void main(String[] args) { Queue<Integer>queue = new LinkedList<>(); queue.add(1);//放元素 queue.add(2); queue.add(3); queue.add(4); queue.add(5); queue.add(6); System.out.println(que
数据结构--初识栈和队列
m0_74288306的博客
07-03 327
int top;//栈的容量 } ST;定义一个STDataType类型的指针，int类型的top变量记录位置，int类型的capacity变量记录栈的容量。
栈与队列初识
Clay的博客
10-09 431
栈与队列 栈 栈是限定仅在表尾进行插入和删除操作的线性表。(撤销、后退功能常用结构) 允许插入和删除的一端称为栈顶，也是表尾，另一端称为栈底，没有数据元素称为空栈，栈成为后进先出的线性表，LIFO结构。 栈元素具有线性关系，即前驱后继关系。 栈的插入操作，叫进栈、压栈、入栈；删除操作，叫出栈、弹栈。 栈的抽象数据类型 ADT 栈(Stack) // 理论上线性表的操作特性它都具备 Data 同线性表，元素具有相同的类型，相邻元素具有前驱和后继关系。 Operation InitStac
初识栈与队列
2301_79977698的博客
03-20 1216
队列是一种常见的数据结构，它遵循先进先出（First-In-First-Out，FIFO）的原则。这意味着最先进入队列的元素将最先被移除。队列通常比喻为排队等待服务的人群，先来的人先被服务，后来的人依次排在后面等待。队列有两个主要操作：1.入队（enqueue）：向队列的末尾（队尾）添加一个元素。2.出队（dequeue）：从队列的头部（队首）移除一个元素。除此之外，队列还可能包括其他操作，如：​查看队首元素（peek）：获取队列的第一个元素，但不将其从队列中移除。​。
栈和队列的实现
xbhinsterest11的博客
03-27 2017
啥是栈？啥是队列？你想知道的这里都有
ZMQ专题学习之一：初识ZeroMQ
01-06
ZMQ专题学习之一：初识ZeroMQ  ZeroMQ号称是“史上最快的消息队列”，基于c语言开发的。引用官方说明定义：“ZMQ(以下ZeroMQ简称ZMQ)是一个简单好用的传输层，像框架一样的一个socket library，他使得Socket编程...
算法电子书 初识ACM090216.zip
06-16
5. **基本数据结构**：数组、链表、栈、队列、树、图等是算法实现的基础，理解这些数据结构的性质和操作对于解决问题至关重要。 6. **问题解决策略**：如何分析问题、设计算法，以及如何用伪代码或实际代码来表达...
初识block之block入门
05-02
你可以将Block提交到不同的队列，比如串行队列、并行队列或者主队列，以控制任务的执行顺序和并发级别。 例如，将一个Block提交到全局并行队列： ```objc dispatch_queue_t globalQueue = dispatch_get_global_...
【数据结构-前缀哈希】力扣523. 连续的子数组和
sjsjs11的博客
08-05 363
当发现有两个余数相同的key的时候，对他们value作差，如果大于等于二，说明该子段长度大于等于二，这时候就找到了一个好的子数组，返回true，如果到最后都没有找到这样一个好的子数组，返回false。，其中 m 是数组 nums 的长度。解释：[23, 2, 6, 4, 7] 是大小为 5 的子数组，并且和为 42。输入：nums = [23,2,6,4,7], k = 13。输入：nums = [23,2,4,6,7], k = 6。输入：nums = [23,2,6,4,7], k = 6。
常见8种数据结构
最新发布
qq_43575301的博客
08-08 635
应用于需要后进先出访问元素的场景，如函数调用栈、表达式求值等。应用于需要先进先出访问元素的场景，如任务调度、消息队列等。适用于优先队列，堆排序和实现高效的合并K个有序链表问题。应用于需要表示层次结构的场景，比如文件系统、组织结构等。应用于需要表示网络结构的场景，如社交网络、交通网络等。应用于需要快速查找和插入操作的场景，如字典、缓存等。一般应用于需要快速随机访问元素的场景。适用于需要频繁插入和删除元素的场景。
数据结构：栈（含源码）
2401_86551514的博客
08-05 575
先判断容量是否有足够的空间让数据入栈，在第一次入栈是先给定4个空间，后面每次不够时就将空间数乘以2， 还有一个判断是否开辟成功（这个可以不写，一般都会开辟成功）。栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作，进行数据插入和删除操作的一端称为栈顶，另一端称为栈底，栈中的数据元素遵守后进先出的原则。我们在创建栈时，一般是创建支持动态增长的栈，定长的静态栈不实用。出栈非常的简单，只要将top数减少一个就行了，相当于是下一次入栈是直接把这个数据修改掉，就算没修改，打印时也不影响。
数据结构：链表经典算法OJ题
2401_86551514的博客
08-04 1040
在了解了链表的相关知识后，我们还需要一些题目进行练习加深对链表这方面知识的理解，也可以用来检测链表这块学的的怎么样，废话不多说，开始上手。
初识Redis 第1关：Redis中的数据结构
06-05
Redis是一个开源的高性能键值对存储数据库，它支持多种数据结构，包括字符串、哈希、列表、集合和有序集合等。这些数据结构不仅可以存储简单的字符串值，还可以存储更复杂的数据结构。 其中，字符串是最简单的数据类型，它可以存储任何类型的数据，包括文本、数字和二进制数据等。哈希是一个键值对的集合，每个键都对应一个值，它可以存储类似于对象的结构。列表是一个有序的字符串列表，它支持在列表两端添加或删除元素，可以作为队列或栈使用。集合是一个无序的字符串集合，它可以进行集合运算，如并集、交集和差集等。有序集合是一个有序的字符串集合，每个字符串都对应一个分数，它可以进行区间查询和排名操作。 除了上述数据结构，Redis还支持一些高级数据结构，如HyperLogLog、GEO等。HyperLogLog是一种基数算法，可以用来估计一个集合的基数。GEO是一种地理位置数据类型，可以用来存储地理位置信息并进行位置查询。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值