java出栈入栈代码 java进栈出栈

Java如何实现出栈入栈并获取栈中最小值的程序

你得明白栈的定义。代码执行的时候是执行一个方法，执行完，返回方法的上一个代码块继续往下执行后面的内容。这样的话是不是就是一个栈结构了？先进后出。方法一边执行，一边往栈里面存数据，等执行完了就取出数据（取出的是返回值，是最后一个存进去的 栈结构是后进先出），然后执行外面的代码。这么说你可能不明白，我给你举个例子。

专注于为中小企业提供做网站、网站设计服务,电脑端+手机端+微信端的三站合一,更高效的管理,为中小企业井陉矿免费做网站提供优质的服务。我们立足成都，凝聚了一批互联网行业人才，有力地推动了上1000家企业的稳健成长，帮助中小企业通过网站建设实现规模扩充和转变。

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 作业 编写固定长度栈和动态栈，完成入栈和出栈。（注：测试接口。）

//栈接口

/**

* 2016/10/31 10:19

*

* @author 3306 TODO

*/

public interface StackInterfaceT {

/**

* 压入元素

*

* @param element 元素

*/

void push(T element);

/**

* 弹出栈顶元素

*

* @return T

*/

T pop();

}

//固定长度栈

/**

* 2016/10/31 10:03

*

* @param T 压入元素类型

* @author 3306 TODO 固定长度栈

*/

public class FixedStackT implements StackInterfaceT{

private Object[] objects = new Object[10];

private int index = 0;

/**

* 往固定长度栈压入元素

*

* @param element 元素

* @throws IndexOutOfBoundsException 压缩元素大于栈的容量的时候

*/

public void push(T element) {

if (index  objects.length) {

throw new IndexOutOfBoundsException();

}

objects[index++] = element;

}

/**

* 弹出栈顶元素

*

* @return T

*/

public T pop() {

if (index  0) {

throw new IndexOutOfBoundsException();

}

return (T) objects[--index];

}

}

//动态栈

import java.util.ArrayList;

import java.util.List;

/**

* 2016/10/31 10:23

*

* @author 3306 TODO

*/

public class FreeStackT implements StackInterfaceT {

private ListT storage = new ArrayList();

private int index = 0;

@Override

public void push(T element) {

if (null == element) {

throw new IllegalArgumentException();

}

storage.add(element);

index++;

}

@Override

public T pop() {

if (index  0) {

throw new IndexOutOfBoundsException();

}

return storage.get(--index);

}

}

//student类

/**

* 2016/10/31 10:11

*

* @author 3306 TODO

*/

public class Student {

private int studentNo;

private String studentName;

public int getStudentNo() {

return studentNo;

}

public void setStudentNo(int studentNo) {

this.studentNo = studentNo;

}

public String getStudentName() {

return studentName;

}

public void setStudentName(String studentName) {

this.studentName = studentName;

}

@Override

public String toString() {

return "Student{" +

"studentNo=" + studentNo +

", studentName='" + studentName + '\'' +

'}';

}

}

//测试类

/**

* 2016/10/31 10:12

*

* @author 3306 TODO

*/

public class TestStack {

public static void main(String[] args) {

testStableStack();

testFreeStack();

}

private static void testStableStack() {

System.out.println("\n\n----------- fixed ------------");

StackInterfaceStudent myStack = new FixedStack();

int numOfStudent = 3;

for (int index = 0; index  numOfStudent; index++) {

Student stu = new Student();

stu.setStudentNo(index);

stu.setStudentName("stu" + index);

myStack.push(stu);

}

for (int index = 0; index  numOfStudent; index++) {

System.out.println(myStack.pop());

}

}

private static void testFreeStack() {

System.out.println("\n\n----------- free ------------");

StackInterfaceStudent freeStack = new FreeStack();

int numOfStudent = 5;

for (int index = 0; index  numOfStudent; index++) {

Student stu = new Student();

stu.setStudentNo(index);

stu.setStudentName("stu" + index);

freeStack.push(stu);

}

for (int index = 0; index  numOfStudent; index++) {

System.out.println(freeStack.pop());

}

}

}

我要用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;

}