栈的java实现

⑴ 求助!如何用java编写一个栈

可以利用LinkedList 来写一个栈. 例如

import java.util.* ;

public class testStack{

private LinkedList list = new LinkedList() ;

public void push(Object o ){

try{

list.addFirst( o ) ;
}catch(Exception e){

}
}

public Object pop(){

return list.removeFirst() ;

}

public Object top() {

return list.getLast() ;
}

public static void main(String[] args){

//code here
testStack s = new testStack() ;
for( int i = 0 ; i<10 ;i++){

s.push( i );

}

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

System.out.println(s.top());
}
}

你可以好好看看Thinking in JAVA中对集合的讲解。。

⑵ 跪求用JAVA语言实现一个栈和一个队列，数据元素为double型。。。具体在问题补充里

publicinterfaceMyStack<T>{
	/**
	*判断栈是否为空
	*/
	booleanisEmpty();
	/**
	*清空栈
	*/
	voidclear();
	/**
	*栈的长度
	*/
	intlength();
	/**
	*数据入栈
	*/
	booleanpush(Tdata);
	/**
	*数据出栈
	*/
	Tpop();
}
publicclassMyArrayStack<T>implementsMyStack<T>{
	privateObject[]objs=newObject[16];
	privateintsize=0;

	@Override
	publicbooleanisEmpty(){
		returnsize==0;
	}

	@Override
	publicvoidclear(){
		//将数组中的数据置为null,方便GC进行回收
		for(inti=0;i<size;i++){
			objs[size]=null;
		}
		size=0;
	}

	@Override
	publicintlength(){
		returnsize;
	}

	@Override
	publicbooleanpush(Tdata){
		//判断是否需要进行数组扩容
		if(size>=objs.length){
			resize();
		}
		objs[size++]=data;
		returntrue;
	}

	/**
	*数组扩容
	*/
	privatevoidresize(){
		Object[]temp=newObject[objs.length*3/2+1];
		for(inti=0;i<size;i++){
			temp[i]=objs[i];
			objs[i]=null;
		}
		objs=temp;
	}

	@SuppressWarnings("unchecked")
	@Override
	publicTpop(){
		if(size==0){
			returnnull;
		}
		return(T)objs[--size];
	}

	@Override
	publicStringtoString(){
		StringBuildersb=newStringBuilder();
		sb.append("MyArrayStack:[");
		for(inti=0;i<size;i++){
			sb.append(objs[i].toString());
			if(i!=size-1){
				sb.append(",");
			}
		}
		sb.append("]");
		returnsb.toString();
	}
}
//栈的链表实现
publicclassMyLinkedStack<T>implementsMyStack<T>{
	/**
	*栈顶指针
	*/
	privateNodetop;
	/**
	*栈的长度
	*/
	privateintsize;
	
	publicMyLinkedStack(){
		top=null;
		size=0;
	}
	
	@Override
	publicbooleanisEmpty(){
		returnsize==0;
	}
	
	@Override
	publicvoidclear(){
		top=null;
		size=0;
	}
	
	@Override
	publicintlength(){
		returnsize;
	}
	
	@Override
	publicbooleanpush(Tdata){
		Nodenode=newNode();
		node.data=data;
		node.pre=top;
		//改变栈顶指针
		top=node;
		size++;
		returntrue;
	}
	
	@Override
	publicTpop(){
		if(top!=null){
			Nodenode=top;
			//改变栈顶指针
			top=top.pre;
			size--;
			returnnode.data;
		}
		returnnull;
	}
	
	/**
	*将数据封装成结点
	*/
	privatefinalclassNode{
		privateNodepre;
		privateTdata;
	}
}

⑶ 我要用java实现一个栈，基本操作就是出栈入栈。请问如何实现效率比较高。

//这是JDK提供的栈

import java.util.Stack;

public class UsingStack {
public static void main(String[] args) {
//构造栈对象，使用类型限制，只能存储Integer数据
Stack<Integer> s = new Stack<Integer>();

//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数据
MyStack<Integer> s = new MyStack<Integer>();

//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 MyStack<T> extends Vector<T>{
/**
* 构造方法
*/
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;
}