基于链表实现Java 自定义Stack队列

接下来让我们看看,如何利用单链表结构来实现栈与队列。由于栈的操作只限于栈顶元素,而单链表只有对首元素才能在O(1)时间内完成插入和删除,故这里把单链表的首节点作为栈顶,其余元素依次排列。此外,为了保证getSize()方法也能够在O(1)时间内完成,还需借助一个实例变量来动态记录栈中元素的数目。具体的实现如 代码二.12 所示。

Node类 Java代码见( Java 实现链表

StackLink 类:

package com.list.stack;

import java.util.Arrays;

import com.stack.ExceptionStackEmpty;
import com.list.stack.Node;

public class StackList {

    //Declared size of stack list
    private static int size;
    //Declared element
    private static Node top;
    public StackList() {
        this.size = 0;
        this.top = null;
    }

    // Get the size of stack
    public int getSize() {
        if(isEmpty())
            return 0;
        else
            return size;
    }

    // Get whether stack is empty
    public boolean isEmpty() {
        return size == 0;
    }

    // Get the top element of stack
    public Object top() throws ExceptionStackEmpty {
        if(isEmpty())
            throw new ExceptionStackEmpty("Stack is empty!");
        return top.getElement();
    }

    // Push element to stack
    public void push(Object element){
        Node newNode = new Node(element,top);
        top = newNode;
        size ++;
    }

    // Pop element from stack
    public Object pop() throws ExceptionStackEmpty {
        if(isEmpty())
            throw new ExceptionStackEmpty("Stack is empty!");
        Object container = top.getElement();
        top = top.getNext();
        size --;
        return container;
    }

    // Get the all elements of stack
    public void getAllElements() throws ExceptionStackEmpty {
        Node travelTop;
        travelTop = top;
        Object[] array = new Object[getSize()];

        for(int i = 0;i < array.length;i ++ ){
            array[i] = travelTop.getElement();
            travelTop = travelTop.getNext();
        }
        System.out.println("Get all elemnt: " + Arrays.toString(array));
    }
}

StackLinkTest 类:

package com.list.stack;

import com.stack.ExceptionStackEmpty;

public class StackListTest {

    public static void main(String[] args) throws ExceptionStackEmpty {

        //Test Class StackList
        StackList sl = new StackList();
        System.out.println("Size of stack list: " + sl.getSize());
        System.out.println("Is emplty? : " + sl.isEmpty());
        sl.push(12);
        sl.push(13);
        sl.push(15);
        sl.push(17);
        sl.push(2);
        sl.push(6);
        sl.getAllElements();
        System.out.println("Size of stack list: " + sl.getSize());
        System.out.println("Is emplty? : " + sl.isEmpty());
        //sl.getAllElements();
        System.out.println(sl.pop());
        System.out.println(sl.pop());
        System.out.println(sl.pop());
        System.out.println(sl.pop());
        System.out.println(sl.pop());
        System.out.println(sl.pop());
        System.out.println("Size of stack list: " + sl.getSize());
        System.out.println("Is emplty? : " + sl.isEmpty());

    }

}

测试结果:

Size of stack list: 0
Is emplty? : true
Get all elemnt: [6, 2, 17, 15, 13, 12]
Size of stack list: 6
Is emplty? : false
6
2
17
15
13
12
Size of stack list: 0
Is emplty? : true

转载请注明出处,谢谢!

http://blog.csdn.net/github_27609763/article/details/46476917

时间: 2024-10-02 20:54:18

基于链表实现Java 自定义Stack队列的相关文章

基于链表实现Java 自定义Queue队列

与栈一样,我们也可以借助单链表来实现队列ADT.同样地,出于效率方面的考虑,我们将以单链表的首(末)节点作为队列的首(末)节点??这样,可以回避单链表在尾部进行删除操作时效率低下的缺陷.此外,还需要两个实例变量分别指示表的首.末节点. java代码如下: QueueList: package com.list.queue; import java.util.Arrays; import com.list.stack.Node; import com.list.stack.ExceptionSta

基于数组实现Java 自定义Queue队列及应用

Java 自定义队列Queue: 队列的抽象数据类型就是一个容器,其中的对象排成一个序列,我们只能访问和取出排在最前端( Front)的对象,只能在队列的尾部( Rear)插入新对象.正是按照这一规则,才能保证最先被插入的对象首先被删除( FIFO).java本身是有自带Queue类包,为了达到学习目的已经更好深入了解Queue队列,自己动手自建java Queue类是个很好的学习开始: 基于数组的实现 ? 顺序数组 借助一个定长数组 Q 来存放对象,即可简单地实现队列.那么,为了符合 FIFO

基于数组实现Java 自定义Stack栈类及应用

栈是存放对象的一种特殊容器,在插入与删除对象时,这种结构遵循后进先出( Last-in-first-out,LIFO)的原则.java本身是有自带Stack类包,为了达到学习目的已经更好深入了解stack栈,自己动手自建java stack类是个很好的学习开始: 自建Java Stack 类 Stack 类: 1 package com.stack; 2 3 import java.util.ArrayList; 4 import java.util.Arrays; 5 6 /** 7 * St

Java 自定义Stack栈类及应用

栈是存放对象的一种特殊容器,在插入与删除对象时,这种结构遵循后进先出( Last-in-first-out,LIFO)的原则.java本身是有自带Stack类包,为了达到学习目的已经更好深入了解stack栈,自己动手自建java stack类是个很好的学习开始: 自建Java Stack 类 Stack 类: package com.stack; import java.util.ArrayList; import java.util.Arrays; /** * Stack Class * @a

java 多线程阻塞队列 与 阻塞方法与和非阻塞方法

Queue是什么 队列,是一种数据结构.除了优先级队列和LIFO队列外,队列都是以FIFO(先进先出)的方式对各个元素进行排序的.无论使用哪种排序方式,队列的头都是调用remove()或poll()移除元素的.在FIFO队列中,所有新元素都插入队列的末尾.队列都是线程安全的,内部已经实现安全措施,不用我们担心 Queue中的方法 Queue中的方法不难理解,6个,每2对是一个也就是总共3对.看一下JDK API就知道了: 注意一点就好,Queue通常不允许插入Null,尽管某些实现(比如Link

Java中的自定义数组队列

在Java中,作为所有数据结构中存储和获取速度最快的一种,数组凭借其这种简单易用的优势在各个方面都能大显神威.但是数组也有自身的局限性.数组的长度必须是固定的一旦定义之后就无法动态的更改,这就会造成这样的问题,如果数组已满,就无法继续添加数据(当然你可以定义一个"足够大的数组",但问题是多大才是足够大呢?太小不够,太大浪费内存空间).如果删除一个数据,它的内存空间空着没有被使用.另外数组只能存储同一类型的数据,如果把它设置成Object类型的话,是可以存不同类型的数据了,但是设想这样一

数据结构 - 基于链表的队列

基于链表的队列 当我们基于链表实现队列时,需要从一端加元素,另一端取出元素,就需要引入一个新的变量tail指向链表的尾部,此时,向尾部进行添加操作时间复杂度会变为O(1),然而删除操作还是需要从head向后遍历,所以此时选择链表尾为队尾,链表头为队首. 基于链表的实现的源码如下: package queue; import linkedList.LinkedList; public class LinkedListQueue<E> implements Queue<E> {    

数据结构之链表及其Java实现

数据的存储一般分线性存储结构和链式存储结构两种.前者是一种顺序的存储方式,在内存中用一块连续的内存空间存储数据,即逻辑上相连的物理位置相邻,比较常见的就是数组:后者是一种链式存储方式,不保证顺序性,逻辑上相邻的元素之间用指针所指定,它不是用一块连续的内存存储,逻辑上相连的物理位置不一定相邻.本篇主要介绍链式存储结构基于链表的实现,使用的语言为Java. 链表是一种递归的数据结构,它要么为空(null),要么指向是指向一个结点(node)的引用,该节点含有一个泛型元素(该泛型元素可以是任意数据类型

Java中阻塞队列的使用

http://blog.csdn.net/qq_35101189/article/details/56008342 在新增的Concurrent包中,BlockingQueue很好的解决了多线程中,如何高效安全“传输”数据的问题.通过这些高效并且线程安全的队列类,为我们快速搭建高质量的多线程程序带来极大的便利.本文详细介绍了BlockingQueue家庭中的所有成员,包括他们各自的功能以及常见使用场景. 认识BlockingQueue阻塞队列,顾名思义,首先它是一个队列,而一个队列在数据结构中所