堆栈实现代码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());
}
}
文章标题:堆栈实现代码java 堆栈类的设计与实现
标题网址:http://scyanting.com/article/hhsehp.html