用java实现数据结构“栈

Java栈的实现

创新互联拥有网站维护技术和项目管理团队，建立的售前、实施和售后服务体系，为客户提供定制化的网站设计、成都网站制作、网站维护、电信机房托管解决方案。为客户网站安全和日常运维提供整体管家式外包优质服务。我们的网站维护服务覆盖集团企业、上市公司、外企网站、商城网站建设、政府网站等各类型客户群体，为全球成百上千家企业提供全方位网站维护、服务器维护解决方案。

public class MyStack { //定义一个堆栈类

int[] array; //用int数组来保存数据，根据需要可以换类型

int s_size; //定义堆栈的宽度

public MyStack(int i){ //定义一个带参数构造器

array=new int[i]; //动态定义数组的长度

s_size=0; //堆栈的默认宽度为0

}

public MyStack(){ //默认构造器

this(50); //默认构造器可容纳50个元素

}

public void push(int i){ //压栈

array[this.s_size]=i;

this.s_size++;

}

public int pop(){ //从堆栈中取元素，从栈顶开始取

if(this.s_size!=0){

int t=array[s_size-1]; //用中间变量保存栈顶的元素

array[s_size-1]=0; //取完元素该位置设为0

s_size--; //栈的大小减1

return t; //返回栈顶元素

}else{

System.out.println("This stack is empty"); //当栈为空时显示提示信息，返回0

return 0;

}

}

public boolean isEmpty(){ //判断栈是否为空

return this.s_size==0;

}

public int top(){ //从栈顶取值，功能和 pop() 方法一样

if(!this.isEmpty()){

int t=array[this.s_size-1];

array[this.s_size-1]=0;

this.s_size--;

return t;

}else{

System.out.println("This stack is empty!");

return 0;

}

}

public void printAll(){ //打印出堆栈中的所有元素的值，不是取出，元素依然在堆栈里

if(!this.isEmpty()){

for(int i=this.s_size - 1;i=0;i--){

System.out.println(array[i]);

}

}

}

//下面是测试代码

public static void main(String[] args){

MyStack stack=new MyStack();

stack.push(4);

stack.push(5);

stack.push(6);

stack.push(7);

//System.out.println(stack.isEmpty());

stack.printAll();

System.out.println("===========");

System.out.println(stack.top());

System.out.println(stack.top());

System.out.println(stack.top());

System.out.println(stack.top());

System.out.println(stack.top());

}

}

用JAVA编写一个程序，希望有注释，但不要太简单，不要在别的地方复制，急用！

/**

* GenericLinkedStack.java

*/

package fix;

import java.util.EmptyStackException;

/**

*泛型的链式栈数据结构

*/

public class GenericLinkedStackE {

// 栈顶元素

private Item top = null;

// 返回栈顶元素，并弹出

public E pop() throws EmptyStackException {

if (isEmpty()) {

throw new EmptyStackException();

}

E e = top.value;

top = top.next;

return e;

}

/**

* 栈顶压入一个元素

* @param e 被压入的元素

*/

public void push(E e) {

Item curr = new Item(e);

curr.next = top;

top = curr;

}

/**

* 返回栈顶元素，但不出栈

* @return 栈顶元素

*/

public E peek() {

if (isEmpty()) {

throw new EmptyStackException();

}

return top.value;

}

/**

* 判断栈是否为空

* @return 判断结果

*/

public boolean isEmpty() {

return top == null;

}

/**

* 栈中元素

* @author jilen

*

*/

class Item {

//元素

private E value;

//下一个

private Item next;

public Item(E e) {

this.value = e;

}

public E getValue() {

return value;

}

public void setValue(E value) {

this.value = value;

}

public Item getNext() {

return next;

}

public void setNext(Item next) {

this.next = next;

}

}

}

/**

* InfixToPostfixConverter.java

*/

package fix;

import java.util.Hashtable;

/**

* @author jilen

*

*/

public class InfixToPostfixConverter {

// 操作符及其优先级组成的键值对

private static final HashtableCharacter, Integer operators;

private StringBuffer infix;

private StringBuffer postfix;

GenericLinkedStackCharacter stack = new GenericLinkedStackCharacter();

// 初始化操作符列表，static语句块会在加载类时自动执行

static {

operators = new HashtableCharacter, Integer();

operators.put('^', 4);

operators.put('*', 3);

operators.put('/', 3);

operators.put('%', 3);

operators.put('+', 2);

operators.put('-', 2);

operators.put('(', -1);

operators.put(')', 5);

}

/**

*

*/

public InfixToPostfixConverter(StringBuffer infix, StringBuffer postfix) {

this.infix = infix;

this.postfix = postfix;

}

/**

* 转换函数

*/

public void convertToPostfix() {

// 对输入字符串中字符遍历

for (int i = 0, n = infix.length(); i n; i++) {

char c = infix.charAt(i);

// 是数字之间添加到转换后字符串

if (isNumber(c)) {

postfix.append(c);

} else if (isOperator(c)) {

switch (c) {

// '(' 直接入栈

case '(':

stack.push(c);

break;

// ')' 弹出元素直到碰到'('

case ')':

while (!stack.isEmpty() stack.peek() != '(') {

postfix.append(stack.pop());

}

stack.pop();

break;

// 其他操作符

default:

// 当前操作符比栈顶操作符优先级高，直接入栈

if (stack.isEmpty() || precedence(c, stack.peek())) {

stack.push(c);

}

// 当前操作符比栈顶操作符优先级低，出栈直到为空或栈顶优先级低于当前操作符

else if (!precedence(c, stack.peek())) {

while (!stack.isEmpty() !precedence(c, stack.peek())) {

postfix.append(stack.pop());

}

stack.push(c);

}

break;

}

}

}

// 若栈中还有操作符，所以元素出栈

while (!stack.isEmpty()) {

postfix.append(stack.pop());

}

}

/**

* 判断是否为操作符

* @param c

* @return

*/

public static boolean isOperator(char c) {

return operators.containsKey(c);

}

/**

* 优先级大小关系operator1 operator2 则返回true，否则false

* @param operator1

* @param operator2

* @return 判断结果

*/

public static boolean precedence(char operator1, char operator2) {

return operators.get(operator1) operators.get(operator2);

}

/**

* 是否数字

* @param c 要判断的字符

* @return 判断结果

*/

public static boolean isNumber(char c) {

return c = '0' c = '9';

}

}

/**

*Main.java测试类

*/

package fix;

/**

* @author Administrator

*

*/

public class Main {

/**

* @param args

*/

public static void main(String[] args) {

StringBuffer infix = new StringBuffer("(1+2)*3/4");

StringBuffer postfix = new StringBuffer();

InfixToPostfixConverter converter = new InfixToPostfixConverter(infix,

postfix);

converter.convertToPostfix();

System.out.println(postfix.toString());

}

}

中缀转后缀的程序，有GenericLinkedStack.java,InfixToPostfix.java,Main.java三个源文件需要放在fix包下

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用链表实现栈

public Object setEle(Object element)

{

Object oldElement = this.element;

this.element = element;

return oldElement;

}

是啥意思，给值还return？？把这函数删了

public Linked()

{

nextNode = null;

element = null;

}

改成

public Linked(Object element)

{

this.element = element;

nextNode = null;

}

用java语言编写算法 输出链栈中的所有元素

#includestdio.h

#includestdlib.h

struct node{

int data;

struct node* pre;

};

void print(struct node *p) //打印链栈

{while(p)

{printf("%d ",p-data);

p=p-pre;

}

}

int main()

{int i;

struct node *p,*q;

for(i=1;i11;i++) //1~10依次入栈

{p=(struct node*)malloc(sizeof(struct node));

if(i==1)p-pre=NULL;

else p-pre=q;

p-data=i;

q=p;

}

print(p);

return 0;

}

本文题目：java链式栈代码,栈的链式存储结构代码
当前地址：http://scgulin.cn/article/hceccp.html