数据结构2——堆栈/队列

前言：之前介绍了线性表，今天来介绍一下堆栈/队列。

1：堆栈主要特点就是只允许固定的一段插入和删除。

采用的是先进后出的方式   如果洗盘子，再比如我们计算机中的递归调用 ，判断字符串是否为回文字符串，利用堆栈来计算算术表达式

　我们只能从栈顶取出元素。而且元素也必须从栈顶进入。

 

同时堆栈又分为：顺序堆栈和链式堆栈

1.1.：顺序堆栈

数据集合：主要是通过数组的形式存储元素。

操作集合：可以定义为一个接口

public interface Stack {
    public void push(Object object);   　　 //进栈
    public Object pop();               　　 //出栈
    public Object getTop();                //获取栈顶的元素
    public boolean notEmpty();            //判断栈是否为空
}

（2）顺序堆栈的具体实现

package com.hone.stack;

public class SeqStack implements Stack{
    final int defaultSize=10;        //默认元素个数
    int top;                        //栈顶位置  
    Object[] stack;                    //数组对象
    int maxStackSize;                //最大数据元素的个数
    
    //创建一个构造方法可以初始化defaultSize
    public SeqStack() {
        initiate(defaultSize);
    }
    
    //创建一个带参数的构造函数，用于
    public SeqStack(int sz){
        initiate(sz);
    }
    //初始化maxStackSize top stack 对象
    private void initiate(int sz) {
        maxStackSize=sz;
        top=0;
        stack=new Object[sz];
    }
    
    /*
     * 进栈
     */
    @Override
    public void push(Object obj) {
        if (top==maxStackSize) {
            System.out.println("堆栈已满！");
        }
        stack[top]=obj;        　　　　//保存刚传进来的元素并且马上建立一个空的栈顶
        top++;                        //产生新栈顶位置（只有栈顶没有元素）　　
    }
    //出栈
    @Override
    public Object pop() {
        if (top==0) {
            System.out.println("堆栈已空");
        }
        top--;                            //产生原来栈顶位置
                　　　　　　　　　　　　　　　//减1的原因（因为这里面加入了一个元素之后都会新开辟一个栈顶，所以无论怎么样都会有一个空的栈顶）
        return stack[top];                //返回原来栈顶的元素
    }
　　//获得栈顶位置的元素
    @Override
    public Object getTop() {
        return stack[top-1];            //返回原栈顶元素
    }
　　//判断栈是否为空
    @Override
    public boolean notEmpty() {
        return (top>0);
    }
}

 1.2：链式节点

首先需要创建节电类，包含元素和下一个结点

/*
 * 整个类使用于封装节点的类，包含两个元素一个是element/next
 */
public class Node {
    Object element;
    public Node next;

    // 定义一个构造函数用于结点
    public Node(Node nextval) {
        next = nextval;
    }

    // 定义一个构造函数用于初始化结点和元素
    public Node(Object o, Node nextval) {
        element = o;
        next = nextval;
    }

    public Object getElement() {
        return element;
    }

    public void setElement(Object element) {
        this.element = element;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }
    
    //将获得的元素转化为String类型
    public String toString(){
        return element.toString();
    }
}

链式栈的实现类：这里面只需要一个head节点就可以了

package com.hone.stack.lin;


import com.hone.stack.Stack;

public class LinStack implements Stack{
    Node head ;                //获得链式堆栈的头节点
    int size;                //结点的个数
    
    //定义一个构造函数用于初始化head结点以及size的大小
     public LinStack() {
         head=null;
         size=0;
    }

     //入栈  从头部开始插入
    @Override
    public void push(Object object) {
        head=new Node(object, head);    
        size++;
    }
    //出栈，从头部开始
    @Override
    public Object pop() {
        if (size==0) {
            System.out.println("堆栈为空");
        }
        Object object=head.getElement();　　　　　　//这里面element行不行呢？
        head=head.next;
        size--;
        return object;
    }
    //获得头部顶端的一个元素
    @Override
    public Object getTop() {
        return head.getElement();                //这里面Element行不行？
    }
    //判断栈是否为空，只需要判断head结点是否为空就可
    @Override
    public boolean notEmpty() {
        return head!=null;
    }

}

 2：队列

队列的主要特点是从一端进，另一端出。队尾入，队头出。因此形成了先进先出的存储模式。

如果将队头和队尾连接起来就成了循环队列。

在队列中必须是队头为head节点，因为只有head节点才有next节点，否则，在出队的时候队尾无法找到rear.next节点

其次，由于顺序队列很容易存在“假溢出”情况 ，因此一般情况下都用顺序循环队列的形式

2.1：顺序循环队列　　　　表现形式任然是数组形式

常用的操作集合：

public interface queue {
    public void append(Object object);        //入队
    public Object delete();                    //出队
    public Object getFront();                //获得队头点的
    public boolean notEmpty();                //判断队列是否为空
}

具体的顺序队列的实现类：

package com.hone.queue;

public class SeqQueue implements queue{
    
    static final int defaultSize=10;
    int front;
    int rear;
    int count;            //元素计数器
    int maxsize;        //数据元素最大的个数
    Object [] data;        //用于保存队列函数
    
    public SeqQueue() {
        initiate(defaultSize);
    }

    private void initiate(int sz) {
        maxsize=sz;
        front=rear=0;
        count=0;
        data=new Object[sz];
    }

    //向一个队列中开始添加元素    入队列
    @Override
    public void append(Object object) {
        if (count>0&&front==rear) {
            System.out.println("队列已满");
        }
        data[rear]=object;
        rear= (rear+1)%maxsize;         //加1取余获得最后队尾的数值
        count++;                    //除以maxsize的原因是循环队列
    }
    
    //出队列
    @Override
    public Object delete() {
        if (count==0) {
            System.out.println("队列已空");
        }
        Object temp=data[front];
        front=(front+1)%maxsize;    //原来的队头+1后求模得到新的队头位置
        count--;
        return temp;
    }
    
    //获得队头的位置
    @Override
    public Object getFront() {
        if (count==0) {
            System.out.println("队列为空！");
        }
        return data[front];
    }

    @Override
    public boolean notEmpty() {
        return count!=0;
    }
    
}

2.2：链式队列的具体实现形式

如前面所说：一个结点都必须包含元素+结点

/*
 * 整个类使用于封装节点的类
 */
public class Node {
    Object element;
    public Node next;

    // 定义一个构造函数用于初始化头结点
    public Node(Node nextval) {
        next = nextval;
    }

    // 定义一个构造函数用于初始化除了头结点以外的节点
    public Node(Object o, Node nextval) {
        element = o;
        next = nextval;
    }

    public Object getElement() {
        return element;
    }

    public void setElement(Object element) {
        this.element = element;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }
    
    //将获得的元素转化为String类型
    public String toString(){
        return element.toString();
    }
}

链式队列的具体实现：

package com.hone.queue.lin;


public class LinQueue implements queue{
    Node rear;                        //获得尾结点
    Node front;                        //获得尾结点
    int count;                        //获得节点的个数
    
    //定义一个函数用于初始化
     private void initiate() {
        rear=null;
        front= null;
        count=0;
    }
     
     public LinQueue() {
        initiate();
    }
     
     public  LinQueue(int sz){
         initiate();
     }
    
    //用链式的方法入队列
    @Override
    public void append(Object object) {
        Node node=new Node(object, null);
        if (rear!=null) {        //如果队尾不为空，则在队尾加上一个新创建的节点
            rear.next=node;        //同时将新创建的节点（包含元素和指针）添加到队尾
            rear=node;
        }
        if (front==null) {
            front=node;
        }
        count++;
    }
    
    //用链式的方法出队列
    @Override
    public Object delete() {
        if (count==0)     System.out.println("队列已空");
        
        Object o=front.getElement();
        front=front.next;
        count--;
        return o;
    }
    
    //获取链式队列的队头位置
    @Override
    public Object getFront() {
        if (count==0) {
            System.out.println("队列已空！");
        }
        return front.getElement();
    }
    
    //判断链式队列是否为空
    @Override
    public boolean notEmpty() {
        return count!=0;
    }
}

2.3：队列同时具有优先级的情况先，将打破了队列  “先入先出” 的原则，优先按照优先级别来处理。

生活中也会分为轻重缓急。

那么此时，队列中各个节点，必须包括优先级别+元素

类似于前面的Node类，这里我们必须加上+ElementPripority类

package com.hone.queue.priority;


//定义element元素的属性，包含pripority和element两个属性
public class ElementPripority {
    private Object element;
    private int pripority;

    // 定义一个构造函数用于初始化element ,pripority
    public ElementPripority(Object o, int p) {
        element = o;
        pripority = p;
    }

    public Object getElement() {
        return element;
    }

    public void setElement(Object element) {
        this.element = element;
    }

    public int getPripority() {
        return pripority;
    }

    public void setPripority(int pripority) {
        this.pripority = pripority;
    }

}

具体的实现：

package com.hone.queue.priority;

import com.hone.queue.queue;

public class SeqQueue implements queue{
    
    static final int defaultSize=10;
    int front;
    int rear;
    int count;            //元素计数器
    int maxsize;        //数据元素最大的个数
    ElementPripority [] data;        //用于保存队列的数组
    
    public SeqQueue() {
        initiate(defaultSize);
    }
    
    public SeqQueue(int sz){
        this.initiate(sz);
    }

    private void initiate(int sz) {
        maxsize=sz;
        front=rear=0;
        count=0;
        data=new ElementPripority[sz];            //创建一个数组并且规定他的大小
    }

    //从一个空的队列中开始添加元素    入队列的时候不用管他的pripority属性
    @Override
    public void append(Object object) {
        if (count>0&&front==rear) {
            System.out.println("队列已满");
        }
        data[rear]=(ElementPripority) object; //加入的时候只是在乎他的element属性
        rear= (rear+1)%maxsize;                //加1取余获得最后队尾的数值
        count++;
    }
    
    //出队列
    @Override
    public Object delete() {
        if (count==0) {
            System.out.println("队列已空");
        }
        //首先要寻找最高优先级别的数，保存在min中
        ElementPripority min=data[0];
        int minIndex=0;
        for (int i = 0; i < count; i++) {
            if(data[i].getPripority()<min.getPripority()){
                min=data[i];
                minIndex=i;            //这个方法是在于找到优先级最小的值
            }
        }
        
        for (int j = minIndex+1; j < count; j++) {
            data[j-1]=data[j];        //因为暂时还没有涉及到除去，只是交换数据，让
                            //优先级别最高的排到队头去
        }
        rear--;
        count--;
        return min;
    }
    //获得队头的位置
    @Override
    public Object getFront() {
        if (count==0) {
            System.out.println("队列为空！");
        }
        //首先要寻找最高优先级别的数，保存在min中
                ElementPripority min=data[0];
                int minIndex=0;
                for (int i = 0; i < count; i++) {
                    if(data[i].getPripority()<min.getPripority()){
                        min=data[i];
                        minIndex=i;            //这个方法是在于找到优先级最小的值
                    }
                }
        return min;
    }

    @Override
    public boolean notEmpty() {
        return count!=0;
    }
}

 以上就是队列和堆栈的各种具体实现：

我们可以用堆栈来模拟回文字符串，或者将进程来模拟计算机中的“进程”。

利用堆栈+队列  来测试回文字符串

import com.hone.queue.SeqQueue;
import com.hone.stack.SeqStack;

public class TestOfHuiwen {
    public static void main(String[] args) {
        String string1="ABCDEDCBA";
        String string2="HGJEIEJHG";
        
        huiwen(string1);
        huiwen(string2);
    }
    
    public static void huiwen(String s){
        int n=s.length();
        SeqStack mystack=new SeqStack();
        SeqQueue myqueue=new SeqQueue();
        
        //先将所有的字符串都加入多对应的队列中去
        for (int i = 0; i < n; i++) {
            mystack.push(s.substring(i, i+1));
            myqueue.append(s.substring(i, i+1));
        }
        
        //从外面取出
        while(myqueue.notEmpty()&&mystack.notEmpty()){
            if (! myqueue.delete().equals(mystack.pop())) {
                System.out.println(s+" 不是回文字符串！");
                return ;        //如果不是回文字符串则直接回到上面的while循环中
            }
        }
        System.out.println(s+" 是回文字符串！");
    }

}

这个就是堆栈和队列的一些基本只是。

当然，这些在java中也已经给我们封装好了，不需要我们具体去写，只需要调用接口即可。

但是在c ,c++中经常利用与堆栈来进行，多项式的加减啊，用后缀表达式来求取表达式的值。

作为一个初学者，仍然是一知半解。