堆栈实现代码java 堆栈类的设计与实现

怎么用java代码实现栈内存?

使用java.util包中的Stack类创建一个栈对象

创新互联-专业网站定制、快速模板网站建设、高性价比北安网站开发、企业建站全套包干低至880元,成熟完善的模板库,直接使用。一站式北安网站制作公司更省心,省钱,快速模板网站建设找我们，业务覆盖北安地区。费用合理售后完善，十载实体公司更值得信赖。

public Object push(Object data);输入数据，实现压栈

public Object pop();输出数据，实现弹栈

public boolean empty()判空

public Object peek();查看栈顶元素

可以去查查API嘛

我也是学java的，大家一起进步。

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代码编写堆栈?

参看： 1 import java.util.*; 2 3 public class TestStack { 4 public static void main(String[] args) { 5 Stack stack = new Stack(); 6 7 for(int i = 0; i 10; i++) { 8 stack.push(new Integer(i)); 9 }1011 if(!stack.empty()) {12 System.out.println(stack.pop());13 }14 }15 }

用一维整数数组实现数据结构中的堆栈(Stack)。（用java语言）

public class IntStack {

private int[] stack;

private int top;

/**

*初始化栈，传入一个非负的整数，否则抛出一个错误

*/

public IntStack(int size) throws StackErrorException{

if(size0){

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 堆栈Stack使用

java中stack的使用方法，堆栈是一种"后进先出"（LIFO） 的数据结构， 只能在一端进行插入（称为"压栈"） 或删除 （称为"出栈"）数据的操作,下面看示例：

JAVA 中，使用 java.util.Stack 类的构造方法创建对象。

public class Stack extends vector

构造方法 ： public Stack() 创建一个空 Stack。

方法：

1. public push （item ） 把项 压入栈顶。其作用与 addElement (item ) 相同。

参数 item 压入栈顶的项 。 返回： item 参数 ；

2. public pop () 移除栈顶对象，并作为函数的值 返回该对象。

返回：栈顶对象（Vector 对象的中的最后一项）。

抛出异常 ： EmptyStackException 如果堆栈式空的 。。。

3. public peek() 查看栈顶对象而不移除它。。

返回：栈顶对象（Vector 对象的中的最后一项）。

抛出异常 ： EmptyStackException 如果堆栈式空的 。。。

4. public boolean empty （测试堆栈是否为空。） 当且仅当堆栈中不含任何项时 返回 true，否则 返回 false.

5. public int search (object o) 返回对象在堆栈中位置， 以 1 为基数， 如果对象 o是栈中的一项，该方法返回距离　栈顶最近的出现位置到栈顶的距离；　栈中最上端项的距离为　1　。

java语言中用LinkList实现堆栈

栈和队列是两种特殊的线性表，它们的逻辑结构和线性表相同，只是其运算规则较线性表有更多的限制，故又称它们为运算受限的线性表。

LinkedList数据结构是一种双向的链式结构，每一个对象除了数据本身外，还有两个引用，分别指向前一个元素和后一个元素，和数组的顺序存储结构（如：ArrayList）相比，插入和删除比较方便，但速度会慢一些。

栈的定义

栈（Stack）是限制仅在表的一端进行插入和删除运算的线性表。

(1)通常称插入、删除的这一端为栈顶（Top），另一端称为栈底（Bottom）。

(2)当表中没有元素时称为空栈。

(3)栈为后进先出（Last In First Out）的线性表，简称为LIFO表。

栈的修改是按后进先出的原则进行。每次删除（退栈）的总是当前栈中"最新"的元素，即最后插入（进栈）的元素，而最先插入的是被放在栈的底部，要到最后才能删除。

实现代码：

package com.weisou.dataStruct;

import java.util.LinkedList;

@SuppressWarnings("unchecked")

public class MyStack {

LinkedList linkList = new LinkedListObject();

public void push(Object object) {

linkList.addFirst(object);

}

public boolean isEmpty() {

return linkList.isEmpty();

}

public void clear() {

linkList.clear();

}

// 移除并返回此列表的第一个元素

public Object pop() {

if (!linkList.isEmpty())

return linkList.removeFirst();

return "栈内无元素";

}

public int getSize() {

return linkList.size();

}

public static void main(String[] args) {

MyStack myStack = new MyStack();

myStack.push(2);

myStack.push(3);

myStack.push(4);

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

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

}

}

队列定义

队列（Queue）是只允许在一端进行插入，而在另一端进行删除的运算受限的线性表

（1）允许删除的一端称为队头（Front）。

（2）允许插入的一端称为队尾（Rear）。

（3）当队列中没有元素时称为空队列。

（4）队列亦称作先进先出（First In First Out）的线性表，简称为FIFO表。

实现代码：

package com.weisou.dataStruct;

import java.util.LinkedList;

/**

*

* @author gf

* @date 2009-11-13

*/

public class MyQueue {

LinkedList linkedList = new LinkedList();

//队尾插

public void put(Object o){

linkedList.addLast(o);

//队头取 取完并删除

public Object get(){

if(!linkedList.isEmpty())

return linkedList.removeFirst();

else

return "";

}

public boolean isEmpty(){

return linkedList.isEmpty();

}

public int size(){

return linkedList.size();

}

public void clear(){

linkedList.clear();

}

/**

* @param args

*/

public static void main(String[] args) {

MyQueue myQueue= new MyQueue();

myQueue.put(1);

myQueue.put(2);

myQueue.put(3);

System.out.println(myQueue.get());

}

}