用java實現棧_我要用java實現一個棧基本操作就是出棧入棧請問如何實現效率比較高

㈠用一維整數數組實現數據結構中的堆棧(Stack)。（用java語言）

public class IntStack {

private int[] stack;
private int top;

/**
*初始化棧，傳入一個非負的整數，否則拋出一個錯誤
*/
public IntStack(int size) throws StackErrorException{
if(size<0){
throw new StackErrorException("錯誤的大小");
}

init(size);
}

private void init(int size) {
stack = new int[size];
top = 0;
}

/**
*判斷棧是否為空，true則為空，反之則反
*/
public boolean isEmpty(){
return top==0;
}

/**
*判斷棧是否已滿，true則已滿，反之則反
*/
public boolean isFull(){
return top==stack.length;
}
/**
*向棧頂添加元素，滿則拋出異常
*/
public void push(int value) throws StackErrorException{
if(isFull()){
throw new StackErrorException("棧已滿");
}
stack[top++] = value;
}
/**
*移除棧頂元素並返回，空則拋出異常
*/
public int pop() throws StackErrorException{
if(isEmpty()){
throw new StackErrorException("已到棧底!");
}
return stack[--top];
}
/**
*返回棧頂元素，空則拋出異常
*/
public int peek() throws StackErrorException{
if(isEmpty()){
throw new StackErrorException("已在棧底!");
}
return stack[top-1];
}
/**
*返回棧大小
*/
public int size(){
return stack.length;
}
class StackErrorException extends Exception{
public StackErrorException(String msg) {
super(msg);
}
}
}

㈡哪位高手可以用 java數組實現棧,當棧滿時，棧空間增加一倍

public class Stack{
private static final int INIT_SIZE=10;
private int[] elements;
private int top;
public Stack(){
elements=new int[INIT_SIZE];
top=0;
}
public void push(int data){
if(elements.length==top){
int[] newElements=new int[elements.length*2];
for(int i=elements.length-1;i>=0;i--){
newElements[i]=elements[i];
}
elements=newElements;
}
elements[top++]=data;
}
int pop(){
return elements[--top];
}
}

㈢ 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;
}

㈣跪求用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】寫一個類，實現棧這種數據結構，要求底層數據使用ArrayList存儲。

棧的特點的就是後進先出,那麼你就linkedList,如果要添加一個元素,就把他存到最後一個位置,要取一個元素,也從最後開始取就可以實現了,只有linkedList才有存,取,刪最後一個元素這個方法,所以要要用linkedList
代碼如下:
public
class
StudyTest
{
private
LinkedList
list
=
new
LinkedList
();
public
String
get()
{
return
list.getLast();
}
public
void
add(String
str)
{
this.list.addLast(str);
}
public
void
remove(){
this.list.removeLast();
}
}

㈥用java編寫出來：用數組實現一個棧

public class Stack {
private Object[] stack;
//這個不需要;
//private int top = 0; //初始化棧頂
//這個也不需要;
//寫一個棧出來,最好是可以動態的,可以自己改變大小的,即數組的長度;
//private int size = 0; // 初始化大小

//元素個數;
private int size;

//默認長度為10;
public Stack(){
this(10);
}

//也可以自己設置長度,即容量;
public Stack(int len){
stack = new Object[len];
}

//返回元素個數;
public int size(){
return size;
}

//返回數組長度,即容量;
public int capacity(){
return stack.length;
}

//實現動態的數組;
public void ensureCapacity(){
if(size() == capacity()){
Object[] newStack = new Object[size() * 3 / 2 + 1];
System.array(stack, 0, newStack, 0, size());
stack = newStack;
}
}

//入棧;
public void push(Object o){
size++;
ensureCapacity();
stack[size - 1] = o;
}

/*
public void push(Object object) {
if (isFull()) {
System.out.println("棧滿! 入棧失敗");
}
stack[top++] = object;
}
*/

//判空;
public boolean isEmpty(){
return size == 0;
}

//出棧;
public Object pop(){
//首先要判空;
if(isEmpty()){
throw new ("不能為空");
}

Object o = stack[--size];
stack[size] = null;
return o;
}

/*
// 出棧
public Object pop() {
Object object = stack[--top];
stack[top] = null;
return object;
}
*/

/*
// 計算棧當前大小
public int size() {
return top;
}

// 判斷是否是空棧
public boolean isEmpey() {
return top == 0;
}

// 判斷是否棧滿
public boolean isFull() {
return top >= size;
}

public Stack(int size) {
this.size = size;
}
*/

public static void main(String[] args) {
Stack stack = new Stack(3);
String[] data = new String[] { "a", "b", "c" };
for (int i = 0; i < data.length; i++) {
stack.push(data[i]);
System.out.println(data[i] + "");
}
System.out.println("***********");
while (!stack.isEmpty()) {
System.out.println(stack.pop() + "");
}
//}
}
}
你自己對比一下,我是在你的裡面修改的

㈦用java編寫程序，利用線程同步編寫一個棧操作程序，包括數據的進棧和出棧。

Stack.java

importjava.util.concurrent.locks.Condition;
importjava.util.concurrent.locks.Lock;
importjava.util.concurrent.locks.ReentrantLock;

publicclassStack{

privateint[]data;
privateintindex;
privateLocklock;
privateConditionmoreSpace;
privateConditionmoreEelment;

publicStack(intsize){
this.data=newint[size];
this.index=0;
this.lock=newReentrantLock();
this.moreSpace=lock.newCondition();
this.moreEelment=lock.newCondition();
}

publicvoidpush(intvalue){
lock.lock();
try{
while(index==data.length){
moreSpace.await();
}
data[index++]=value;
moreEelment.signalAll();
}catch(InterruptedExceptione){
e.printStackTrace();
}finally{
lock.unlock();
}
}

publicintpopup(){
lock.lock();
intvalue=0;
try{
while(index==0){
moreEelment.await();
}
value=data[--index];
moreSpace.signalAll();
}catch(InterruptedExceptione){
e.printStackTrace();
}finally{
lock.unlock();
}
returnvalue;
}
}

寫入線程 WriteStack.java

importjava.util.Random;

{

privateStackstack;

publicWriteStack(Stackstack){
this.stack=stack;
}

@Override
publicvoidrun(){
Randomr=newRandom(System.currentTimeMillis());
for(inti=0;i<10;i++){
intvalue=r.nextInt(500);
stack.push(value);
System.out.printf("Write:push%dinstack
",value);
try{
Thread.sleep(r.nextInt(500));
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
}

}

讀取線程 ReadStack.java

importjava.util.Random;

{

privateStackstack;

publicReadStack(Stackstack){
this.stack=stack;
}

@Override
publicvoidrun(){
Randomr=newRandom(System.currentTimeMillis());
for(inti=0;i<10;i++){
intvalue=stack.popup();
System.out.printf("Read:popupanelement%d
",value);
try{
Thread.sleep(r.nextInt(500));
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
}
}

主測試線程 StackExample.java

publicclassStackExample{
publicstaticvoidmain(String[]args)throwsInterruptedException{
Stackstack=newStack(5);
WriteStackwriteStack=newWriteStack(stack);
ReadStackreadStack=newReadStack(stack);

ThreadwriteThread=newThread(writeStack);
ThreadreadThread=newThread(readStack);
writeThread.start();
readThread.start();
}
}

㈧我要用java實現一個棧，基本操作就是出棧入棧。請問如何實現效率比較高。

java的list的子類裡面有個叫vector，這個下面有個叫做stack，可以實現！你去看看看

㈨ Java中棧的使用

和C++裡面一樣，有入棧，彈棧，查找函數
import java.util.*;(引入包含棧類的頭文件)
相關函數介紹
boolean empty()
測試堆棧是否為空。
E peek()
查看堆棧頂部的對象，但不從堆棧中移除它。
E pop()
移除堆棧頂部的對象，並作為此函數的值返回該對象。
E push(E item)
把項壓入堆棧頂部。
int search(Object o)
返回對象在堆棧中的位置，以 1 為基數。

導航:首頁 > 編程語言 > 用java實現棧

用java實現棧

與用java實現棧相關的資料