前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >如果让你手写个栈和队列,你还会写吗?

如果让你手写个栈和队列,你还会写吗?

作者头像
Java团长
发布2019-07-01 16:12:12
7280
发布2019-07-01 16:12:12
举报
文章被收录于专栏:微信公众号:Java团长

来源:程序员私房菜(ID:eson_15)

昨天跟一个CSDN上的朋友聊天,他说现在如果让他自己手写一个栈或者队列,估计都要写蛮久的,平时虽然都在用,但是都是别人封装好的集合。

确实,经典的数据结构,包括排序算法,虽然我们平时不用手写了,但是这些内功,作为开发人员来说是必须要掌握的。受此启发,我打算更一下经典数据结构和算法的系列文章。今天先从栈和队列说起。

这些东西,挤地铁时,吃饭排队时,等公交时,可以拿来看看,或者,就把它当作个下午茶吧~

我们知道,在数组中,若知道数据项的下标,便可立即访问该数据项,或者通过顺序搜索数据项,访问到数组中的各个数据项。但是栈和队列不同,它们的访问是受限制的,即在特定时刻只有一个数据项可以被读取或者被删除。众所周知,栈是先进后出,只能访问栈顶的数据,队列是先进先出,只能访问头部数据。这里不再赘述。

栈的主要机制可以用数组来实现,也可以用链表来实现,下面用数组来实现栈的基本操作:

代码语言:javascript
复制
class ArrayStack {
    private long[] a;
    private int size; //栈数组的大小
    private int top; //栈顶

    public ArrayStack(int maxSize) {
        this.size = maxSize;
        this.a = new long[size];
        this.top = -1; //表示空栈
    }

    public void push(long value) {//入栈
        if(isFull()) {
            System.out.println("栈已满!");
            return;
        }
        a[++top] = value;
    }

    public long peek() {//返回栈顶内容,但不删除
        if(isEmpty()) {
            System.out.println("栈中没有数据");
            return 0;
        }
        return a[top];
    }

    public long pop() { //弹出栈顶内容,删除
        if(isEmpty()) {
            System.out.println("栈中没有数据!");
            return 0;
        }
        return a[top--];        
    }

    public int size() {
        return top + 1;
    }

    public boolean isEmpty() {
        return (top == -1);
    }

    public boolean isFull() {
        return (top == size -1);
    }

    public void display() {
        for(int i = top; i >= 0; i--) {
            System.out.print(a[i] + " ");
        }
        System.out.println("");
    }
}

数据项入栈和出栈的时间复杂度均为O(1)。这也就是说,栈操作所消耗的时间不依赖于栈中数据项的个数,因此操作时间很短。栈不需要比较和移动操作。

队列也可以用数组来实现,不过这里有个问题,当数组下标满了后就不能再添加了,但是数组前面由于已经删除队列头的数据了,导致空。所以队列我们可以用循环数组来实现,见下面的代码:

代码语言:javascript
复制
public class RoundQueue {
    private long[] a;
    private int size;   //数组大小
    private int nItems; //实际存储数量
    private int front;  //头
    private int rear;   //尾

    public RoundQueue(int maxSize) {
        this.size = maxSize;
        a = new long[size];
        front = 0;
        rear = -1;
        nItems = 0;
    }

    public void insert(long value) {
        if(isFull()){
            System.out.println("队列已满");
            return;
        }
        rear = ++rear % size;
        a[rear] = value; //尾指针满了就循环到0处,这句相当于下面注释内容      
        nItems++;
/*        if(rear == size-1){
            rear = -1;
        }
        a[++rear] = value;
*/
    }

    public long remove() {
        if(isEmpty()) {
            System.out.println("队列为空!");
            return 0;
        }
        nItems--;
        front = front % size;
        return a[front++];
    }

    public void display() {
        if(isEmpty()) {
            System.out.println("队列为空!");
            return;
        }
        int item = front;
        for(int i = 0; i < nItems; i++) {
            System.out.print(a[item++ % size] + " ");
        }
        System.out.println("");
    }

    public long peek() {
        if(isEmpty()) {
            System.out.println("队列为空!");
            return 0;
        }
        return a[front];
    }

    public boolean isFull() {
        return (nItems == size);
    }

    public boolean isEmpty() {
        return (nItems == 0);
    }

    public int size() {
        return nItems;
    }
}

和栈一样,队列中插入数据项和删除数据项的时间复杂度均为O(1)。

还有个优先级队列,优先级队列是比栈和队列更专用的数据结构。优先级队列与上面普通的队列相比,主要区别在于队列中的元素是有序的,关键字最小(或者最大)的数据项总在队头。数据项插入的时候会按照顺序插入到合适的位置以确保队列的顺序。优先级队列的内部实现可以用数组或者一种特别的树——堆来实现。

代码语言:javascript
复制
public class PriorityQueue {
    private long[] a;
    private int size;
    private int nItems;//元素个数

    public PriorityQueue(int maxSize) {
        size = maxSize;
        nItems = 0;
        a = new long[size];
    }

    public void insert(long value) {
        if(isFull()){
            System.out.println("队列已满!");
            return;
        }
        int j;
        if(nItems == 0) { //空队列直接添加
            a[nItems++] = value;
        }
        else{//将数组中的数字依照下标按照从大到小排列
            for(j = nItems-1; j >= 0; j--) {
                if(value > a[j]){
                    a[j+1] = a[j];
                }
                else {
                    break;
                }
            }
            a[j+1] = value;
            nItems++;
        }
    }

    public long remove() {
        if(isEmpty()){
            System.out.println("队列为空!");
            return 0;
        }
        return a[--nItems];
    }

    public long peekMin() {
        return a[nItems-1];
    }

    public boolean isFull() {
        return (nItems == size);
    }

    public boolean isEmpty() {
        return (nItems == 0);
    }

    public int size() {
        return nItems;
    }

    public void display() {
        for(int i = nItems-1; i >= 0; i--) {
            System.out.print(a[i] + " ");
        }
        System.out.println(" ");
    }
}

这里实现的优先级队列中,插入操作需要 O(N) 的时间,而删除操作则需要 O(1) 的时间。

(完)

本文参与 腾讯云自媒体同步曝光计划,分享自微信公众号。
原始发表:2019-01-05,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 Java团长 微信公众号,前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档