java顺序栈的完整代码 顺序栈的初始化完整代码

关于数据结构（java）的一个代码

描述栈抽象数据类型的SStack接口的声明

创新互联建站专注于企业全网营销推广、网站重做改版、尼玛网站定制设计、自适应品牌网站建设、html5、成都做商城网站、集团公司官网建设、外贸网站建设、高端网站制作、响应式网页设计等建站业务，价格优惠性价比高，为尼玛等各大城市提供网站开发制作服务。

public interfaceSStackE //栈接口

{

boolean isEmpty(); //判断是否空栈，若空栈返回true

boolean push(E element); //元素element入栈，若操作成功返回true

E pop(); //出栈，返回当前栈顶元素，若栈空返回null

E get(); //取栈顶元素值，未出栈，若栈空返回null

}

顺序栈类具体操作方法的声明：

importdataStructure.linearList.SStack;

public classSeqStackE implements SStackE

//顺序栈类

{

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; itemp.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[])

{

SeqStackString stack = newSeqStackString(20);

System.out.print("Push: ");

char ch='a';

for(int i=0;i5;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语言实现一个栈和一个队列，数据元素为double型。。。具体在问题补充里

public interface MyStackT {

/**

 * 判断栈是否为空

 */

boolean isEmpty();

/**

 * 清空栈

 */

void clear();

/**

 * 栈的长度

 */

int length();

/**

 * 数据入栈

 */

boolean push(T data);

/**

 * 数据出栈

 */

T pop();

}

public class MyArrayStackT implements MyStackT {

private Object[] objs = new Object[16];

private int size = 0;

@Override

public boolean isEmpty() {

return size == 0;

}

@Override

public void clear() {

// 将数组中的数据置为null, 方便GC进行回收

for (int i = 0; i  size; i++) {

objs[size] = null;

}

size = 0;

}

@Override

public int length() {

return size;

}

@Override

public boolean push(T data) {

// 判断是否需要进行数组扩容

if (size = objs.length) {

resize();

}

objs[size++] = data;

return true;

}

/**

 * 数组扩容

 */

private void resize() {

Object[] temp = new Object[objs.length * 3 / 2 + 1];

for (int i = 0; i  size; i++) {

temp[i] = objs[i];

objs[i] = null;

}

objs = temp;

}

@SuppressWarnings("unchecked")

@Override

public T pop() {

if (size == 0) {

return null;

}

return (T) objs[--size];

}

@Override

public String toString() {

StringBuilder sb = new StringBuilder();

sb.append("MyArrayStack: [");

for (int i = 0; i  size; i++) {

sb.append(objs[i].toString());

if (i != size - 1) {

sb.append(", ");

}

}

sb.append("]");

return sb.toString();

}

}

//栈的链表实现

public class MyLinkedStackT implements MyStackT {

/**

 * 栈顶指针

 */

private Node top;

/**

 * 栈的长度

 */

private int size;

public MyLinkedStack() {

top = null;

size = 0;

}

@Override

public boolean isEmpty() {

return size == 0;

}

@Override

public void clear() {

top = null;

size = 0;

}

@Override

public int length() {

return size;

}

@Override

public boolean push(T data) {

Node node = new Node();

node.data = data;

node.pre = top;

// 改变栈顶指针

top = node;

size++;

return true;

}

@Override

public T pop() {

if (top != null) {

Node node = top;

// 改变栈顶指针

top = top.pre;

size--;

return node.data;

}

return null;

}

/**

 * 将数据封装成结点

 */

private final class Node {

private Node pre;

private T data;

}

}

栈与队列的实现(java)

import java.util.Stack;

public class Translate {

//程序入口

public static void main(String[]args){

int n = Translate.translate(3467,8);

System.out.println("结果是："+n);

}

public static int translate(int number, int base_num) {

//使用栈

StackIntegerstack = new StackInteger();

while(number0){

//压栈

stack.push(number % base_num);

number /= base_num;

}

int n = stack.size();

int val=0;

//依次出栈并合成结果（用我们熟悉的十进制表示，所以乘以10）

for(int i=0;in;i++){

val=val*10+stack.pop();

}

return val;

}

}

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

}

java 进栈

public StackX(int maxSize){

maxSize=maxSize;

stackarray=new long[maxSize];

top=-1;

}

不好意思，你犯了一个很傻的错误，这里应该是this.maxSize = maxSize,否则的话，你的实例变量maxSize还是没有被初始化为正确值，而只是默认值0