动态数组2栈的顺序存储结构(Stack接口，ArrayStack实现，ArrayStackDoubleEnd实现)

最新推荐文章于 2021-04-09 15:38:30 发布
最新推荐文章于 2021-04-09 15:38:30 发布
阅读量217 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zh_tnis/article/details/100675332
版权

   1.栈的定义。

      栈是限定仅在表尾进行插入和删除操作的线性表。

    2.栈接口Stack的定义。

    代码如下：

package com.oupeng.p2栈;

public interface Stack<E> {
	/**
	 * 获取栈中元素的个数
	 * @return 栈中元素个数
	 * */
	public int getSize();
	/**
	 * 判断当前栈是否为空
	 * @return 是否为空布尔值
	 * */
	public boolean isEmpty();
	/**
	 * 近栈一个元素e
	 * @param e 即将进栈的元素
	 * */
	public void push(E e);
	/**
	 * 出栈一个元素
	 * @return 当前出栈的栈顶元素
	 * */
	public E pop();
	/**
	 * 获取当前栈顶元素
	 * @return 当前栈顶的元素  不弹栈
	 * */
	public E peek();
	/**
	 * 清空栈
	 * */
	public void clear();
}

    3.栈的顺序存储结构ArrayStack的定义。

    代码如下：

package com.oupeng.p2栈;

import com.oupeng.p1线性表.ArrayList;

public class ArrayStack<E> implements Stack<E> {
	//栈的实现可以完全借助于ArrayList
    private ArrayList<E> list;
    /**
     * 创建一个默认大小的栈（顺序表）
     */
    public ArrayStack() {
    	list =new ArrayList<E>();
    }
    /**
     * 创建一个容量为指定capacity大小栈（顺序表）
     * @param capacity
     */
    public ArrayStack(int capacity) {
    	list=new ArrayList<E>(capacity);
    }
    
	@Override
	public int getSize() {
		return list.getSize();
	}

	@Override
	public boolean isEmpty() {
		return list.isEmpty();
	}

	@Override
	public void push(E e) {
		list.addLast(e);
	}

	@Override
	public E pop() {
		return list.removeLast();
	}

	@Override
	public E peek() {
		return list.getLast();
	}

	@Override
	public void clear() {
		list.clear();
	}
	
	@Override
	public boolean equals(Object obj) {
		if(obj==null) {
			return false;
		}
		if(obj==this) {
			return true;
		}
		if(obj instanceof ArrayStack) {
			ArrayStack<E> stack=(ArrayStack<E>) obj;
			return list.equals(stack.list);
		}
		return false;
	}
	 @Override
	  public String toString() {
		StringBuilder sb=new StringBuilder();
		sb.append("ArrayList:size="+getSize()+",capacity="+list.getCapacity()+"\n");
		if(isEmpty()) {
			sb.append("[]");
		}else {
			sb.append('[');
			for(int i=0;i<getSize();i++) {
				sb.append(list.get(i));
				if(i==getSize()-1) {
					sb.append(']');
					
				}else {
					sb.append(',');
				}
			}
		}
		return sb.toString();
		
	  }
}
  •     ArrayStack的分析

    1、栈的顺序存储结构----进栈操作O(1)

      

1.根据ArrayList中的定义
  使用void push(E e);
  将元素e从表头进栈        或者  从表尾进栈

    2、栈的顺序存储结构----出栈操作O(1)

1.根据ArrayList
  E pop()；
2.选择最后一个元素作为出栈
  也就是list.removeLast()；

    3、进栈出栈变化形式

 

     4.双端栈的定义。

      是指将一个线性表的两端当做栈底分别进行入栈和出栈操作。

    简单理解：1、一个数组分成两个栈，一个栈的端点leftTop是数组的下标0处，另一个栈的端点rightTop是数组的下标

                             (数组长度-1)处

                        2、可知，这个数组中间有一部分不存在元素，当栈增加元素时，就是两个端点向中间部分延伸

                        3、栈满：当  leftTop+1==rightTop时 

                        4、栈空：当 leftTop=-1;或者rightTop=data.length;

    代码如下：

package com.oupeng.p2栈;

import com.oupeng.p1线性表.ArrayList;

public class ArrayStackDoubleEnd<E> implements Stack<E>{
	//枚举
	enum Direction{
		LEFT,RIGHT;
	}
	
	private E[] data;		              //用于存储数据的容器
	private int leftTop;	              //左端栈的栈顶 开始在-1
	private int rightTop;	              //右端栈的栈顶 开始在data.length
	private static int DEFAULT_SIZE=10;   //默认容量大小为10
	
	public ArrayStackDoubleEnd(){
		this(DEFAULT_SIZE);
	}
	public ArrayStackDoubleEnd(int capacity){
		data=(E[]) new Object[capacity];
		leftTop=-1;
		rightTop=data.length;
	}
	private boolean isFull(){
		return leftTop+1==rightTop;
	}
	/**
	 * 向指定的端口进栈元素
	 * */
	public void push(Direction dir,E e){
		if(isFull()){
			resize(data.length*2);
		}
		if(dir==Direction.LEFT){
			data[++leftTop]=e;
		}else{
			data[--rightTop]=e;
		}
	}
	
	
	private void resize(int newLen) {
		E[] newData=(E[]) new Object[newLen];
		//左端复制
		for(int i=0;i<=leftTop;i++){
			newData[i]=data[i];
		}
		//右端复制
		int index=data.length-1;
		int i;
		//6 7 8 9
		for(i=newData.length-1;i>=newData.length-data.length+rightTop;i--){
			newData[i]=data[index--];
		}
		rightTop=i+1;
		data=newData;
	}
	/**
	 * 从指定的端口出栈元素
	 * */
	public E pop(Direction dir){
		if(dir==Direction.LEFT){
			if(leftTop==-1){
				throw new IllegalArgumentException("左端栈为空!");
			}
			E e=data[leftTop--];
			if(getSize()<=data.length/4&&data.length>DEFAULT_SIZE){
				resize(data.length/2);
			}
			return e;
		}else{
			if(rightTop==data.length){
				throw new IllegalArgumentException("右端栈为空!");
			}
			E e=data[rightTop++];
			if(getSize()<=data.length/4&&data.length>DEFAULT_SIZE){
				resize(data.length/2);
			}
			return e;
		}
		
	}
	
	/**
	 * 从指定的端口获取栈顶元素
	 * */
	public E peek(Direction dir){
		if(dir==Direction.LEFT){
			if(leftTop==-1){
				throw new IllegalArgumentException("左端栈为空!");
			}
			return data[leftTop];
		}else{
			if(rightTop==data.length){
				throw new IllegalArgumentException("右端栈为空!");
			}
			return data[rightTop];
		}
	}
	
	/**
	 * 获取指定端口栈的元素个数
	 * */
	public int getSize(Direction dir){
		if(dir==Direction.LEFT){
			return leftTop+1;
		}else{
			return data.length-rightTop;
		}
	}
	
	/**
	 * 判断指定端口的栈是否为空
	 * */
	public boolean isEmpty(Direction dir){
		if(dir==Direction.LEFT){
			return leftTop==-1;
		}else{
			return rightTop==data.length;
		}
	}
	/**
	 * 清空指定端口的栈
	 * */
	public void clear(Direction dir){
		if(dir==Direction.LEFT){
			leftTop=-1;
		}else{
			rightTop=data.length;
		}
	}
	
	/**
	 * 获取左端栈和右端栈元素的总和
	 * */
	@Override
	public int getSize() {
		return getSize(Direction.LEFT)+getSize(Direction.RIGHT);
	}
	
	/**
	 * 判断左端栈和右端栈是否全为空
	 * */
	@Override
	public boolean isEmpty() {
		return isEmpty(Direction.LEFT)&&isEmpty(Direction.RIGHT);
	}
	
	/**
	 * 左端少进左端，右端少进右端
	 * */
	@Override
	public void push(E e) {
		if(getSize(Direction.LEFT)<=getSize(Direction.RIGHT)){
			push(Direction.LEFT,e);
		}else{
			push(Direction.RIGHT,e);
		}
	}
	
	/**
	 * 哪端多弹哪端
	 * */
	@Override
	public E pop() {
		if(isEmpty()){
			throw new IllegalArgumentException("双端栈为空!");
		}
		if(getSize(Direction.LEFT)>getSize(Direction.RIGHT)){
			return pop(Direction.LEFT);
		}else{
			return pop(Direction.RIGHT);
		}
	}
	
	/**
	 * 哪端多获取哪 一样多默认左
	 * */
	@Override
	public E peek() {
		if(isEmpty()){
			throw new IllegalArgumentException("双端栈为空!");
		}
		if(getSize(Direction.LEFT)>getSize(Direction.RIGHT)){
			return peek(Direction.LEFT);
		}else{
			return peek(Direction.RIGHT);
		}
	}
	
	/**
	 * 左右两端都清空
	 * */
	@Override
	public void clear() {
		clear(Direction.LEFT);
		clear(Direction.RIGHT);
	}
	
	@Override
	public String toString() {
		StringBuilder sb=new StringBuilder();
		sb.append("ArrayStackDoubleEnd: size="+getSize()+",capacity="+data.length+"\n");
		if(isEmpty()){
			sb.append("[]");
		}else{
			sb.append('[');
			int count=0;
			for(int i=0;i<=leftTop;i++){
				sb.append(data[i]);
				count++;
				if(count==getSize()){
					sb.append(']');
				}else{
					sb.append(',');
				}
			}
			for(int i=rightTop;i<data.length;i++){
				sb.append(data[i]);
				count++;
				if(count==getSize()){
					sb.append(']');
				}else{
					sb.append(',');
				}
			}
		}
		return sb.toString();
	}
	
	/**
	 * 纯粹比较两个双端栈的内容
	 * */
	@Override
	public boolean equals(Object obj) {
		
		if(obj==null){
			return false;
		}
		if(obj==this){
			return true;
		}
		if(obj instanceof ArrayStackDoubleEnd){
			ArrayStackDoubleEnd<E> stack=(ArrayStackDoubleEnd<E>) obj;
			if(getSize()==stack.getSize()){
				ArrayList<E> list1=new ArrayList<E>(getSize());
				ArrayList<E> list2=new ArrayList<E>(getSize());
				//拼接当前栈的左部分
				for(int i=0;i<=leftTop;i++){
					list1.addLast(data[i]);
				}
				//拼接当前栈的右部分
				for(int i=rightTop;i<data.length;i++){
					list1.addLast(data[i]);
				}
				//拼接传入栈的左部分
				for(int i=0;i<=stack.leftTop;i++){
					list2.addLast(stack.data[i]);
				}
				//拼接传入栈的右部分
				for(int i=stack.rightTop;i<stack.data.length;i++){
					list2.addLast(stack.data[i]);
				}
				return list1.equals(list2);
			}
		}
		return false;
	}
}

 

  •     ArrayStackDoubleEnd分析  
push(Direction dir,E e)  方向（左栈或右栈）,元素  判是否满栈，满进行扩容，未满在传入的方向，
                         端点(leftTop)+1或(rightTop)-1赋值，也就是进栈
resize(int newLen)       新长度       将原双栈复制到新数组两端
pop(Direction dir)       方向（左栈或右栈）      判是否空栈，未空，端点开始移动。然后判断是否需
                         要缩容
peek(Direction dir)      方向（左栈或右栈）      判是否空栈，未空，在传入的方向获取栈顶元素
getSize(Direction dir)   方向（左栈或右栈）      获取该方向的总元素
isEmpty(Direction dir)   方向（左栈或右栈）      判该方向是否已空 
clear(Direction dir)     方向（左栈或右栈）      清空该方向的所有元素 
====================================================================================
getSize()                获取两个方向，也就是左栈和右栈元素总和
isEmpty()                判断两个方向是否都已空
push(E e)                对左栈和右栈元素数量进行对比，那边少元素进入哪个方向的栈，相同默认左栈
pop()                    若isEmpty()=true，则那边多元素出哪个方向的栈，相同默认右栈（自己定义）
peek()                   若isEmpty()=true，则那边多元素获取哪个方向的栈顶元素 相同自己定义默认
clear()                  清空选择方向的栈  上方的clear(Direction dir)
toString()               
equals(Object obj)

 

zh_Tnis
关注
专栏目录
栈的动态顺序存储表示
理工科的杜小甫的博客
06-23 2350
采用动态一维数组来存储栈。所谓动态，指的是栈的大小可以根据需要增加。 ◆ 用bottom表示栈底指针，栈底固定不变的；栈顶则随着进栈和退栈操作而变化。用top(称为栈顶指针)指示当前栈顶位置。 ◆ 用top=bottom作为栈空的标记，每次top指向栈顶数组中的下一个存储位置。 ◆ 结点进栈：首先将数据元素保存到栈顶(top所指的当前位置)，然后执行top加1，使top指向栈顶的下一个存储位置
数据结构——栈的java实现(一)-使用顺序存储结构(数组)以及实现
weixin_38927257的博客
01-07 1180
文章目录一、线性表的定义二、顺序存储结构三、栈的定义代码：Array.classArrayStack.classStack.class测试：测试结果：总结： 一、线性表的定义 线性表是同一类型数据的一个有限序列，线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的。 线性表的顺序存储要求地址空间是连续的，地址必须一个接一个，不能中断。如下图为顺序...
线性表之顺序存储结构（C语言动态数组实现）
weixin_30682415的博客
05-16 423
线性表的定义：N个数据元素的有限序列 线性表从存储结构上分为：顺序存储结构（数组）和 链式存储结构（链表） 顺序存储结构：是用一段连续的内存空间存储表中的数据L=(a1,a2,a3....an) 链式存储结构：是用一段一段连续的内存空间存储表中每一行的数据，段与段之间通过一个引用（指针）相互连接来，形成一个链式的存储结构 看到顺序存储结构的图示，我们可能会马上联想到C语...
C++实现 栈的顺序存储（通过动态数组）
weixin_43335392的博客
03-18 362
前面讲解了通过静态数组，实现顺序栈 C++实现 栈的顺序存储（通过静态数组) 那么如果我们不想使用定长的数组，转而使用动态数组又该怎么编写呢？强烈建议与上面这篇文章，对比着学习，注重二者不同的地方，这样更能深刻掌握栈的顺序存储 1.栈的结构定义 typedef int ElementType #define Maxsize 10; struct Sqstack { Element_type *P;...
数据结构之栈的动态顺序存储实现-c语言版
阿祖的专栏
05-16 292
#include <stdio.h> #define STACK_SIZE 100 #define STACK_INCREMENT 10 typedef int ElemType; typedef int Status; #define OK 1 #define ERROR -1 typedef struct sqstack { ElemType *bottom; ElemType *top; int stackSize; }SqStack,*Pstack; Sta...
栈的顺序存储实现
computer vision, sixth sense, robot, AI
11-17 415
#define StackSize 100 typedef struct { DataType stack[StackSize]; int top; }SeqStack; void InitStack(SeqStack *S) { S->top = 0; } int StackEmpty(SeqStack S) { if(S.top == 0) retur
数组模拟栈并实现加减乘除运算
CsDnGoGod的博客
12-04 343
数组模拟栈并实现加减乘除运算 1.通过一个index值，来遍历我们的表达式 2.如果我们发现是一个数字，就直接入数栈 3.如果发现扫描到是一个符号，分如下情况 3.1如果发现当前符号栈为空，就直接入栈 3.2如果符号栈有操作符，就进行比较，如果当前的操作符的优先级小于或者等于栈中的操作符，就需要从数栈中pop出两个数，再从符号栈中pop出一个符号，进行运算，将得到的结果，入数栈，然后将当前的操作符入符号栈。如果当前的操作符的优先级大于或者等于栈中的操作符，就直接入符号栈 4.当表达式扫描完毕，就顺序的从数栈
数据结构动态数组之双端栈和队列基层实现
qq_37244548的博客
06-05 318
定义：一个线性表的两端当做栈底分别进行入栈和出栈的操作，主要利用了栈"栈底位置不变，而栈顶位置动态变化"的特性。 我们把双端栈叫做ArrayDoubleEndStack，双端栈是线性表的一种，更是栈的一个特殊的分类，所以我们可以用动态数组和栈的思想来实现双端栈，毕竟由于其操作的特殊性，并不能借助ArrayList或者ArrayStack实现,所以这里需要从头开始实现双端栈 队列的定义 只是允许在一端进行插入操作，而在另一端进行删除操作的线性表 我们把允许删除的一端称为队首，插入的一端称为队尾 ..
Java实现顺序栈原理解析
08-25
Java实现顺序栈原理解析是指使用Java语言实现顺序栈的数据结构，顺序栈是一种特殊的线性表，限制了元素的插入和删除只能在线性表的同一端进行。下面将详细介绍Java实现顺序栈原理解析的知识点。 什么是栈 栈是一种...
动态数组在数据结构中的魔法：揭秘链表、栈、队列的实现
动态数组的底层实现通常使用指针和内存分配。它将元素存储在连续的内存块中，并使用指针跟踪当前分配的内存大小。当需要添加或删除元素时，动态数组会自动调整内存分配，确保始终有足够的空间容纳所有元素。 动态...
自定义实现的顺序栈ArrayStack
03-06
利用Java语言实现的，基于数组实现的顺序栈——ArrayStack
栈的顺序存储 - 设计与实现 - API实现
yofer张耀琦的专栏
07-13 1211
Stack基本概念 栈是一种 特殊的线性表 栈仅能在线性表的一端进行操作 栈顶(Top)：允许操作的一端 栈底(Bottom)：不允许操作的一端 Stack的常用操作 创建栈 销毁栈 清空栈 进栈 出栈 获取栈顶元素 获取栈的大小  栈模型和链表模型关系分析 栈的顺序存储设计与实现 // seqlist.h // 顺序存储结构线性
栈（2）——栈的顺序存储
程序员的时光
08-24 498
目录 1. 基本概念； 2. 设计与实现； 2.1 建立动态数组实体类SeqStack类； 2.2 再建立方法类SeqStackDao类； 2.3 测试类SeqStackMain类； 1. 基本概念； 栈的顺序存储结构简称顺序栈，它是运算受限制的顺序表； 顺序栈的存储结构： 利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素； ...
基于数组，实现动态扩容的顺序栈
qianye的博客
04-09 289
实现代码： public class DynamicCapacityArrayStack<T> { /** * 存放数据的数组 */ private T[] items; /** * 栈中元素初始化容量大小 */ public static int initSize = 10; /** * 当前栈中元素个数 */ private int currentSize; /**
数据结构之动态数组
Batac的博客
04-26 307
Batac 联系方式:1763781716@qq.com 几种数据结构:集合,线性结构,树形结构,图形结构: 说明: 线性表的顺序存储结构:数组 数组:一次性申请一定量的内存空间; 动态数组:不断的扩容,重新申请更大的内存空间; 实现动态数组: public class ArrayList<E> { /** * 元素个数 */ private int siz...
数据结构与算法---动态数组（2）顺序栈ArrayStack、双端栈ArrayStackDoubleEnd
qq_45161607的博客
12-11 270
栈的顺序存储结构 a.栈的定义：栈是限定仅在表尾进行插入和删除操作的线性表 我们把允许插入和删除的一端称为栈顶，另一端称为栈底 栈又称为后进先出的线性表 定义中说的时在线性表的表尾进行插入和删除，这里表尾是栈顶 栈的插入操作，叫做进栈，也称压栈，入栈 栈的删除操作，叫做出栈，也称弹栈 b.栈的接口定义 成员变量，成员函数 我们可以将顺序表看成时栈的一个成员变量 c.接口的实现 接口的实现我们都可...
数据结构——ArrayStack和LinkedStack的实现
来自星星的の松子的博客
01-31 2090
栈是一种后进先出(LIFO)的数据结构。 ArrayStack使用数组来实现，LinkedStack使用链表来实现，各有特点，也都非常简单。
卜若的代码笔记-数据结构系列-第十一章：栈二.顺序栈(动态数组栈)
qq_37080133的博客
05-17 197
1.首先来说明一下什么叫做动态数组。 本质上还是数组，只是每次向数组里面添加的时候，如果检查到数组的长度不够的时候，就会产生以下动作： a.new 一个两倍容量数组 b.将原始数组拷贝进去 关于拷贝方式的性能比较，我找到一篇比较好的博客 https://www.cnblogs.com/tabCtrlShift/p/9440566.html 可以去看一下。 c.释放掉原始数组(关于释放的问题，我会单独开辟一个专栏去介绍。在java里面我们默认自动释放) 分析后我们发现，我们目前需要..
三 . 栈的顺序存储结构
qq_36549593的博客
09-11 128
一 . 栈 1 . 栈的定义 栈是限定仅在表尾进行插入和删除操作的线性表，表尾是指栈顶，而不是栈底 我们把允许插入和删除的一端称为栈顶(top)，另一端称为栈底(bottom) 不含任何数据元素的栈称为空栈 栈又称为后进先出的线性表简称LIFO结构 栈本身是一个线性表，其数据元素具有线性关系，只不过它是一种特殊的线性表而已 栈的插入：进栈，也称压栈，入栈。类似子弹入弹夹 栈的删除...
栈的顺序存储结构与实现
在实现顺序栈时，通常会设定一个初始存储空间大小（如 `STACK-INIT-SIZE`），并定义一个增量（如 `STACKINCREMENT`），当栈满时，需要动态扩展存储空间。例如，如果初始分配了100个元素的空间，当栈满时，会再增加10...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值