java算法：堆栈ADT及实例

最新推荐文章于 2021-03-02 16:19:42 发布
最新推荐文章于 2021-03-02 16:19:42 发布
阅读量1.3k 收藏 2
点赞数
分类专栏： 算法设计
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/undoner/article/details/8114877
版权

java算法：堆栈ADT及实例

在支持插入和删除数据项集的数据类型中，最重要的数据类型是堆栈。

堆栈：是由两个基本操作构成的ADT，插入（或压入）一个新项，以及删除（或弹出）最近插入的数据项。

例1：堆栈ADT接口

Java代码 复制代码
  1. public interface IIntStack {   
  2.     int intStack(int value);   
  3.     int empty();   
  4.     void push(int value);   
  5.     int pop();   
  6. }  
public interface IIntStack {
	int intStack(int value);
	int empty();
	void push(int value);
	int pop();
}

例2：中缀法：5*(((9+8)*(4*6))+7)，后缀法：5 9 8 + 4 6 * * 7 + *，前缀法：* + 7 * + 9 8 * 4 6 5

后缀计法和相关的压入栈操作应用到计算机中。如：

5     5

9     5    9

8     5    9   8

+     5    17

4     5    17  4

6     5    17  4  6

*     5    17  24

*     5    408

7     5    408 7

+     5    415

*     2075

Java代码 复制代码
  1. public class Postfix {   
  2.        
  3.     public static void main(String[] args) {   
  4.         char [] a = "598+46**7+*".toCharArray();   
  5.         int N = a.length;   
  6.         IIntStack s = new IntStackImpl();   
  7.         for(int i = 0; i < N; i++){   
  8.             if(a[i] == '+'){   
  9.                 s.push(s.pop() + s.pop());   
  10.             }   
  11.             if(a[i] == '*'){   
  12.                 s.push(s.pop() * s.pop());   
  13.             }   
  14.             if((a[i] >= '0') && (a[i] <= '9')){   
  15.                 s.push(0);   
  16.             }   
  17.             while((a[i] >= '0') && (a[i] <= '9')){   
  18.                 s.push(10 * s.pop() + (a[i++]-'0'));   
  19.             }   
  20.         }   
  21.         System.out.println(s.pop());   
  22.   
  23.     }   
  24.   
  25. }  
public class Postfix {
	
	public static void main(String[] args) {
		char [] a = "598+46**7+*".toCharArray();
		int N = a.length;
		IIntStack s = new IntStackImpl();
		for(int i = 0; i < N; i++){
			if(a[i] == '+'){
				s.push(s.pop() + s.pop());
			}
			if(a[i] == '*'){
				s.push(s.pop() * s.pop());
			}
			if((a[i] >= '0') && (a[i] <= '9')){
				s.push(0);
			}
			while((a[i] >= '0') && (a[i] <= '9')){
				s.push(10 * s.pop() + (a[i++]-'0'));
			}
		}
		System.out.println(s.pop());

	}

}

例3：中缀到后缀的转换

Java代码 复制代码
  1. public class InfixToPostfix {   
  2.        
  3.     public static void main(String[] args) {   
  4.         char [] a = "598+46**7+*".toCharArray();   
  5.         int N = a.length;   
  6.         IIntStack s = new IntStackImpl();   
  7.         for(int i = 0; i < N; i++){   
  8.             if(a[i] == ')'){   
  9.                 System.out.println(s.pop() + " ");   
  10.             }    
  11.             if((a[i] == '*') || (a[i] == '+')){   
  12.                 s.push(a[i]);   
  13.             }   
  14.             if((a[i] >= '0') && (a[i] <= '9')){   
  15.                 System.out.println(a[i] + " ");   
  16.             }   
  17.         }   
  18.         System.out.println(" ");   
  19.   
  20.     }   
  21.   
  22. }  
public class InfixToPostfix {
	
	public static void main(String[] args) {
		char [] a = "598+46**7+*".toCharArray();
		int N = a.length;
		IIntStack s = new IntStackImpl();
		for(int i = 0; i < N; i++){
			if(a[i] == ')'){
				System.out.println(s.pop() + " ");
			} 
			if((a[i] == '*') || (a[i] == '+')){
				s.push(a[i]);
			}
			if((a[i] >= '0') && (a[i] <= '9')){
				System.out.println(a[i] + " ");
			}
		}
		System.out.println(" ");

	}

}

栈的ADT实现

主要：数组和链表

例3：堆栈的数组实现

Java代码 复制代码
  1. class  IntStack{   
  2.     private int[] s;   
  3.     private int N;   
  4.     IntStack(int maxN){   
  5.         s = new int[maxN];   
  6.         N = 0;   
  7.     }   
  8.     boolean isEmpty(){   
  9.         return (N == 0);   
  10.     }   
  11.     void push(int item){   
  12.         s[N++] = item;   
  13.     }   
  14.     int pop(){   
  15.         return s[--N];   
  16.     }   
  17. }<SPAN></SPAN>  
class  IntStack{
	private int[] s;
	private int N;
	IntStack(int maxN){
		s = new int[maxN];
		N = 0;
	}
	boolean isEmpty(){
		return (N == 0);
	}
	void push(int item){
		s[N++] = item;
	}
	int pop(){
		return s[--N];
	}
}

例4：堆栈的链表实现

Java代码 复制代码
  1. class intStack{   
  2.     private Node head;   
  3.     private class Node{   
  4.         int item;   
  5.         Node next;   
  6.         Node(int item, Node next){   
  7.             this.item = item;   
  8.             this.next = next;   
  9.         }   
  10.     }   
  11.     intStack(int maxN){   
  12.         head = null;   
  13.     }   
  14.     boolean isEmpty(){   
  15.         return (head == null);   
  16.     }   
  17.     void push(int item){   
  18.         head = new Node(item, head);   
  19.     }   
  20.     int pop(){   
  21.         int v = head.item;   
  22.         Node t = head.next;   
  23.         head = t;   
  24.         return v;   
  25.     }   
  26. }  
class intStack{
	private Node head;
	private class Node{
		int item;
		Node next;
		Node(int item, Node next){
			this.item = item;
			this.next = next;
		}
	}
	intStack(int maxN){
		head = null;
	}
	boolean isEmpty(){
		return (head == null);
	}
	void push(int item){
		head = new Node(item, head);
	}
	int pop(){
		int v = head.item;
		Node t = head.next;
		head = t;
		return v;
	}
}


客户程序并不关心在数组实现和链表实现中栈的项是否按不同的顺序存放的。实现可自由地使用任何数据结构，只要它能保持抽象堆栈的假象。链表实现能产生栈可以无限增长的假象。而在实际中是不可能的：到达一定时候，当无法满足请求更多内存的要求时，就会抛出异常。

 

一般实现：定义一个接口，并实现object类型的堆栈，

Java代码 复制代码
  1. Stack s = new Stack(N);   
  2. s.push(a);   
  3. s.push(b);   
  4. a = (Item) s.pop();   
  5. b = (Item) s.pop();  
Stack s = new Stack(N);
s.push(a);
s.push(b);
a = (Item) s.pop();
b = (Item) s.pop();

例5：一般堆栈

Java代码 复制代码
  1. class Stack{   
  2.     private Object[] s;   
  3.     private int N;   
  4.     Stack(int maxN){   
  5.         s = new Object[maxN];   
  6.         N = 0;   
  7.     }   
  8.     boolean isEmpty(){   
  9.         return (M == 0);   
  10.     }   
  11.     void push(Object item){   
  12.         s[N++] = item;   
  13.     }   
  14.     Object pop(){   
  15.         Object t = s[--N];   
  16.         s[N] = null;   
  17.         return t;   
  18.     }   
  19. }  
class Stack{
	private Object[] s;
	private int N;
	Stack(int maxN){
		s = new Object[maxN];
		N = 0;
	}
	boolean isEmpty(){
		return (M == 0);
	}
	void push(Object item){
		s[N++] = item;
	}
	Object pop(){
		Object t = s[--N];
		s[N] = null;
		return t;
	}
}

例6：整数栈的适配类

Java代码 复制代码
  1. class IntStack{   
  2.     private Stack s;   
  3.     intStack(int maxN){   
  4.         s = new Stack(maxN);   
  5.     }   
  6.   
  7.     boolean isEmpty(){   
  8.         return s.isEmpty();   
  9.     }   
  10.     void push(int item){   
  11.         s.push(new Integer(item));   
  12.     }   
  13.     int pop(){   
  14.         return ((Integer)s.pop()).intValue();   
  15.     }   
  16.        
  17. }  
class IntStack{
	private Stack s;
	intStack(int maxN){
		s = new Stack(maxN);
	}

	boolean isEmpty(){
		return s.isEmpty();
	}
	void push(int item){
		s.push(new Integer(item));
	}
	int pop(){
		return ((Integer)s.pop()).intValue();
	}
	
}

创建新的ADT

设计一个新的ADT：开发解决应用问题的客户程序，定义接口，验证ADT是否更容易实现客户程序，再考虑是否合理、效率实现ADT中的操作，如果不能，找到原因进行更改。多次之后，改进的客户程序和ADT，采取策略冻结接口。

例7：等价关系ADT接口,连通性问题：初始化一个抽象数据结构来跟踪给定节点数之间的联系，判断两个给定节点是否连通，并把两个节点连起来，以后就认为它们是连通的。

Java代码 复制代码
  1. class UF{   
  2.     UF(int N);   
  3.     boolean find(int x; int y);   
  4.     void unite(int x; int y);   
  5. }  
class UF{
	UF(int N);
	boolean find(int x; int y);
	void unite(int x; int y);
}

例8：等价关系ADT的客户

Java代码 复制代码
  1. class Equivalence{   
  2.     public static void main(String [] args){   
  3.         int p,q, N = 100;   
  4.         UF info = new UF(N);   
  5.         for(In.init(); !In.empty();){   
  6.             p = In.getInt(); q = In.getInt();   
  7.             if(!info.find(p,q)){   
  8.                 info.unite(p,q);   
  9.                 System.out.println(p + "-" + q);   
  10.             }   
  11.         }   
  12.     }      
  13. }  
class Equivalence{
	public static void main(String [] args){
		int p,q, N = 100;
		UF info = new UF(N);
		for(In.init(); !In.empty();){
			p = In.getInt(); q = In.getInt();
			if(!info.find(p,q)){
				info.unite(p,q);
				System.out.println(p + "-" + q);
			}
		}
	}	
}

例9：等价关系ADT实现：加权快速合并实现接口：

Java代码 复制代码
  1. private int [] id, sz;   
  2. private int find(int x){   
  3.     while(x != id[x]){   
  4.         x = id[x];   
  5.     }   
  6.     return x;   
  7. }   
  8. UF(int N){   
  9.     id = new int[N];   
  10.     sz = new int[N];   
  11.     for(int i = 0; i < N; i++){   
  12.         id[i] = i;   
  13.         sz[i] = i;   
  14.     }   
  15. }   
  16. boolean find(int p, int q){   
  17.     return (find(p) == find(q));   
  18. }   
  19. void unite(int p, int q){   
  20.     int i = find(p), j = find(q);   
  21.     if(i == j){   
  22.         return;   
  23.     }   
  24.     if(sz[i] < sz[j]){   
  25.         id[i] = j; sz[j] += sz[i];   
  26.     }else{   
  27.         id[j] = i; sz[i] += sz[j];   
  28.     }   
  29. }  
private int [] id, sz;
private int find(int x){
	while(x != id[x]){
		x = id[x];
	}
	return x;
}
UF(int N){
	id = new int[N];
	sz = new int[N];
	for(int i = 0; i < N; i++){
		id[i] = i;
		sz[i] = i;
	}
}
boolean find(int p, int q){
	return (find(p) == find(q));
}
void unite(int p, int q){
	int i = find(p), j = find(q);
	if(i == j){
		return;
	}
	if(sz[i] < sz[j]){
		id[i] = j; sz[j] += sz[i];
	}else{
		id[j] = i; sz[i] += sz[j];
	}
}

比较：把解决高层（连通性）问题的任务和解决低层（合并-查找）的问题分开了，从而使我们能独立解决这两个问题；为我们提供了把解决该问题的不同算法和数据结构进行比较的自然方式；通过该接口定义了一个方法来检查软件是否按所期望的操作；为我们提供了一种更新的表示（新数据结构或新算法）而根本不需要改变客户程序的方法；为我们提供了一个能用来构建其他算法的抽象结构。

注意：使用抽象类或接口会产生运行时开销，每个抽象方法的调用需要跟踪表中对方法的一个引用。算法与数据结构经常用于系统中关键的性能部分，不希望以此为代价获得抽象类和接口的灵活性。

阿-杰
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java adt怎么使用_Java ADT中如何使用ImageView控件
weixin_34433661的博客
02-13 561
我们使用Java ADT做Android应用的时候，经常会需要使用ImageView控件插入图片。那么如何在Java ADT中使用ImageView控件呢？下面小编给大家分享一下。工具/材料Java ADT首先我们打开Java ADT软件，在左侧空白处右键单击选择New下面的Android Apppcation Project选项，如下图所示 ...
java adt教程_ADT工具使用详解
weixin_36002026的博客
02-12 3835
备注:一下内容为本人手工翻译官方文档注解,如有翻译不到位的地方,欢迎批评指正;ADT(Android开发工具)是Eclipse的插件，它提供了一套与Eclipse IDE集成的工具。它可以让您访问许多功能，帮助您快速开发Android应用程序。ADT提供对许多命令行SDK工具的GUI访问以及用于快速原型设计，设计和构建应用程序用户界面的UI设计工具。因为ADT是Eclipse的插件，您可以获得一个...
【数据结构NO.00003】C++构建简单的ADT栈&ADT栈的简单应用 by arttnba3
arttnba3的博客
10-06 581
C++构建ADT栈与简单应用绪论基本概念：栈（Stack）系统里的栈数据结构上的栈利用数组实现栈利用基于链表的ADT接口实现栈一、建立抽象二、建立接口三、实现栈模型栈的简单应用计算后缀表达式中缀表达式的转换 绪论 基本概念：栈（Stack） 系统里的栈 数据结构上的栈 利用数组实现栈 利用基于链表的ADT接口实现栈 一、建立抽象 二、建立接口 三、实现栈模型 栈的简单应用 计算后缀表达式 中缀表达...
java堆栈算法_java算法：堆栈ADT及实例
weixin_36344678的博客
02-15 343
java算法：堆栈ADT及实例在支持插入和删除数据项集的数据类型中，最重要的数据类型是堆栈。堆栈：是由两个基本操作构成的ADT，插入(或压入)一个新项，以及删除(或弹出)最近插入的数据项。例1：堆栈ADT接口Java代码 publicinterfaceIIntStack{intintStack(intvalue);intempty();voidpush(intvalue);intpop();}p...
adt的java_java算法：基于应用ADT例子
weixin_32804237的博客
02-20 298
java算法：基于应用ADT例子例1：多项式ADT接口Java代码 classPoly{Poly(int,int)doubleeval(double)voidadd(Poly)voidmult(Poly)publicStringtoString()}class Poly{Poly(int,int)double eval(double)void add(Poly)void mult(Poly)pu...
数据结构与算法java中文
11-05
- **基本数据类型**：Java提供了八种基本数据类型，包括四种整型（byte、short、int、long）、两种浮点型（float、double）、一种字符型（char）以及布尔型（boolean）。每种数据类型都有其固定的字节大小。 - **...
JAVA算法与数据结构
09-27
### JAVA算法与数据结构知识点概览 #### 一、Java语言基础知识 **1.1 Java语言基础知识** - **1.1.1 基本数据类型及运算** - Java支持多种基本数据类型，包括整型（`byte`, `short`, `int`, `long`）、浮点型（`...
数据结构与算法-java版
03-05
- **基本数据类型及运算**：Java支持多种基本数据类型，包括整型（如byte、short、int、long）、浮点型（float、double）、字符型（char）等。每种数据类型都有其特定的范围和用途。例如，`int`类型的变量通常用于...
如何在eclipse中添加android ADT
live_for_you的专栏
04-17 953
对于程序开发的学者来说，eclipse并不陌生，它为我们提供了一个非常广阔的平台来开发程序。同样我们也可以用它来开发android程序。但是在eclipse中并不能直接开发android程序，需要我们安装一个ADT插件。下面就介绍ADT插件的安装。 工具/原料 eclipse 方法/步骤 第一步，添加ADT。 打开eclipse
Java的ADT使用泛型
dxyinme-Zz
03-15 1939
JAVA也有跟其他计算机语言一样的抽象数据类型 下面是试例 public class ADTtest &lt;L&gt;{ public L name; public ADTtest(L g){ name = g; }//构造方法 @Override public String toString(){ return name....
数据结构与算法：堆栈ADT实现及应用
upc122的博客
04-29 1023
假设栈ADT的数据元素为整数，栈ADT的实现采用顺序存储结构。现要用栈来辅助完成任意非负十进制整数到Base(Base不大于35)进制的转换。部分代码已经给出，请补充完善栈溢出处理函数和主函数。 注意：只提交需要补充的函数，其他代码不允许自己重写和修改。 栈溢出处理函数overflowProcess：当栈满时，将栈的空间在原来基础上扩大1倍。 主函数： 输入一个非负十进制整数n及要转换的进制Ba...
《数据结构与算法》练习题：堆栈ADT实现及应用
Viadimir的博客
05-20 1305
题目描述如下： 假设栈ADT的数据元素为整数，栈ADT的实现采用顺序存储结构。现要用栈来辅助完成任意非负十进制整数到Base(Base不大于35)进制的转换。部分代码已经给出，请补充完善栈溢出处理函数和主函数。 注意：只提交需要补充的函数，其他代码不允许自己重写和修改。 栈溢出处理函数overflowProcess：当栈满时，将栈的空间在原来基础上扩大1倍。 主函数： 输入一个非负十进制整...
数据结构与算法分析-C++描述 第3章 栈ADT（简单计算器设计）
qq_37172182的博客
03-20 318
栈（stack）是限制插入和删除只能在同一位置上进行的表（又称LIFO表），该位置是表的末端，称为栈顶。 栈的两种实现：1）栈的链表（单向链表）实现； 2）栈的数组（vector）实现； 栈的常见应用：1）平衡符号，用于编译器语法检错；2）后缀表达式：通过栈的形式完成数学运算，时间复杂度为O(N)，执行效率高；3）中缀到后缀的转换；4）函数调用：堆和栈相...
顺序栈ADT模板简单应用算法设计：奇怪的键盘（我居然输了）
Blackoutdragon的博客
10-30 843
文章目录问题描述输入说明输出说明输入范例输出范例思路分析 问题描述 目的：使用C++模板设计顺序栈的抽象数据类型（ADT）。并在此基础上，使用顺序栈ADT的基本操作，设计并实现简单应用的算法设计。 内容：（1）请参照顺序表的ADT模板，设计顺序栈的抽象数据类型。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。参考教材、课件，以及网盘中的顺序表ADT原型文件，自行设计顺序栈的ADT。） （2）ADT的简单应用：使用该ADT
ADT（抽象数据类型）--堆栈
Turtle's trail
03-02 281
堆栈很简单，先进后出，用静态数组和动态内存分配实现： 版本一：静态数组版本 define STACK_SIZE 100 typedef int STACK_TYPE; //堆栈数组 static STACK_TYPE stack[STACK_SIZE]; //栈顶offset index static int top_element = -1; //push void push(STACK_TYPE value) { assert(!is_full()); top_element +
栈的抽象数据类型ADT
Caelus‘s Blobs
12-29 4734
转至：http://www.nowamagic.net/librarys/veda/detail/2270 对于栈来讲，理论上线性表的操作特性它都具备，可由于它的特殊性，所以针对它在操作上会有些变化。特别是插入和删除操作，我们改名为push和pop,英文直译的话是压和弹，更容易理解。你就把它当成是弹夹的子弹压入和弹出就好记忆了，我们一般叫进栈和出栈。 栈的抽象数据类型ADT定义如下：ADT 栈
ADT: Stack 栈
超悠閒的博客
10-31 2474
ADT: Stack 栈 文章目录ADT: Stack 栈简介参考正文栈结构抽象接口实现要素Java 实现C++ 实现结语 简介 本篇开始介绍 ADT(Abstract Data Type 抽象数据结构)，在计算机科学中除了基本类型如 int、long、char 等，大多数的程序还需要用到其他集成更多细节的抽象数据结构，如栈(Stack)、队列(Queue)、树(Tree)、图(Graph) 等，许多复杂算法的实现必须借助特定的数据结构才能够实现。 本篇将从最简单的栈(Stack)结构开始介绍，虽然栈的结构
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值