Java数据结构--------堆栈和队列-蒲公英云

本章相关介绍：

堆栈和队列都是特殊的线性表。线性表、堆栈和队列三者的数据元素以及数据元素间的逻辑关系完全相同，差别是线性表的插入和删除操作不受限制，而堆栈只能在栈顶插入和删除，队列只能在队尾插入，在队头删除。堆栈和队列都可以分别用顺序存储结构和链式存储结构存储。顺序队列通常采用顺序循环队列方法实现，因为顺序循环队列可以避免顺序队列的“假溢出”问题。优先队列是带有优先级的队列。

堆栈

堆栈（也称为栈）是一种特殊的线性表。堆栈的数据元素以及数据元素之间的逻辑关系和线性表完全相同，其差别是线性表允许在任意位置进行插入和删除操作，而堆栈只允许在固定的一端进行插入和删除操作。

堆栈中允许进行插入和删除的一端称为栈顶，另一端称为栈底。堆栈的插入操通常称为进栈或入栈，堆栈的删除操作通常称为出栈或退栈。

根据栈的定义，每次进栈的数据元素都放在原当前栈顶元素之前而成为新的栈顶元素，每次退栈的数据元素都是当前栈顶元素，这样，最后进入堆栈的数据元素总是最先退出堆栈，因此，堆栈也称为后进先出表。

堆栈的抽象数据类型

1、堆栈的数据集合可以表示为a1,a2,a3,a4,a5，每个数据元素的数据类型是任意的类类型。

2、操作集合：

1、入栈操作

2、出栈操作

3、取出栈顶数据元素

4、判断堆栈是否为空

相关源代码：

接口对象

package com.algorithm;
//堆栈接口对象
public interface StackExample {
    //入栈操作
    public boolean push(Object object);
    //出栈操作
    public Object pop();
    //栈顶元素
    public Object getTop();
    //堆栈是否为空
    public boolean isEmpty();
}

实列化类：

package com.algorithm;
public class StackInstantiation implements StackExample {
    //默认栈顶的位置
    final int defaultSize=10;
    //栈标记
    int top;
    //堆栈数组
    Object[] stack;
    //堆栈元素个数
    int maxSize;
    //相关的构造函数和方法
    public void initiate(int size){
        maxSize=size;
        top=0;
        stack=new Object[size];
    }    
    public StackInstantiation() {
        initiate(defaultSize);
    }
    public StackInstantiation(int sz) {
        initiate(sz);
    }
    @Override
    public Object getTop() {
        // TODO Auto-generated method stub
        Object object=null;
        if(top==0){
             object="404";            
        }else{
            object=stack[top-1];
        }
        return object;
    }
    @Override
    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return (top>0);
    }
    @Override
    public Object pop() {
        // TODO Auto-generated method stub
        Object object=null;
        if(top==0){
            object="404";
        }else{
            top--;
            object=stack[top];
        }
        return object;
    }
    @Override
    public boolean push(Object object) {
        // TODO Auto-generated method stub
        boolean target=false;
        if(top==maxSize){
            return target;
        }else{
            target=true;
            stack[top]=object;
            top++;
            return target;
        }
    }
}

实例化方法

package com.algorithm;
public class StackTest {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        StackInstantiation stack=new StackInstantiation();
         //判断堆栈是否为空
        boolean target=stack.isEmpty();
        System.out.println("堆栈是否为空："+target);
        //堆栈元素添加
        stack.push("c");
        stack.push("c++");
        stack.push("c#");
        stack.push("java");
        stack.push("object-c");
        stack.push("php");
        stack.push("ruby");
        //堆栈元素添加再次判断堆栈是否为空
        boolean targets=stack.isEmpty();
        System.out.println("堆栈是否为空："+targets);
        //获取栈顶元素
        Object object=stack.getTop();
        System.out.println("栈顶元素为:"+object);
        //堆栈元素出栈
        Object objects=stack.pop();
        System.out.println("移除栈顶元素为："+objects);
        //再次获取栈顶元素
        Object objects1=stack.getTop();
        System.out.println("再次获得的栈顶元素为："+objects1);
    }
}

结果展示：

Center

堆栈———-链式存储结构

源代码：

结点接口

package com.algorithm;
public interface StackNode {
    //获取结点数据域
     public Object getData();
     //设置结点数据域 
     public void setData(Object obj);
}

堆栈操作接口

package com.algorithm;
//堆栈接口对象
public interface StackExample {
    //入栈操作
    public boolean push(Object object);
    //出栈操作
    public Object pop();
    //栈顶元素
    public Object getTop();
    //堆栈是否为空
    public boolean isEmpty();
}

结点接口实例化对象

package com.algorithm;
public class SLNode implements StackNode {
    private Object element; // 数据成员
    private SLNode next; // 指向下一个成员结点
    // 两个构造器
    public SLNode() {
        this(null, null);
    }
    public SLNode(Object obj, SLNode nextnode) {
        this.element = obj;
        this.next = nextnode;
    }
    public Object getElement() {
        return element;
    }
    public void setElement(Object element) {
        this.element = element;
    }
    public SLNode getNext() {
        return next;
    }
    public void setNext(SLNode next) {
        this.next = next;
    }
    public void setData(Object obj) {
        element = obj;
    }
    public Object getData() {
        return element;
    }
}

核心代码：

package com.algorithm;
//堆栈-----链式存储结构
public class StackLinked implements StackExample {
    // 相关属性和方法
    private SLNode top; // 链表首结点引用
    private int size; // 栈的大小
    // 相关构造函数
    public StackLinked() {
        top = null;
        size = 0;
    }
    // 返回堆栈的大小
    public int getSize() {
        return size;
    }
    // 栈顶元素
    @Override
    public Object getTop() {
        // TODO Auto-generated method stub
        Object object = null;
        if (size < 1) {
            object = "404";
            return object;
        } else {
            object = top.getData();
            return object;
        }
    }
    // 判断栈顶是否为空
    @Override
    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return size == 0;
    }
    // 元素出栈
    @Override
    public Object pop() {
        // TODO Auto-generated method stub
        Object object = null;
        if (size < 1) {
            object = "404";
            return object;
        } else {
            object = top.getData();
            top = top.getNext();
            size--;
            return object;
        }
    }
    // 数据元素object入栈
    @Override
    public boolean push(Object object) {
        // TODO Auto-generated method stub
        SLNode q = new SLNode(object, top);
        top = q;
        size++;
        return true;
    }
}

演示结构：

package com.algorithm;
public class StackTest {
    /**
     * @param args
     */
    public static void main(String[] args) {        
        StackLinked linked=new StackLinked();
        //判断堆栈是否为空
        boolean target=linked.isEmpty();
        System.out.println("堆栈是否为空："+target);
        //堆栈元素添加
        linked.push("c");
        linked.push("c++");
        linked.push("c#");
        linked.push("object-c");
        linked.push("java");
        linked.push("php");
        linked.push("ruby");
        //堆栈元素添加再次判断堆栈是否为空
        boolean targets=linked.isEmpty();
        System.out.println("堆栈是否为空："+targets);
        //获取栈顶元素
        Object object=linked.getTop();
        System.out.println("栈顶元素为:"+object);
        //堆栈元素出栈
         Object objects=linked.pop();
        System.out.println("移除栈顶元素为："+objects);
        //堆栈数据元素个数
        int size=linked.getSize();
        System.out.println("堆栈元素个数为："+size);
        //再次获取栈顶元素
        Object objects1=linked.getTop();
        System.out.println("再次获得的栈顶元素为："+objects1);
    }
}