队列和堆栈的实现

队列的堆栈的元素移动

import java.awt.List;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Stack;

public class stackQueue {  
 
    public static void main(String[] args) {  
        System.out.println("--------------------堆栈--------------------");  
        MyStack<Integer> stack = new MyStack<Integer>();
    
        System.out.println("刚创建堆栈时,stack.isEmpty():" + stack.isEmpty() +",stack.size():" + stack.size());  
        stack.push(1);  
        stack.push(2);  
        stack.push(3);  
        System.out.println("push 3个元素时,栈内元素个数为" + stack.size() + ",元素转化成字符串后为:" + stack.toString());  
        stack.pop();  
        stack.pop();  
        System.out.println("弹出2个元素后,栈内剩余的元素个数为" + stack.size() +  ",元素转化成字符串后为:" + stack.toString());  
 
        System.out.println("--------------------队列开始--------------------");  
        MyQueue<Integer> queue = new MyQueue<Integer>(5);  
        System.out.println("刚创建堆栈时,queue.isEmpty():" + queue.isEmpty() +",queue.isFull():"+queue.isFull()+ ",queue.size():" + queue.size());  
        for (int i = 0; i < 3; i++) {  
            queue.add(i);  
        }  
        System.out.println("添加3个元素:");  
        System.out.println("队列头元素为:"+queue.getHead()+",队尾元素为:"+queue.getTail()+",队列长度为:"+queue.size());  
        System.out.println(queue);  
        System.out.println("去掉2个元素:");//去掉元素,元素只是不能访问到了,被去掉的元素可以被添加的覆盖  
        queue.remove();
        queue.remove();
        
        System.out.println("队列头元素为:"+queue.getHead()+",队尾元素为:"+queue.getTail()+",队列长度为:"+queue.size());  
        queue.add(7);
        System.out.println(queue);  
        for (int i = 3; i < 6; i++) {  
            queue.add(i);  
        }  
        System.out.println("添加4个元素:");//此时尾指又要从开始处添加元素,remove掉的被覆盖  
        System.out.println("队列头元素为:"+queue.getHead()+",队尾元素为:"+queue.getTail()+",队列长度为:"+queue.size());  
        System.out.println(queue);  
          
        System.out.println("去掉4个元素:");//此时尾指又要从开始处添加元素  
        queue.remove();queue.remove();queue.remove();queue.remove();  
        System.out.println("queue.getHead():"+queue.getHead()+",queue.getTail():"+queue.getTail()+",queue.size():"+queue.size());  
        System.out.println(queue);  
    }  
 
}  
 
class MyStack<E> {  
    private ArrayList<E> list;  
 
    public MyStack() {  
        list = new ArrayList<E>();  
    }  
 
    /**
     * 栈是否为空
     *  
     * @return
     */  
    public boolean isEmpty() {  
        return list.size() == 0;  
    }  
 
    /**
     * 栈内容长度
     *  
     * @return
     */  
    public int size() {  
        return list.size();  
    }  
 
    /**
     * 添加元素
     *  
     * @param e
     */  
    public void push(E e) {  
        list.add(e);
     
    }  
 
    /**
     * 弹出元素
     *  
     * @return
     */  
    public E pop() {  
        if (list.size() > 0) {  
            return list.remove(list.size() - 1);  
        }  
        return null;  
    }  
 
    @Override  
    public String toString() {  
        return Arrays.toString(list.toArray());  
    }  
}  
 
class MyQueue<E> {  
    private int maxSize;// 队列容量  
    private E queue[];// 队列  
    private int head;// 头指针  
    private int tail;// 尾指针  
    private int nItems;// 元素个数  
 
    @SuppressWarnings("unchecked")  
    public MyQueue(int maxSize) {  
        this.maxSize = maxSize;  
        this.queue = (E[]) new Object[maxSize];  
        this.head = 0;// 移除元素一般从下标0开始,头指针指向待移除的元素(也就是移除元素的下标)  
        this.tail = -1;// 一般设为-1,当添加元素后,尾指针数值为当前已经添加的元素的下标位置  
        this.nItems = 0;  
    }  
 
    /**
     * 队列是否为空
     *  
     * @return
     */  
    public boolean isEmpty() {  
        return nItems == 0;  
    }  
 
    /**
     * 队列是否已满
     *  
     * @return
     */  
    public boolean isFull() {  
        return nItems == queue.length;  
    }  
 
    /**
     * 添加从队尾开始
     *  
     * @param e
     */  
    public void add(E e) {  
        if (isFull()) {  
            throw new RuntimeException("队列已满");  
        }  
        // 当队尾指针已经到达数组的末尾,但数组却未填满(数组前面有空缺),此时又从起始位置添加元素  
        if (tail == maxSize - 1) {  
            tail = -1;  
        }  
        queue[++tail] = e;  
        nItems++;  
    }  
 
    /**
     * 删除从对头开始
     *  
     * @return
     */  
    public E remove() {  
        if (isEmpty()) {  
            throw new RuntimeException("队列已空");  
        }  
        // 当对头指针到达数组末尾,但数组个数却不为空(说明数组前面还有元素),此时又从起始位置删除元素  
        if (head == maxSize) {  
            head = 0;  
        }  
        nItems--;  
        return queue[head++];  
    }  
 
    /**
     * 获取对头元素
     *  
     * @return
     */  
    public E getHead() {  
        return queue[head];  
    }  
 
    /**
     * 获取队尾元素
     *  
     * @return
     */  
    public E getTail() {  
        return queue[tail];  
    }  
 
    /**
     * 队列元素个数
     *  
     * @return
     */  
    public int size() {  
        return nItems;  
    }  
 
    @Override  
    public String toString() {  
        return Arrays.toString(queue);  
    }  
 
}

运行结果:

时间: 2024-10-08 10:08:04

队列和堆栈的实现的相关文章

js里实现队列与堆栈

在面向对象的程序设计里,一般都提供了实现队列(queue)和堆栈(stack)的方法,而对于JS来说,我们可以实现数组的相关操作,来实现队列和堆栈的功能,看下面的相关介绍. 一 看一下它们的性质,这种性质决定了它们的使用场合 队列:是一种支持先进先出(FIFO)的集合,即先被插入的数据,先被取出! 堆栈:是一种支持后进先出(LIFO)的集合,即后被插入的数据,先被取出! 二 看一下实现的代码(JS代码) var a=new Array(); a.unshift(1); a.unshift(2);

队列和堆栈的区别

如题,队列和堆栈的区别 首先这个问题是非常具有歧义的.堆栈其实是堆和栈,都是内存的不同区域. 那么这里的堆栈,应该不是指内存,而是java.util.Stack<E>(类).应该称之为栈.之所以叫堆栈,应该是某些人的理解问题. 这里的队列,应该是java.util.Queue(接口) 就是说,java集合中的两种数据结构的对比. 一句话形容其区别,就是: 队列是FIFO的(先进先出): 堆栈式FILO的(现今后出): 以上. 队列和堆栈的区别,布布扣,bubuko.com

普通集合和泛型集合的区别,哈希表和字典表的区别,队列和堆栈的区别以及堆和栈的区别。

普通集合和泛型集合的区别: 泛型集合与传统集合相比 类型更安全. 泛型集合无需装箱拆箱操作. 泛型的重要性. 泛型是未来五年的主流技术 ... 通常情况下,建议您使用泛型集合,因为这样可以获得类型安全的直接优点而不需要从基集合类型派生并实现类型特定的成员.此外,如果集合元素为值类型,泛型集合类型的性能通常优于对应的非泛型集合类型(并优于从非泛型基集合类型派生的类型),因为使用泛型时不必对元素进行装箱. 下面的泛型类型对应于现有的集合类型: List 是对应于 ArrayList 的泛型类. Di

JavaScript实现数据结构中的队列和堆栈

今天在项目中要使用JavaScript实现数据结构中的队列和堆栈,这里做一下总结. 一.队列和堆栈的简单介绍 1.1.队列的基本概念 队列:是一种支持先进先出(FIFO)的集合,即先被插入的数据,先被取出! 如下图所示: 1.2.堆栈的基本概念 堆栈:是一种支持后进先出(LIFO)的集合,即后被插入的数据,先被取出! 如下图所示: 二. 在JavaScript中实现队列和堆栈 在JavaScript中实现队列和数组主要是通过数组,js数组中提供了以下几个方法可以让我们很方便实现队列和堆栈: sh

JavaScript的数组实现队列与堆栈的方法

JavaScript的数组实现队列与堆栈的方法 今天在项目中要使用JavaScript实现数据结构中的队列和堆栈,这里做一下总结. 一.队列和堆栈的简单介绍 1.1.队列的基本概念 队列:是一种支持先进先出(FIFO)的集合,即先被插入的数据,先被取出! 如下图所示: 1.2.堆栈的基本概念 堆栈:是一种支持后进先出(LIFO)的集合,即后被插入的数据,先被取出! 如下图所示: 二. 在JavaScript中实现队列和堆栈 在JavaScript中实现队列和数组主要是通过数组,js数组中提供了以

使用JavaScript的数组实现数据结构中的队列与堆栈

今天在项目中要使用JavaScript实现数据结构中的队列和堆栈,这里做一下总结. 一.队列和堆栈的简单介绍 1.1.队列的基本概念 队列:是一种支持先进先出(FIFO)的集合,即先被插入的数据,先被取出! 如下图所示: 1.2.堆栈的基本概念 堆栈:是一种支持后进先出(LIFO)的集合,即后被插入的数据,先被取出! 如下图所示: 二. 在JavaScript中实现队列和堆栈 在JavaScript中实现队列和数组主要是通过数组,js数组中提供了以下几个方法可以让我们很方便实现队列和堆栈: sh

JS~js里实现队列与堆栈

在面向对象的程序设计里,一般都提供了实现队列(queue)和堆栈(stack)的方法,而对于JS来说,我们可以实现数组的相关操作,来实现队列和堆栈的功能,看下面的相关介绍. 一 看一下它们的性质,这种性质决定了它们的使用场合 队列:是一种支持先进先出(FIFO)的集合,即先被插入的数据,先被取出! 堆栈:是一种支持后进先出(LIFO)的集合,即后被插入的数据,先被取出! 二 看一下实现的代码(JS代码) var a=new Array(); a.unshift(1); a.unshift(2);

JavaScript学习总结(二十一)——使用JavaScript的数组实现数据结构中的队列与堆栈

今天在项目中要使用JavaScript实现数据结构中的队列和堆栈,这里做一下总结. 一.队列和堆栈的简单介绍 1.1.队列的基本概念 队列:是一种支持先进先出(FIFO)的集合,即先被插入的数据,先被取出! 如下图所示: 1.2.堆栈的基本概念 堆栈:是一种支持后进先出(LIFO)的集合,即后被插入的数据,先被取出! 如下图所示: 二. 在JavaScript中实现队列和堆栈 在JavaScript中实现队列和数组主要是通过数组,js数组中提供了以下几个方法可以让我们很方便实现队列和堆栈: sh

C#泛型集合之——队列与堆栈

队列与堆栈基础 队列 1.操作: (1)创建及初始化: Queue<类型> 队列名 =new Queue<类型>()://空队列,无元素 Queue<类型> 队列名 =new Queue<类型>(数组名): Queue<类型> 队列名 =new Queue<类型>(){值} //队列未包含Add定义.这样是不行的!!! (2)出入队: 入队:队列名.Enqueue(值); 出队:队列名.Dequeue(); //返回是队列类型的首元素