㈠ 用一维整数数组实现数据结构中的堆栈(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 为基数。