数据结构与算法（三）栈和队列

最新推荐文章于 2023-05-26 19:30:50 发布

Damon_zqt

最新推荐文章于 2023-05-26 19:30:50 发布

阅读量304

点赞数

分类专栏：数据结构与算法

本文链接：https://blog.csdn.net/Damon_zqt/article/details/105784141

版权

数据结构与算法专栏收录该内容

15 篇文章 2 订阅

订阅专栏

栈概述

数组、链表、树等数据结构适用于存储数据库应用中的数据记录，它们常常用于记录那些现实世界的对象和活动的数据，便于数据的访问：插入、删除和查找特定数据项。

而栈和队列更多的是作为程序员的工具来使用。他们主要作为构思算法的辅助工具，而不是完全的数据存储工具。这些数据结构的生命周期比那些数据库类型的结构要短很多。在程序操作执行期间它们才被创建，通常它们去执行某项特殊的任务，当任务完成后就被销毁。

栈和队列的访问是受限制的，即在特定时刻只有一个数据项可以被读取或删除。

栈和队列是比数组和其他数据结构更加抽象的结构，是站在更高的层面对数据进行组织和维护。

栈的主要机制可用数组来实现，也可以用链表来实现。优先级队列的内部实现可以用数组或者一种特别的树——堆来实现。

栈只允许访问一个数据项：即最后插入的数据。移除这个数据项后才能访问倒数第二个插入的数据项。它是一种后进先出的数据结构。

栈实现

栈最基本的操作是出栈、入栈，还有其他扩展操作，如查看栈顶元素，判断栈是否为空、是否已满，读取栈的大小等。

下面我们就用数组来写一个栈操作的封装类。

public class Stack {
    private int size;           //栈的大小
    private int top;            //栈顶元素的下标
    private int [] stackArray;  //栈的容器
    
    //构造函数
    public Stack(int size){
        stackArray = new int [size];
        top = -1;   //初始化栈的时候，栈内无元素，栈顶下标设为-1
        this.size = size;
    }
    
    //入栈，同时，栈顶元素的下标加一
    public void push(int elem){
        stackArray[++top] = elem; //插入栈顶
    }
    
    //出栈，删除栈顶元素，同时，栈顶元素的下标减一
    public int pop(){
        return stackArray[top--]; 
    }
    
    //查看栈顶元素，但不删除
    public int peek(){
        return stackArray[top];
    }
    
    //判空
    public boolean isEmpty(){
        return (top == -1);
    }
    
    //判满
    public boolean isFull(){
        return (top == size-1);
    }
    
}

上例中，没有对可能的异常进行处理，需要由编程人员保证程序的正确性，比如，才出栈前需要应该保证栈中有元素，在入栈前应保证栈没有满。

入栈操作示意图：
在这里插入图片描述
出栈操作示意图：

应用实例

通常，文本串是用计算机语言写的代码行，而解析它们的程序就是编译器。

下面我们来用栈来实现一个经典的应用：分隔符匹配。

想一下在Eclipse编程时，如果我们写的代码中如果多了一个“{”，后者少了一个“}”，或者括号的顺序错乱，都会报错。接下来我们就用栈来模拟这种分隔符匹配。

分隔符匹配程序从字符串中不断地读取程序，每次读取一个字符，若发现它是左分隔符（{、[、(），将它压入栈中。当读到一个右分隔符时（)、]、}），弹出栈顶元素，并且查看它是否和该右分隔符匹配。如果它们不匹配，则程序报错。如果到最后一直存在着没有被匹配的分隔符，程序也报错。

我们来看下面这个正确的字符串：a{b(c[d]e)f}，在栈中的变化过程：

最后出现的左分隔符需要被最先匹配，这符合栈“后进先出”的规则。

在本例中，要处理的是字符，所以需要对上面的Stack类进行修改，需要将存放元素的数组改为char类型，并把相关方法的参数类型改为char类型，其余不变。

public class Stack {
    private int size;           //栈的大小
    private int top;            //栈顶元素的下标
    private char [] stackArray; //栈的容器
    
    //构造函数
    public Stack(int size){
        stackArray = new char [size];
        top = -1;   //初始化栈的时候，栈内无元素，栈顶下标设为-1
        this.size = size;
    }
    
    //入栈，同时，栈顶元素的下标加一
    public void push(char elem){
        stackArray[++top] = elem; //插入栈顶
    }
    
    //出栈，删除栈顶元素，同时，栈顶元素的下标减一
    public char pop(){
        return stackArray[top--]; 
    }
    
    //查看栈顶元素，但不删除
    public char peek(){
        return stackArray[top];
    }
    
    //判空
    public boolean isEmpty(){
        return (top == -1);
    }
    
    //判满
    public boolean isFull(){
        return (top == size-1);
    }
    
}
然后写一个类来封装分隔符匹配的操作：

public class BrecketChecker {
    
    private String input;  //存储待检查的字符串
    
    //构造方法，接受待检查的字符串
    public BrecketChecker(String in){
        this.input = in;
    }
    
    //检查分隔符匹配的方法
    public void check(){
        int strLength = input.length();
        Stack stack = new Stack(strLength);
        
        for(int i=0;i<strLength;i++){
            
            char ch = input.charAt(i);  //一次获取串中的单个字符
            
            switch(ch){
                case '{' :
                case '[' :
                case '(' :
                     //如果为左分隔符，压入栈
                    stack.push(ch); 
                    break;
                case '}' :
                case ']' :
                case ')' :
                    //如果为右分隔符，与栈顶元素进行匹配
                    if(!stack.isEmpty()){
                        char chx = stack.pop();
                        
                        if((ch == '{' && chx != '}')||
                           (ch == '(' && chx != ')')||
                           (ch == '[' && chx != ']')
                        ){
                            System.out.println("匹配出错！字符："+ch+",下标："+i);
                        }
                    }else{
                        System.out.println("匹配出错！字符："+ch+",下标："+i);
                    }
                    
                default :
                    break;
            }
            
        }
        
        if(!stack.isEmpty()){
            //匹配结束时如果栈中还有元素，证明右分隔符缺失
            System.out.println("有括号没有关闭！");
        }
    }
    
}

public static void main(String[] args) {
        
        System.out.println("输入需要检测的字符串：");
        String str = getString();
        BrecketChecker checker = new BrecketChecker(str);
        checker.check();
    }
    
    public static String getString(){
        String str = "";
        try{
            InputStreamReader reader = new InputStreamReader(System.in);
            BufferedReader bReader = new BufferedReader(reader);
            str = bReader.readLine();
        }catch(IOException e){
            e.printStackTrace();
        }
        return str;
    }

队列概述

栈是后进先出（LIFO，Last In First Out）的数据结构，与之相反，队列是先进先出（FIFO，First In First Out）的数据结构。

队列的作用就像售票口前的人们站成的一排一样：第一个进入队列的人将最先买到票，最后排队的人最后才能买到票。

在计算机操作系统或网路中，有各种队列在安静地工作着。打印作业在打印队列中等待打印。当敲击键盘时，也有一个存储键盘键入内容的队列，如果我们敲击了一个键，而计算机又暂时在做其他事情，敲击的内容不会丢失，它会排在队列中等待，直到计算机有时间来读取它，利用队列保证了键入内容在处理时其顺序不会改变。

栈的插入和删除数据项的命名方法很标准，成为push和pop，队列的方法至今也没有一个标准化的方法，插入可以称作put、add或enque等，删除可以叫作delete、get、remove或deque等。

下面我们依然使用数组作为底层容器来实现一个队列的操作封装，与栈不同的是，队列的数据项并不都是从数组的第一个下标开始，因为数据项在数组的下标越小代表其在队列中的排列越靠前，移除数据项只能从队头移除，然后队头指针后移，这样数组的前几个位置就会空出来如下图所示：
在这里插入图片描述
这与我们的直观感觉相反，因为我们排队买票时，队列总是向前移动，当前面的人买完票离开后，其他人都向前移动，而在我们的设计中，队列并没有向前移动，因为那样做会使效率大打折扣，我们只需要使用指针来标记队头和队尾，队列发生变化时，移动指针就可以，而数据项的位置不变。

但是，这样的设计还存在着一个问题，随着队头元素不断地移除，数组前面空出的位置会越来越多，当队尾指针移到最后的位置时，即使队列没有满，我们也不能再插入新的数据项了。

在这里插入图片描述
解决这种缺点的方法是环绕式处理，即让队尾指针回到数组的第一个位置：

这就是循环队列（也成为缓冲环）。虽然在存储上是线形的，但是在逻辑上它是一个首尾衔接的环形

public class Queue {
    
    private int [] queArray;
    private int maxSize;
    public int front;   //存储队头元素的下标
    public int rear;    //存储队尾元素的下标
    private int length; //队列长度
    
    //构造方法，初始化队列
    public Queue(int maxSize){
        this.maxSize = maxSize;
        queArray = new int [maxSize];
        front = 0;
        rear = -1;
        length = 0;
    }
    
    //插入
    public void insert(int elem) throws Exception{
        if(isFull()){
            throw new Exception("队列已满，不能进行插入操作！");
        }
        //如果队尾指针已到达数组的末端，插入到数组的第一个位置
        if(rear == maxSize-1){
            rear = -1;
        }
        queArray[++rear] = elem;
        length++;
    }
    
    //移除
    public int remove()throws Exception{
        if(isEmpty()){
            throw new Exception("队列为空，不能进行移除操作！");
        }
        int elem = queArray[front++];
        //如果队头指针已到达数组末端，则移到数组第一个位置
        if(front == maxSize){
            front = 0;
        }
        length--;
        return elem;
    }
    
    //查看队头元素
    public int peek()throws Exception{
        if(isEmpty()){
            throw new Exception("队列内没有元素！");
        }
        return queArray[front];
    }
    
    //获取队列长度
    public int size(){
        return length;
    }
    
    //判空
    public boolean isEmpty(){
        return (length == 0);
    }
    
    //判满
    public boolean isFull(){
        return (length == maxSize);
    }
    
}

还有一种称为双端队列的数据结构，队列的每一端都可以进行插入和移除操作。

其实双端队列是队列和栈的综合体。如果限制双端队列的一段只能插入，而另一端只能移除，就变成了平常意义上的队列；如果限制双端队列只能在一端进行插入和移除，就变成了栈。

优先级队列

像普通队列一样，优先级队列有一个队头和一个队尾，并且也是从队头移除数据，从队尾插入数据，不同的是，在优先级队列中，数据项按关键字的值排序，数据项插入的时候会按照顺序插入到合适的位置。

除了可以快速访问优先级最高的数据项，优先级队列还应该可以实现相当快的插入，因此，优先级队列通常使用一种称为堆的数据结构来实现。在下例中，简便起见，我们仍然使用数组来实现。

在数据项个数比较少，或不太关心速度的情况下，用数组实现优先级队列还可以满足要求，如果数据项很多，或对速度要求很高，采用堆是更好的选择。

优先级队列的实现跟上面普通队列的实现有很大的区别。

优先级队列的插入本来就需要移动元素来找到应该插入的位置，所以循环队列那种不需要移动元素的优势就不太明显了。在下例中，没有设置队头和队尾指针，而是使数组的第一个元素永远是队尾，数组的最后一个元素永远是队头，为什么不是相反的呢？因为队头有移除操作，所以将队头放在数组的末端，便于移除，如果放在首段，每次移除队头都需要将队列向前移动。

插入元素示意图：
在这里插入图片描述
移除元素示意图：

在下例中，我们设置了一个基准点，认为元素到里基准点的距离越近则优先级越高，如设置的基准点为2，3到2的距离就是|3-2|=1，而-1到2的距离是|-1-2|=3，所以3的优先级就比-1要高。

public class PriorityQueue {
    
    private int [] queArray;
    private int maxSize;
    private int length; //队列长度
    private int referencePoint;  //基准点
    
    //构造方法，初始化队列
    public PriorityQueue(int maxSize,int referencePoint){
        this.maxSize = maxSize;
        this.referencePoint = referencePoint;
        queArray = new int [maxSize];
        length = 0;
    }
    
    //插入
    public void insert(int elem) throws Exception{
        if(isFull()){
            throw new Exception("队列已满，不能进行插入操作！");
        }
        
        //如果队列为空，插入到数组的第一个位置
        if(length == 0){
            queArray[length++] = elem;
        }else{
            int i;
            for(i=length;i>0;i--){
                
                int dis = Math.abs(elem-referencePoint);  //待插入元素的距离
                int curDis = Math.abs(queArray[i-1]-referencePoint);  //当前元素的距离
                
                //将比插入元素优先级高的元素后移一位
                if(dis >= curDis){
                    queArray[i] = queArray[i-1];
                }else{
                    break;
                }
            }
            queArray[i] = elem;
            length++;
        }
    }
    
    //移除
    public int remove()throws Exception{
        if(isEmpty()){
            throw new Exception("队列为空，不能进行移除操作！");
        }
        int elem = queArray[--length];
        return elem;
    }
    
    //查看队头元素
    public int peek()throws Exception{
        if(isEmpty()){
            throw new Exception("队列内没有元素！");
        }
        return queArray[length-1];
    }
    
    //返回队列长度
    public int size(){
        return length;
    }
    
    //判空
    public boolean isEmpty(){
        return (length == 0);
    }
    
    //判满
    public boolean isFull(){
        return (length == maxSize);
    }
    
}

Damon_zqt

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
数据结构与算法（三）栈和队列

栈概述数组、链表、树等数据结构适用于存储数据库应用中的数据记录，它们常常用于记录那些现实世界的对象和活动的数据，便于数据的访问：插入、删除和查找特定数据项。而栈和队列更多的是作为程序员的工具来使用。他们主要作为构思算法的辅助工具，而不是完全的数据存储工具。这些数据结构的生命周期比那些数据库类型的结构要短很多。在程序操作执行期间它们才被创建，通常它们去执行某项特殊的任务，当任务完成后就被销毁。...
复制链接

扫一扫

专栏目录