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
文章标题：java顺序栈的完整代码 顺序栈的初始化完整代码
标题来源：http://6mz.cn/article/hphosi.html