锐客网

  1. 首页 > 睿知 > it技术 > >

java出栈进栈代码 java方法入栈出栈

IT技术public

关于数据结构（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 = https://www.04ip.com/post/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 = https://www.04ip.com/post/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出栈进栈代码的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java方法入栈出栈、java出栈进栈代码的信息别忘了在本站进行查找喔 。

    推荐阅读


    上一篇：硬盘坏了怎么重装系统，硬盘坏了还能做系统吗

    下一篇：安卓自定义服务器，安卓自定义服务器怎么设置