基于java数据结构实验报告+-+栈

实验报告

break;

case ')': if (stack1.isEmpty() || !stack1.pop().equals("(")) //遇见右括号时，出栈

return "

期望("; //检查出栈字符是否为左括号

} }

return (stack1.isEmpty()) ? "无

" : "期望)"; //返回空串表示没有错误

}

public static void main(String args[])

{

String infix="((1+2)*3+4";

System.out.println(infix+" ，编译错误："+Bracket.isMatched(infix));

}

4.中缀表达式转后缀表达式；根据后缀表达式求值。（可选）

运行结果：

顺序栈表的测试及结果：

单链栈表的测试及结果：

实验总结：

栈是特殊的线性表，其存储结构和线性表很相似，分为顺序存储和链式存储。顺序存储类似于高级语言中的数组，可用数组的相关方法实运算，链式存储类似于高级语言中的指针，可通过类的对象引用实现指针运算。

栈只允许在其一端进行操作，对其算法的实现起到瓶颈的作用。

附：源程序：

建立顺序栈，实现入栈，出栈等基本操作。

package StackTable;

public class SequeueStack{

private int size=10;

private int count;

private int top;

private T[] stack;

public SequeueStack() {

top=-1;

stack=(T[])new Object[size];

count=0;

}

public SequeueStack(int n) {

top=-1;

stack=(T[])new Object[n];

count=0;

}

public boolean isEmpty() {

return top==-1;

}

public boolean isFull() {

return top==size;

}

public boolean push(T obj) {

if (isFull()) {

System.out.println("栈满");

return false;

}

stack[++top]=obj;

count++;

return true;

}

public T pop() {

if (isEmpty()) {

System.out.println("栈空");

return null;

}

T sc=stack[top--];

count--;

return sc;

}

public void list() {

if(isEmpty()) {

System.out.println("栈空");

}

for(int i=top;i>=0;i--) {

System.out.println("stack["+i+"]="+stack[i]);

}

}

public static void main(String[] args) {

SequeueStack stack1=new SequeueStack(5);

stack1.push("王帆");

stack1.push("李明");

stack1.push("李华");

stack1.push("张三");

stack1.push("李四");

stack1.list();

System.out.println("出栈的是："+stack1.pop());

System.out.println("出栈后：");

stack1.list();

// TODO Auto-generated method stub

}

}

掌握链栈基本操作的算法实现；

package linkedList;

class StackNode{

private T data;

private StackNode next;

public StackNode(T obj) {

this.data =obj;

}

@Override

public String toString() {

return"StackNode [data=" + data + "]";

}

public StackNode getNext() {

return next;

}

public void setNext(StackNode next) {

this.next = next;

}

}

public class SingleLinkStack {

private StackNode top;

public SingleLinkStack() {

top=null;

}

public boolean isEmpty() {

return top==null;

}

public boolean push(StackNode s) {

s.setNext(top);

top=s;

return true;

}

public StackNode pop() {

if (isEmpty()) {

System.out.println("栈空");

return null;

}

StackNode sc=top;

top=top.getNext();

return sc;

}

public void list() {

StackNode temp=top;

while(temp!=null) {

System.out.println(temp);

temp=temp.getNext();

}

}

public static void main(String[] args) {

StackNode node1=new StackNode("王帆");

StackNode node2=new StackNode("小明");

StackNode node3=new StackNode("小王");

StackNode node4=new StackNode("小红");

StackNode node5=new StackNode("小华");

SingleLinkStack list1 = new SingleLinkStack();

list1.push(node1);

list1.push(node2);

list1.push(node3);

list1.push(node4);

list1.push(node5);

list1.list();

System.out.println("出栈的是："+list1.pop());

System.out.println("出栈后：");

list1.list();

// TODO Auto-generated method stub

}

}

括号匹配问题

package seqList;

import java.util.Stack;

public class Bracket {

public static void main(String[] args) {

String infix="((1+2)*3+4) ";

System.out.println(infix+",编译错误：

"+Bracket.isMatched(infix));

// TODO Auto-generated method stub

}

public static String isMatched(String infix) {

Stack stack1 = new Stack();

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

char ch=infix.charAt(i);

switch(ch) {

case'(': stack1.push(ch+"");break;

case')':

if(stack1.isEmpty()||!stack1.pop().equals("(")) {

return"缺少(";

}

break;

}

}

return (stack1.isEmpty())?"无":"缺少)";

}

}