正文
java出栈进栈代码 java方法入栈出栈
小程序：扫一扫查出行【扫一扫了解最新限行尾号】
复制小程序
关于数据结构（java）的一个代码
描述栈抽象数据类型java出栈进栈代码的SStack接口的声明
public interfaceSStackE //栈接口
{
boolean isEmpty(); //判断是否空栈java出栈进栈代码，若空栈返回true
boolean push(E element); //元素element入栈java出栈进栈代码，若操作成功返回true
E pop(); //出栈java出栈进栈代码，返回当前栈顶元素，若栈空返回null
E get(); //取栈顶元素值，未出栈，若栈空返回null
}
顺序栈类具体操作方法的声明java出栈进栈代码：
importdataStructure.linearList.SStack;
public classSeqStackE implements SStackE
//顺序栈类
{
private Object value[]; //存储栈的数据元素
private int top; //top为栈顶元素下标
public SeqStack(int capacity) //构造指定容量的空栈
{
this.value = newObject[Math.abs(capacity)];
this.top=-1;
}
public SeqStack() //构造默认容量的空栈
{
this(10);
}
public boolean isEmpty() //判断是否空栈，若空栈返回true
{
return this.top==-1;
}
public boolean push(E element) //元素element入栈，若操作成功返回true
{
if (element==null)
return false; //空对象（null）不能入栈
if (this.top==value.length-1) //若栈满，则扩充容量
{
Object[] temp = this.value;
this.value = newObject[temp.length*2];
for (int i=0; itemp.length;i++)
this.value[i] = temp[i];
}
this.top++;
this.value[this.top] = element;
return true;
}
public E pop() //出栈，返回当前栈顶元素，若栈空返回null
{
if (!isEmpty())
return (E)this.value[this.top--];
else
return null;
}
public E get() //取栈顶元素值，未出栈，栈顶元素未改变
{
if (!isEmpty())
return (E)this.value[this.top];
else
return null;
}
public String toString() //返回栈中各元素的字符串描述
{
String str="{";
if (this.top!=-1)
str +=this.value[this.top].toString();
for (int i=this.top-1; i=0; i--)
str += ","+this.value[i].toString();
return str+"} ";
}
实例引用public static void main(String args[])
{
SeqStackString stack = newSeqStackString(20);
System.out.print("Push: ");
char ch='a';
for(int i=0;i5;i++)
{
String str =(char)(ch+i)+"";
stack.push(str);
System.out.print(str+" ");
}
System.out.println("\n"+stack.toString());
System.out.print("Pop : ");
while(!stack.isEmpty()) //全部出栈
System.out.print(stack.pop().toString()+" ");
System.out.println();
}
有没有哪位大神能告诉我一下，java stack 进栈出栈怎么写？
public class MyStack {
private Node top;
public void push(Object o) {
if(top==null) {
top = new Node(o);
}else {
Node n = new Node(o);
n.setPre(top);
top = n;
}
}
public Object pop() {
if(top.getEntity()!=null) {
Object ret = top.getEntity();
top = top.getPre();
return ret;
}
return null;
}
public void printStack() {
Node n = top;
System.out.print("[");
while(n!=null) {
System.out.print(n.getEntity());
System.out.print(",");
n=n.getPre();
}
System.out.println("]");
}
public static void main(String[] args) {
MyStack s = new MyStack();
s.push(1);
s.push(2);
s.push("cat");
s.push("dog");
s.printStack();
s.pop();
s.printStack();
}
}
class Node {
private Node pre;
private Object entity;
public Node(Object entity) {
this.entity = entity;
}
public Node getPre() {
return pre;
}
public void setPre(Node pre) {
this.pre = pre;
}
public Object getEntity() {
return entity;
}
public void setEntity(Object entity) {
this.entity = entity;
}
}
Java如何实现出栈入栈并获取栈中最小值的程序
你得明白栈的定义。代码执行的时候是执行一个方法，执行完，返回方法的上一个代码块继续往下执行后面的内容。这样的话是不是就是一个栈结构了？先进后出。方法一边执行，一边往栈里面存数据，等执行完了就取出数据（取出的是返回值，是最后一个存进去的 栈结构是后进先出），然后执行外面的代码。这么说你可能不明白，我给你举个例子。
int sub(int a,int b){
return a+b;
}
int c = sub(2,3);//注意执行这条语句的时候是不是执行了一个方法？
//那么语句执行的时候是要从左往右执行的对吧，但是事实的逻辑却是先算出来sub（2，3）这个方
//法的返回值，然后再把返回值（5）赋值给 c ，那么这个怎么实现，肯定是一个栈的数据结构，编译的时候先把”int c = “入栈，然后再把 sub（2，3），入栈，执行的时候，从栈里面取，取的第一个肯定是sub（2，3）吧？于是就计算出等于5，继续取，取出了int c =，然后就和5对接上了，就把值赋给c了。这只是一个小例子。
道理是这样，但是具体的存取可不是这样的哦。具体的存取应该分的非常细腻，应该是按照java语法的最小单位来往栈里存取的。说白了一句话，程序运行的时候的先后顺序是跟人大脑想问题的顺序一样的，但是代码不是按照这样的顺序写的（从左到右），于是就用栈结构来达到这样的效果。
这么说，明白了吗？
java语言的完整进站出站程序
楼主要java出栈进栈代码的究竟是一个栈的程序，还是要一段能够实现中缀变成后缀的程序？我这里有一份作业。也许你有用。
文件CharStackD.java:
/**
* 用数组实现的栈。能够设置栈所使用数组的大小
*/
public class CharStackD {
char[] ch;
int top;
//构造函数
public CharStackD() {
ch = new char[10];
int top = -1;
}
public CharStackD(int n) {
ch = new char[n];
int top = -1;
}
public CharStackD(char c) {
ch = new char[10];
int top = 0;
ch[top] = c;
}
public CharStackD(int n,char c) {
ch = new char[n];
int top = 0;
ch[top] = c;
}
//压栈
public boolean push(char c) {
top++;
if (top == ch.length)
return false;
ch[top] = c;
return true;
}
//出栈
public char pop() {
if (top == -1)
return ' ';
return ch[top--];
}
//查询栈是否为空
public boolean isEmpty() {
if (top == -1) return true;
return false;
}
//查询栈是否已满
public boolean isFull() {
if (top == ch.length) return true;
return false;
}
}
文件java出栈进栈代码：ConvertMToB.java
/**
* 此程序的功能是将中缀表达式转换成后缀表达式。程序使用了一个堆栈。转换
* 的方法：当读到字母时直接输出；当读到加减乘除号时，有三种情况，一是栈空，
* 将符号压入栈中，二是当前符号比栈顶的符号优先级低，将栈顶符号弹出并根据
* 当前符号与栈顶符号的情况决定下一步的操作，三是当前符号比栈顶的符号优先
* 级高，将当前符号压栈；遇到左括号入栈；遇到右括号将左右括号之间的符号全
* 部出栈，同时略去括号。
* 假定中缀表达式已经被事先存放于s1中。
*/
public class ConvertMToB {
//事先存入的表达式
static String s1 = "a+b*(c/d)-e/f";
//主程序
public static void main(String arg[]) {
//s2用于输出结果
String s2 = "";
int current = 0;
CharStackD stack = new CharStackD();
char c;
//按字符扫描s1
while (currents1.length()) {
c = s1.charAt(current);
//扫描到字符，直接输出
if ((c = 'a') (c = 'z')) s2 += c;
//扫描到左括号，入栈
if (c == '(') stack.push(c);
//扫描到右括号，输出括号间的符号
if (c == ')') {
for(;;) {
char out = stack.pop();
if (out == '(') break;
else {
if (out == ' ') {
System.out.println("Wrong in " + s1);
System.exit(0);
}
s2 += out;
}
}
}
//扫描到加减乘除号
if ("+-*/".indexOf((int)c) -1) {
//栈空，入栈
if (stack.isEmpty()) {
stack.push(c);
current++;
continue;
}
//扫描到加减号
if ("+-".indexOf((int)c) -1) {
char topChar = stack.pop();
if (topChar == '(') stack.push(topChar);
for (int i = 0;i = 1;i++) {
if ("+-*/".indexOf((int)topChar) -1) s2 += topChar;
topChar = stack.pop();
if (topChar == '(') {
stack.push(topChar);
break;
}
}
stack.push(c);
}
//扫描到乘除号
else {
char topChar = stack.pop();
if (topChar == '(')
stack.push(topChar);
else {
if ("*/".indexOf((int)topChar) -1)
s2 += topChar;
else {
stack.push(topChar);
}
}
stack.push(c);
}
}
//扫描下一个字符
current++;
}
//清理栈内剩余的符号
while (!(stack.isEmpty())) {
s2 += stack.pop();
}
//输出结果
System.out.println("Middle Style: "+s1+"\nBackwards Style: "+s2);
}
}
我要用java实现一个栈，基本操作就是出栈入栈。请问如何实现效率比较高。
//这是JDK提供的栈
import java.util.Stack;
public class UsingStack {
public static void main(String[] args) {
//构造栈对象，使用类型限制，只能存储Integer数据
StackInteger s = new StackInteger();
//1、2、3依次入栈
s.push(1);
s.push(2);
s.push(3);
//3、2、1依次出栈
System.out.println(s.pop());
System.out.println(s.pop());
System.out.println(s.pop());
}
}
//这是我写的顺序结构的栈
import java.util.EmptyStackException;
import java.util.Vector;
public class UsingStack{
public static void main(String[] args){
//构造栈对象，使用类型限制，只能存储Integer数据
MyStackInteger s = new MyStackInteger();
//1、2、3依次入栈
s.push(1);
s.push(2);
s.push(3);
//3、2、1依次出栈
System.out.println(s.pop());
System.out.println(s.pop());
System.out.println(s.pop());
}
}
/**
* 栈类
* @author developer_05
* @param T
*/
class MyStackT extends VectorT{
/**
* 构造方法
*/
public MyStack(){
}
/**
* 入栈方法
* @param item 待入栈的元素
* @return 返回入栈的元素
*/
public T push(T item) {
addElement(item);
return item;
}
/**
* 出栈方法(同步处理)
* @return 返回出栈元素
*/
public synchronized T pop() {
T obj;
int len = size();
if (len == 0)
throw new EmptyStackException();
obj = elementAt(len - 1);
removeElementAt(len - 1);
return obj;
}
/**
* 判断栈是否为空的方法
* @return 返回true(栈空)或false(栈非空)
*/
public boolean empty() {
return size() == 0;
}
private static final long serialVersionUID = 1L;
}
java出栈进栈代码的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java方法入栈出栈、java出栈进栈代码的信息别忘了在本站进行查找喔。
