Java数据结构-线性表之栈（顺序栈和链栈）

栈的定义：（特殊的线性表）

??仅在表的一端进行插入和删除的线性表。允许插入、删除的这一端称为栈顶，另一端称为栈底。表中没有元素时称为空栈。

??被称为后进先出的线性表（Last In First Out），简称 LIFO表，或被称为先进后出的线性表（First In Last Out），简称 FILO表。

??栈更具存储方式的不同分为两种：顺序栈和链栈。

顺序栈：

  • 和顺序表一样，顺序栈也采用数组来存放数据元素；
  • 为了保证栈底位置的不变，采用数组下标为0的位置作为顺序栈的栈底。
  • 而栈顶指针的最大值为capacity（栈的容量）-1；
  • 当栈为空栈时，采用栈顶指针指向-1表示。

下面借图（来自http://www.nowamagic.net/librarys/veda/detail/2271）演示一下：

对于顺序栈，数据元素的进栈操作解释如下：

  1. 栈顶指针top先自增1，给需要进栈的元素腾出内存空间;
  2. 然后给top对应的数组元素赋值，data[top] = e。size加1

出栈的操作则相反，如下：

  1. 先获得栈顶指针对应的数组元素的值；
  2. 然后栈顶指针top减1。size减1

下面是我的Java代码实现：

package com.phn.stack;
/**
 * @author 潘海南
 * @Email [email protected]
 * @TODO 顺序栈
 * @date 2015年7月20日
 */
public class FOArrayStack<E> {
    //初始化默认栈的存储容量
    private static final int DEFUALT_CAPACITY = 100;
    //栈中存储数据元素的数组
    private Object[] data = null;
    //栈的实际大小
    private int size;
    //栈的栈顶指针
    private int top;
    //栈的实际容量
    private int capacity;
    /**
     * @TODO 无参构造函数，初始化栈
     */
    public FOArrayStack(){
        this(DEFUALT_CAPACITY);
    }
    /**
     * @TODO 带参构造函数，初始化栈
     * @param initialCapacity 初始化栈的容量
     */
    public FOArrayStack(int initialCapacity) {
        this.capacity = initialCapacity;
        this.data = new Object[initialCapacity];
        this.size = 0;
        this.top = this.size-1;
    }
    /**
     * @TODO 压入数据元素到栈中
     * @param e 数据元素
     * @return true
     */
    public boolean push(E e){
        this.validateCapacity();
        this.top++;
        this.data[top]=e;
        this.size++;
        return true;
    }
    /**
     * @TODO 验证栈的实际大小是否已经到达栈实际容量的极限
     */
    private void validateCapacity() {
        if(this.top==this.capacity-1){
            throw new RuntimeException("此栈已满！最大容量="+this.capacity);
        }
    }
    /**
     * @TODO 获取栈顶元素，并没有将其弹出栈
     * @return e 数据元素
     */
    public E peek(){
        if(this.isEmpty()){
            throw new RuntimeException("此栈为空栈！");
        }else{
            Object e = new Object();
            e = this.data[this.top];
            return (E)e;
        }

    }
    /**
     * @TODO 获取栈顶元素并弹出栈
     * @return e 数据元素
     */
    public E pop(){
        E e = this.peek();
        this.top--;
        this.size--;
        return e;
    }
    /**
     * @TODO 清空栈
     * @return true
     */
    public boolean clear(){
        while(this.top>=0){
            this.data[this.top]=null;
            this.top--;
            this.size--;
        }
        return true;
    }

    @Override
    public String toString() {
        StringBuffer sb = new StringBuffer("[");
        if(this.top!=-1){
            sb.append(this.data[this.top]);
            int temp = this.top-1;
            while(temp>=0){
                sb.append(", "+this.data[temp]);
                temp--;
            }
        }
        sb.append("]");
        return sb.toString();
    }
    /**
     * @TODO 判断栈是否为空
     * @return true空 or false不为空
     */
    public boolean isEmpty(){
//或者用长度表示
        if(this.top==-1){
            return true;
        }
        return false;
    }
    /**
     * @TODO 栈的实际大小
     * @return
     */
    public int size(){
        return this.size;
    }
}

我的测试代码：

package com.phn.stack;
/**
 * @author 潘海南
 * @Email [email protected]
 * @TODO 顺序栈测试
 * @date 2015年7月20日
 */
public class FOArrayStackTest {
    public static void main(String[] args) {
        FOArrayStack<String> foas = new FOArrayStack<String>(6);
        foas.push("元素1");
        foas.push("元素2");
        foas.push("元素3");
        foas.push("元素4");
        foas.push("元素5");
        System.out.println(foas);
        foas.pop();
        System.out.println(foas);
        String s = foas.peek();
        System.out.println(s);
        System.out.println(foas);
        foas.clear();
        System.out.println(foas);
        System.out.println(foas.isEmpty());
    }
}

测试结果截图：

下面扩展一下顺序栈，两栈共享空间：

??顺序栈具有单向延伸的特性，在一个程序中如果同时使用了具有相同数据类型的两个栈时可考虑使用一个数组来存储这两个栈，其中栈1的栈底设在该数组的始端，栈2的栈底设在该数组的尾端，两个栈都从各自的端点向数组中部延伸，只有在两个栈的栈顶在数组空间的某一位置相遇时才会产生“上溢”。栈1在入栈操作时栈顶指针top1++，出栈操作时top1–；栈2在入栈操作时栈顶指针top2–，出栈操作时top2++。

链栈：

  • 同单链表类似，只不过链栈只能从栈顶插入数据；
  • 因此可以将单链表的头指针作为链栈的栈顶指针，而去掉单链表的头结点，这样得到的就是链栈了。
  • 链栈不同顺序栈，链栈没有容量限制，不存在栈满的情况。空链栈的定义是栈顶指针指向空null。

对于链栈，插入（压栈）操作push解释如下：

  1. 将需要插入的数据元素放入一个新建立的节点temp中，将temp的next指向topNode；
  2. 将topNode赋值为temp。size加1

删除（弹出）操作pop解释如下：

  1. 取出topNode的数据元素e；
  2. 然后将topNode指向topNode的next节点；size减1。

下面是我的Java实现代码：

package com.phn.stack;
/**
 * @author 潘海南
 * @Email [email protected]
 * @TODO 链栈
 * @date 2015年7月20日
 */
public class FOLinkedStack<E> {
    //栈顶指针
    private FOLinkedNode<E> topNode = null;
    //栈的长度
    private int size;
    /**
     * @TODO 无参构造函数，初始化链栈
     */
    public FOLinkedStack() {
        this.size = 0;
    }
    /**
     * @TODO 获取栈的长度
     * @return
     */
    public int size() {
        return this.size;
    }
    /**
     * @TODO 压入数据元素到栈中
     * @param e 要压入的数据元素
     * @return true
     */
    public boolean push(E e) {
        FOLinkedNode<E> temp = new FOLinkedNode<E>();
        temp.setE(e);
        temp.addNext(this.topNode);
        this.topNode = temp;
        this.size++;
        return true;
    }
    /**
     * @TODO 获取栈顶元素，并没有弹出，还存在栈中
     * @return e 获取到的数据元素
     */
    public E peek(){
        if(this.isEmpty()){
            throw new RuntimeException("链栈为空！");
        }else{
            E e = this.topNode.getE();
            return e;
        }
    }
    /**
     * @TODO 弹出栈顶数据元素，不在栈中了
     * @return e 弹出的数据元素
     */
    public E pop(){
        E e = this.peek();
        this.topNode = this.topNode.next;
        this.size--;
        return e;
    }
    /**
     * @TODO 栈是否为空
     * @return true空 or false不为空
     */
    public boolean isEmpty(){
        if(this.topNode==null){
            return true;
        }
        return false;
    }
    @Override
    public String toString() {
        StringBuffer sb = new StringBuffer("[");
        if(this.topNode!=null){
            sb.append(this.topNode.getE());
            FOLinkedNode<E> temp =new  FOLinkedNode<E>();
            temp = this.topNode.next;
            while(temp!=null){
                sb.append(","+temp.getE());
                temp = temp.next;
            }
        }
        sb.append("]");
        return sb.toString();
    }

}

链栈节点类：

package com.phn.stack;
public class FOLinkedNode<E> {
        private E e;// 结点中存放的数据
        FOLinkedNode() {
        }
        FOLinkedNode(E e) {
            this.e = e;
        }
        FOLinkedNode<E> next;// 用来指向该结点的下一个结点
        // 设置下一节点的值
        void addNext(FOLinkedNode<E> node) {
            next = node;
        }
        public E getE() {
            return e;
        }
        public void setE(E e) {
            this.e = e;
        }
        @Override
        public String toString() {
            return e.toString();
        }
    }

下面是我的测试代码：

public static void main(String[] args) {
        FOLinkedStack<String> fols = new FOLinkedStack<String>();
        System.out.println(fols.isEmpty());
        fols.push("元素1");
        System.out.println(fols);
        System.out.println(fols.size());
        System.out.println(fols.peek());
        System.out.println(fols);
        System.out.println(fols.pop());
        System.out.println(fols.isEmpty());
        System.out.println(fols);
        System.out.println(fols.size());
        fols.push("元素4");
        fols.push("元素2");
        fols.push("元素5");
        fols.push("元素3");
        fols.push("元素6");
        System.out.println(fols);
        System.out.println(fols.size());
        System.out.println(fols.isEmpty());
    }

测试截图：

顺序栈和链栈的比较：

  1. 两种栈都是“先进后出”（或者称之为“后进先出”）的特点，只能在栈顶进行操作，所以时间复杂度为常量O(1)；
  2. 顺序栈初始化需要分配存储空间，分配过大则浪费，过小则溢出；
  3. 链栈初始化不需要分配空间，不过需要在分配一个指针域，存在结构性开销，但是没有长度限制。

应用建议：

??如果栈的使用过程中元素变化不可预料，有时很小，有时非常大，那么最好是用链栈，反之，如果它的变化在可控范围内，建议使用顺序栈会更好一些。

使用栈的原因：栈的引入简化了程序设计的问题，划分了不同关注层次，使得思考范围缩小，更加聚焦于我们要解决的问题核心。

版权声明：本文为博主原创文章，如需转载请注明出处并附上链接，谢谢。

时间： 2024-10-22 17:34:36

Java数据结构-线性表之栈（顺序栈和链栈）的相关文章

Java数据结构-线性表之顺序表ArrayList

线性表的顺序存储结构,也称为顺序表,指用一段连续的存储单元依次存储线性表中的数据元素. 根据顺序表的特性,我们用数组来实现顺序表,下面是我通过数组实现的Java版本的顺序表. package com.phn.datestructure; /** * @author 潘海南 * @Email [email protected] * @TODO 顺序表 * @date 2015年7月16日 */ public class FOArrayList<E> { // 顺序表长度 private int

Java数据结构-线性表之单链表LinkedList

线性表的链式存储结构,也称之为链式表,链表:链表的存储单元可以连续也可以不连续. 链表中的节点包含数据域和指针域,数据域为存储数据元素信息的域,指针域为存储直接后继位置(一般称为指针)的域. 注意一个头结点和头指针的区别: 头指针: 指向链表的第一个节点的指针,若链表有头结点,则是指向头结点的指针: 头指针具有标识作用,所以常用头指针作为链表的名字: 不论链表是否为空,头指针都不为空: 是链表的必要元素. 头结点: 头结点是为了操作的统一和方便而设立的,放在第一个元素节点的前面,其数据域一般无意

Java数据结构-线性表之队列

队列(Queue)的定义:只允许在一端进行插入另一端进行删除操作的线性表.允许插入的一端称为队尾(rear) ,允许删除的一端称为队头(front). 具有"先进先出"特点. 队列也是线性表,所以也存在顺序结构和链式结构. 顺序队列: 对于队列,入队操作的解释为: (是在队尾追加一个元素,不需要移动任何元素,因此时间复杂度为0(1).) 判断队列是否已满: 如果没满则先给队尾元素赋值; 然后将队尾指针后移一位(对队尾指针赋值,Q->rear = Q->rear+1 ). 出

Java数据结构-线性表之栈的应用-递归及其应用

??递归函数的定义:把一个直接调用自己或通过一系列的调用语句间接地调用自己的函数,称做递归函数(递归函数必须有一个结束的条件,以免陷入无穷尽的递归中). 迭代和递归的区别是: ?(1).迭代使用的是循环结构,递归使用的是选择结构. ?(2).递归能使程序的结构更清晰.更简洁.更容易让人理解,从而减少读懂代码的时间.但是大量的递归调用会建立函数的副本,会耗费大量的时间和内存. ?(3).迭代则不需要反复调用函数和占用额外的内存.因此我们应该视不同情况选择不同的代码实现方式. 下面解释一下怎么使用栈

Java数据结构-线性表之静态链表

静态链表的定义: 节点由一个一维数组和一个指针域组成,数组用来存放数据元素,而指针域里面的指针(又称游标)用来指向下一个节点的数组下标.这样的链表称之为静态链表. 链表中的数组第一个和最后一个位置需要特殊处理,不存数据.第一个位置(即数组0下标)的节点的指针用来存放备用链表的第一个节点的数组下标.最后一个位置(即数组长度MaxSize-1下标)的节点的指针用来存放指向有数值的第一个数据元素的数组下标,类似于单链表的头结点. 静态链表的示例图: 下面举一个摘抄自<大话数据结构>的例子,来解释一下

Java数据结构-线性表之链表应用-检测链表是否有环

??如何检测一个链表是否有环?这个是一个出现频率较高的面试题. ??如下是一个含有环的链表. (图片来自http://www.nowamagic.net/librarys/veda/detail/2245 一个有很多关于数据结构的文章的网站,还有其他的资料,可以看看) 我这里解题的方法有三种: 快慢指针方法:两个速度不一样的指针遍历总会相遇: 利用环的顶点数和边相等的关系: 两个指针遍历判断步数是否相等. ??为了实现检查链表是否含有环的情况,我们需要先构建出一个含有环的链表. ??于是乎我在之

[考研系列之数据结构]线性表之栈

?基本概念 栈的定义 限定仅在表尾进行插入或删除的线性表 组成 栈顶 栈底 基本操作 入栈(PUSH) 往栈中插入一个元素 弹栈(POP) 从栈顶删除一个元素 栈的表示 顺序栈 链栈 对于顺序栈,有两个指针base和top base指向栈底 top指向栈顶 对于栈的一些基本情况: 栈不存在时候 base=NULL 栈为空时  top=base 栈的长度 top-base 链栈略过. 栈的应用 1 数制转换 数制转换我们使用一种称之为"辗转相除法"的算法.此算法的基本原理基于: N=(N

java实现数据结构-线性表-顺序表，实现插入，查找，删除，合并功能

package 顺序表; import java.util.ArrayList; import java.util.Scanner; public class OrderList { /** * @param args * @author 刘雁冰 * @2015-1-31 21:00 */ /* * (以下所谓"位置"不是从0开始的数组下标表示法,而是从1开始的表示法.) * (如12,13,14,15,16数据中,位置2上的数据即是13) * * 利用JAVA实现数据结构-线性表-顺

数据结构——线性表（顺序实现）

好好学习基础知识,出人头地就靠它了,内外兼修.(好吧,我现在内外都不行)写这篇文章的目的就是为了,巩固刚学完的线性表,个人能力有限,若有不当之处,望指出. 线性表 好了,扯完了,说正事: 1.定义 线性表是一种及其常用的并且最简单的一种数据结构.简单来说,线性表就是集合里的元素的有限排列.(在这里我把集合定义为具有相同属性的元素,会有些狭义) 在线性表中数据元素之间的关系是一对一的关系,即除了第一个和最后一个数据元素之外,其它数据元素都是首尾相接的(注意,这句话只适用大部分线性表,而不是全部.比