① 仅使用Stack类中的构造函数、push()、peek（）、pop()、以及empty()等方法实现任意长度数组的逆序
// stack.java
// demonstrates stacks
// to run this program: C>java StackApp
////////////////////////////////////////////////////////////////
class StackX
{
private int maxSize; // size of stack array
private long[] stackArray;
private int top; // top of stack
//--------------------------------------------------------------
public StackX(int s) // constructor
{
maxSize = s; // set array size
stackArray = new long[maxSize]; // create array
top = -1; // no items yet
}
//--------------------------------------------------------------
public void push(long j) // put item on top of stack
{
stackArray[++top] = j; // increment top, insert item
}
//--------------------------------------------------------------
public long pop() // take item from top of stack
{
return stackArray[top--]; // access item, decrement top
}
//--------------------------------------------------------------
public long peek() // peek at top of stack
{
return stackArray[top];
}
//--------------------------------------------------------------
public boolean isEmpty() // true if stack is empty
{
return (top == -1);
}
//--------------------------------------------------------------
public boolean isFull() // true if stack is full
{
return (top == maxSize-1);
}
public void tofun(long a,long b,long c,long d,long e,long f,long g,long h,long i,long k)
{
push(a);
push(b);
push(c);
push(d);
push(e);
push(f);
push(g);
push(h);
push(i);
push(k);
}
}
class StackApp
{
public static void main(String[] args)
{
StackX stackX=new StackX(10);
stackX.tofun(1,2,3,4,5,6,7,8,9,10);
while( !stackX.isEmpty() ) // until it's empty,
{ // delete item from stack
long value = stackX.pop();
System.out.print(value); // display it
System.out.print(" ");
} // end while
System.out.println("");
}
}
② 小菜鸟求教Java stack的实现问题
stack类修改一下就行了，修改处见注释
staticclassstack
{
Nodetop;
Objectpop()
{
if(top!=null)
{
Objecttopdata=top.data;
top=top.next;
returntopdata;
}
returnnull;
}
voidpush(Objecttopdata)
{
//Nodet=newNode((Integer)topdata);你push的是node,这边当int处理，自然错了
Nodet=(Node)topdata;
t.next=top;
top=t;
}
Objectpeek()
{
if(top!=null)
{
returntop.data;
}
//这边再加个判断，不过对于运行期异常，不处理也是可以的
else
{
returnnull;
}
}
}
③ 用JAVA编写一个程序，希望有注释，但不要太简单，不要在别的地方复制，急用！
/**
* GenericLinkedStack.java
*/
package fix;
import java.util.EmptyStackException;
/**
*泛型的链式栈数据结构
*/
public class GenericLinkedStack<E> {
// 栈顶元素
private Item top = null;
// 返回栈顶元素，并弹出
public E pop() throws EmptyStackException {
if (isEmpty()) {
throw new EmptyStackException();
}
E e = top.value;
top = top.next;
return e;
}
/**
* 栈顶压入一个元素
* @param e 被压入的元素
*/
public void push(E e) {
Item curr = new Item(e);
curr.next = top;
top = curr;
}
/**
* 返回栈顶元素，但不出栈
* @return 栈顶元素
*/
public E peek() {
if (isEmpty()) {
throw new EmptyStackException();
}
return top.value;
}
/**
* 判断栈是否为空
* @return 判断结果
*/
public boolean isEmpty() {
return top == null;
}
/**
* 栈中元素
* @author jilen
*
*/
class Item {
//元素
private E value;
//下一个
private Item next;
public Item(E e) {
this.value = e;
}
public E getValue() {
return value;
}
public void setValue(E value) {
this.value = value;
}
public Item getNext() {
return next;
}
public void setNext(Item next) {
this.next = next;
}
}
}
/**
* InfixToPostfixConverter.java
*/
package fix;
import java.util.Hashtable;
/**
* @author jilen
*
*/
public class InfixToPostfixConverter {
// 操作符及其优先级组成的键值对
private static final Hashtable<Character, Integer> operators;
private StringBuffer infix;
private StringBuffer postfix;
GenericLinkedStack<Character> stack = new GenericLinkedStack<Character>();
// 初始化操作符列表，static语句块会在加载类时自动执行
static {
operators = new Hashtable<Character, Integer>();
operators.put('^', 4);
operators.put('*', 3);
operators.put('/', 3);
operators.put('%', 3);
operators.put('+', 2);
operators.put('-', 2);
operators.put('(', -1);
operators.put(')', 5);
}
/**
*
*/
public InfixToPostfixConverter(StringBuffer infix, StringBuffer postfix) {
this.infix = infix;
this.postfix = postfix;
}
/**
* 转换函数
*/
public void convertToPostfix() {
// 对输入字符串中字符遍历
for (int i = 0, n = infix.length(); i < n; i++) {
char c = infix.charAt(i);
// 是数字之间添加到转换后字符串
if (isNumber(c)) {
postfix.append(c);
} else if (isOperator(c)) {
switch (c) {
// '(' 直接入栈
case '(':
stack.push(c);
break;
// ')' 弹出元素直到碰到'('
case ')':
while (!stack.isEmpty() && stack.peek() != '(') {
postfix.append(stack.pop());
}
stack.pop();
break;
// 其他操作符
default:
// 当前操作符比栈顶操作符优先级高，直接入栈
if (stack.isEmpty() || precedence(c, stack.peek())) {
stack.push(c);
}
// 当前操作符比栈顶操作符优先级低，出栈直到为空或栈顶优先级低于当前操作符
else if (!precedence(c, stack.peek())) {
while (!stack.isEmpty() && !precedence(c, stack.peek())) {
postfix.append(stack.pop());
}
stack.push(c);
}
break;
}
}
}
// 若栈中还有操作符，所以元素出栈
while (!stack.isEmpty()) {
postfix.append(stack.pop());
}
}
/**
* 判断是否为操作符
* @param c
* @return
*/
public static boolean isOperator(char c) {
return operators.containsKey(c);
}
/**
* 优先级大小关系operator1 > operator2 则返回true，否则false
* @param operator1
* @param operator2
* @return 判断结果
*/
public static boolean precedence(char operator1, char operator2) {
return operators.get(operator1) > operators.get(operator2);
}
/**
* 是否数字
* @param c 要判断的字符
* @return 判断结果
*/
public static boolean isNumber(char c) {
return c >= '0' && c <= '9';
}
}
/**
*Main.java测试类
*/
package fix;
/**
* @author Administrator
*
*/
public class Main {
/**
* @param args
*/
public static void main(String[] args) {
StringBuffer infix = new StringBuffer("(1+2)*3/4");
StringBuffer postfix = new StringBuffer();
InfixToPostfixConverter converter = new InfixToPostfixConverter(infix,
postfix);
converter.convertToPostfix();
System.out.println(postfix.toString());
}
}
中缀转后缀的程序，有GenericLinkedStack.java,InfixToPostfix.java,Main.java三个源文件需要放在fix包下
④ 用java编写出来：用数组实现一个栈
} } 使用java中Stack类.跟数据结构中的栈是一个意思。 不用Stack,直接new一个长度为10的数组就可以了
⑤ java Collection ArrayStack 的问题...
粗略的看了一下，
for(int i=0; i<6; i++)
stack.push(i*2);
这一步会调用
if(!isFull()) ---> if((top+1) == stackSize)----->elements= new Object[top];数组会被创建5次(01234)
数组第一次被创建是emements=new Object[0];这样会抛出异常。假如没抛出异常：
只有第五次的elements[4]=8,会被存入数组，其他elements[0]elements[1]elements[2]elements[3]没有值，默认为0（你的是Object，不一定为零，先看成0）。所以elements={0，0，0，0，8}
之后System.out.print(stack.pop() + " "); 应该会输出0 (elements[3])
错了两点不该每次都创建elements数组；不该在pop中将top--后输出var,要反过来。
最好将Object数组改成Integer数组，这样测试。
⑥ c++堆栈中 top（） pop（）的具体作用是什么
top()是将指针置于堆栈顶部pop（）是从堆栈中提取数据
⑦ 关于数据结构（java）的一个代码
描述栈抽象数据类型的SStack接口的声明
public interfaceSStack<E> //栈接口
{
boolean isEmpty(); //判断是否空栈，若空栈返回true
boolean push(E element); //元素element入栈，若操作成功返回true
E pop(); //出栈，返回当前栈顶元素，若栈空返回null
E get(); //取栈顶元素值，未出栈，若栈空返回null
}
顺序栈类具体操作方法的声明：
importdataStructure.linearList.SStack;
public classSeqStack<E> implements SStack<E>
//顺序栈类
{
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; i<temp.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[])
{
SeqStack<String> stack = newSeqStack<String>(20);
System.out.print("Push: ");
char ch='a';
for(int i=0;i<5;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 里面“堆栈”的简单解释，通俗例子！
java堆栈类源程序import java.util.LinkedList;import java.io.*;import java.util.NoSuchElementException;/** * * @version 1.00 06/12/19 */public class MStack { LinkedList list; public MStack() { list=new LinkedList(); } public static void main(String[] args) { MStack MStack=new MStack(); MStack.push("ok"); MStack.push("i am ok"); System.out.println(MStack.pop()); System.out.println(MStack.pop()); System.out.println(MStack.pop()); } //弹出元素 public Object pop() { try { Object o=list.getFirst(); list.removeFirst(); return o; } catch(NoSuchElementException e) { //System.out.println(e); return null; } } //压入元素 public void push(Object o) { list.addFirst(o); } //得到栈顶元素 public Object getTop() { if(list.size()!=0) { return list.getFirst(); } else { return null; } } }Junit测试程序import junit.framework.*;public class TestMStack extends TestCase{ MStack s=new MStack(); public TestMStack(String name) { super(name); } public void setUp() { } public void testCase1() { MStack MStack=new MStack(); s.push("ok"); MStack.push("ok"); Assert.assertEquals(s.getTop(),MStack.getTop()); } public static void main(String[] args) { junit.textui.TestRunner.run(TestMStack.class); } }// http://blog.csdn.net/wfisone/archive/2009/05/09/4163778.aspx