java面向对象的栈 队列 优先级队列的比较

　　栈 队列 有序队列数据结构的生命周期比那些数据库类型的结构(比如链表，树)要短得多。在程序操作执行期间他们才被创建，通常用他们去执行某项特殊的任务；当完成任务之后，他们就会被销毁。这三个数据结构还有一个特点就是访问是受到限制的，即在特定时刻只有一个数据项可以被读取或者被删除，但是所谓的移除并不是真的删除，数据项依然在这些数据结构中，只不过因为指针已经指向其他数据项，没有办法访问到，当添加新的数据项时，当初移除的数据项被替代从而永远消失。

栈 队列 优先级队列的模拟思想

　　1.栈：栈遵循先进后出(FILO)模式最后插入的数据项最先被移除，而且只能访问最后的数据项，只有当移除这个数据项之后才能访问倒数第二项的数据项。

　　2.队列：队列遵循先进先出(FIFO)模式首先被插入的数据项最先被移除，而且只能访问访问第一个数据项，只有当移除这个数据项之后才能访问第二项的数据项。特别的为了避免队列不满却不能插入新数据项，可以让队头队尾指针绕回到数组开始的位置，这就是循环队列。

　　3.优先级队列：优先级队列和队列的特性相同有队头和队尾，除此之外在优先级队列中，数据项按关键字的值有序，这样关键字最小的数据项或最大的数据项(视情况而定)总是在队头，数据项插入的时候会按照顺序插入到合适的位置以确保队列的顺序。

栈 队列 优先级队列的效率

　　栈：插入操作需要O(1),删除操作需要O(1)。

　　队列：插入操作需要O(1),删除操作需要O(1)。

　　优先级队列：插入操作需要O(N),删除操作需要O(1)。

栈 队列 优先级队列的指针

　　栈：top= -1。

　　队列：rear = -1， front = 0。

　　优先级队列：nItems = 0。

栈 队列 优先级队列的java代码

栈

package sy;

import sy.Stack;

class Stack{
    //定义栈长度
    private int maxSize;
    //定义栈
    private long[] stackArray;
    //定义栈指针
    private int top;
    //定义构造方法
    public Stack(int n){
        maxSize = n;
        stackArray = new long[maxSize];
        top = -1;
    }
    //定义插入方法
    public void push(long n){
        //栈长度先增加，再向栈中压入数据
        stackArray[++top] = n;
    }
    //定义删除方法
    public long pop(){
        //先向栈中压入数据，栈长度再减少
        return stackArray[top--];
    }
    //定义查找方法
    public long peek(){
        return stackArray[top];
    }
    //定义查空方法
    public boolean isEmpty(){
        return (top == -1);
    }
    //定义查满方法
    public boolean isFull(){
        return (top == maxSize - 1);
    }
}
public class App {
    public static void main(String[] args){
        Stack theStack = new Stack(10);
        theStack.push(20);
        theStack.push(40);
        theStack.push(60);
        theStack.push(80);        

        while(!theStack.isEmpty())
        {
            long value = theStack.pop();
            System.out.print(value);
            System.out.print(" ");

        }
        System.out.println("");
    }
}

队列(带nItems)

package sy;

class Queue{
    //定义队列长度
    private int maxSize;
    //定义队列
    private long[] queArray;
    //定义队首指针
    private int front;
    //定义队尾指针
    private int rear;
    //定义数据项个数
    private int nItems;

    //定义构造方法
    public Queue(int n){
        maxSize = n;
        queArray = new long[maxSize];
        front = 0;
        rear = -1;
        nItems = 0;
    }
    //定义插入方法
    public void insert(long n){
        //判断是否循环至队首
        if(rear == maxSize - 1)
        {
            rear = -1;
        }
        //先自增再赋值
        queArray[++rear] = n;
        nItems++;
    }
    //定义删除方法
    public long remove(){
        //先赋值在自增
        long temp = queArray[front++];
        //判断是否循环至队首
        if(front == maxSize)
        {
            front = 0;
        }
        nItems--;
        return temp;
    }
    //定义查找首项方法
    public long peekFront(){
        return queArray[front];
    }

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

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

    public int size(){
        return nItems;
    }
}

public class App {
    public static void main(String[] args){
        Queue theQueue = new Queue(5);

        theQueue.insert(10);
        theQueue.insert(20);
        theQueue.insert(30);
        theQueue.insert(40);
        theQueue.remove();
        theQueue.remove();
        theQueue.remove();
        theQueue.insert(50);
        theQueue.insert(60);
        theQueue.insert(70);
        theQueue.insert(80);

        while(!theQueue.isEmpty())
        {
            long n = theQueue.remove();
            System.out.print(n);
            System.out.print(" ");

        }
        System.out.print("");

    }
}

注意：insert()和remove方法中分别递增和递减了nItems，当处理大量的插入和移除操作的时候，就会影响性能。

队列(没有nItems)

package sy;

//import aa.Queue;

class Queue{
    //定义队列长度
    private int maxSize;
    //定义队列
    private long[] queArray;
    //定义队首指针
    private int front;
    //定义队尾指针
    private int rear;

    //定义构造方法
    public Queue(int n){
        //这里最大值要加一
        maxSize = n + 1;
        queArray = new long[maxSize];
        front = 0;
        rear = -1;
    }
    //定义插入方法
    public void insert(long n){
        //判断是否循环至队首
        if(rear == maxSize - 1)
        {
            rear = -1;
        }
        //先自增再赋值
        queArray[++rear] = n;
    }
    //定义删除方法
    public long remove(){
        //先赋值在自增
        long temp = queArray[front++];
        //判断是否循环至队首
        if(front == maxSize)
        {
            front = 0;
        }
        return temp;
    }
    //定义查找首项方法
    public long peekFront(){
        return queArray[front];
    }

    public boolean isEmpty(){
        return (rear + 1 == front || (front + maxSize - 1 == rear));
    }

    public boolean isFull(){
        return (rear + 2 == front || (front + maxSize - 2 == rear));
    }
}

public class App {
    public static void main(String[] args){
        Queue theQueue = new Queue(5);

        theQueue.insert(10);
        theQueue.insert(20);
        theQueue.insert(30);
        theQueue.insert(40);
        theQueue.remove();
        theQueue.remove();
        theQueue.remove();
        theQueue.insert(50);
        theQueue.insert(60);
        theQueue.insert(70);
        theQueue.insert(80);

        while(!theQueue.isEmpty())
        {
            long n = theQueue.remove();
            System.out.print(n);
            System.out.print(" ");

        }
        System.out.print("");

    }
}

优先级队列

package aa;

import java.io.IOException;
//在这个队列中小的在后，队列有大到小排列，这里只能访问最后一个数据项
class Priority{
    private int maxSize;
    private long[] queArray;
    private int nItems;

    public Priority(int s){
        maxSize = s;
        queArray = new long[maxSize];
        nItems = 0;
    }

    public void insert(long i){
        //定义一个临时变量
        int j;
        //判断数据项是否为零
        if(nItems == 0)
        {
            //如果为零插入数据，数据项增加
            queArray[nItems++] = i;
        }
        else
        {
            //数据项从后往前遍历，注意j>=0
            for(j = nItems - 1; j >= 0; j--)
            {
                //判断插入项是否大于遍历的数据项
                if(i > queArray[j])
                {
                    //如果大于则从j的数据项开始每一项都后移一位
                    queArray[j+1] = queArray[j];
                }
                else
                {
                    break;
                }
            }
            //在for循环中最后一次循环的最后阶段执行了j--，所以在这里加回来，这样for循环外的j+1相当于for循环内的判断的j
            queArray[j + 1] = i;
            nItems++;
        }
    }

    public long remove(){
        return queArray[--nItems];
    }

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

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

    public boolean isFull(){
        return (nItems == maxSize);
    }
}
public class PriorityApp {
    public static void main(String[] args) throws IOException{
        Priority thePri = new Priority(5);
        thePri.insert(30);
        thePri.insert(50);
        thePri.insert(10);
        thePri.insert(40);
        thePri.insert(20);

        while(!thePri.isEmpty())
        {
            long item = thePri.remove();
            System.out.print(item + " ");
        }
        System.out.println("");
    }
}
时间： 2024-10-28 05:24:25

java面向对象的栈 队列 优先级队列的比较的相关文章

java数据结构与算法值优先级队列

一.优先级队列 什么是优先级队列:优先级队列是一种比栈和队列更加常用的一种数据结构.在优先级队列中,数据项按照关键字的值有序.数据项插入到队列中时,会按照顺序插入到合适的位置,用来保证队列的顺序. 生活中的例子,假设你有若干封件,你最急需要处理的文件就放在所有邮件的 顶部,如果不急需处理的文件就放放在下面. 参考代码: package edu.structure.queue; public class PriorityQ { private int maxSize; private int[]

优先级队列（PriprityQueue）是一种什么样的数据结构

优先级队列(PriprityQueue)是一种无界队列,基于优先级堆,它的元素根据自然顺序或者通过实现Comparator接口的自定义排序方式进行排序.这篇文章,我们将创建一个Items的优先级队列,基于价格排序,优先级队列用来实现迪科斯彻算法(Dijkstra algorithm)非常实用.值得注意的是他的迭代器并不保证有序,如果需要按顺序遍历,最好使用Arrays.sort(pd.toArray())方法.同时它的实现不是同步的,意味着在多线程中不是线程安全的对象,可以取而代之的是Prior

STL学习系列七：优先级队列priority_queue容器

1.简介 最大值优先级队列.最小值优先级队列 优先级队列适配器 STL priority_queue 用来开发一些特殊的应用,请对stl的类库,多做扩展性学习 如果我们给每个元素都分配一个数字来标记其优先级,不妨设较小的数字具有较高的优先级,这样我们就可以在一个集合中访问优先级最高的元素并对其进行查找和删除操作了.这样,我们就引入了优先级队列 这种数据结构. 优先级队列(priority queue) 是0个或多个元素的集合,每个元素都有一个优先权,对优先级队列执行的操作有(1)查找(2)插入一

STL源码笔记（15）—堆和优先级队列（二）

STL源码笔记(15)-堆和优先级队列 优先级队列的源码实现基于heap的操作,底层容器默认是vector. 优先级队列简介 优先级队列跟队列类似,一端插入一端删除,不同的是,优先级队列的元素入队后会根据其优先级进行调整,默认情况下优先级高的将优先出队,在SGI STL中,优先级队列的功能保证由heap实现:stl_heap.h中,heap的分析见:STL堆源码分析 优先级队列构造函数 默认情况下,优先级队列使用vector作为底层容器,使用less作为比较函数,其在源码中的定义声明如下: te

Redis实现优先级队列

实现优先级队列 优先级队列是什么? 优先级队列 是不同于先进先出队列的另一种队列.每次从队列中取出的是具有最高优先权的元素. redis如何实现优先级队列 关键命令:BRPOP(从队列右边弹出)/BLPOP(从队列左边弹出) BRPOP/BLPOP和RPOP/LPOP命令类似,都是从队列里弹出一个元素,只不过BRPOP在队列没有新元素的时候会阻塞,它接受一个timeout参数,用来表示阻塞的时间,当超过该时间还是未获得新元素则会返回nil,如果为0则表示一直阻塞下去.除此之外它还可以接受多个KE

java 集合 Connection 栈 队列 及一些常用

800x600 Normal 0 7.8 磅 0 2 false false false EN-US ZH-CN X-NONE MicrosoftInternetExplorer4 /* Style Definitions */ table.MsoNormalTable {mso-style-name:普通表格; mso-tstyle-rowband-size:0; mso-tstyle-colband-size:0; mso-style-noshow:yes; mso-style-priori

【转】java中PriorityQueue优先级队列使用方法

优先级队列是不同于先进先出队列的另一种队列.每次从队列中取出的是具有最高优先权的元素. PriorityQueue是从JDK1.5开始提供的新的数据结构接口. 如果不提供Comparator的话,优先队列中元素默认按自然顺序排列,也就是数字默认是小的在队列头,字符串则按字典序排列. 由于网上的资料大多将优先级队列各个方法属性,很少有实例讲解的,为方便大家以后使用,我就写了个demo~ 如果想实现按照自己的意愿进行优先级排列的队列的话,需要实现Comparator接口.下面的方法,实现了根据某个变

JAVA优先级队列测试

package code.test; import java.util.Comparator; import java.util.Iterator; import java.util.PriorityQueue; import java.util.Queue; /** * 实验表明,在java中: * 1.优先级队列打印或者迭代,得到的输出顺序为堆结构数组的顺序,大致有序但不完全保证顺序 * 2.由于堆排序是不稳定排序,在优先级相同的情况下,元素不会保持原来的顺序输出 * Created by

Java 模拟队列(一般队列、双端队列、优先级队列)

队列: 先进先出,处理类似排队的问题,先排的.先处理,后排的等前面的处理完了,再处理 对于插入和移除操作的时间复杂度都为O(1).从后面插入,从前面移除 双端队列: 即在队列两端都能够insert和remove:insertLeft.insertRight.removeLeft.removeRight 含有栈和队列的功能,如去掉insertLeft.removeLeft,那就跟栈一样了.如去掉insertLeft.removeRight.那就跟队列一样了 一般使用频率较低,时间复杂度 O(1)