栈
- 用数组实现一个顺序栈
1.数组实现一个顺序栈
接口
package stack;
interface IStack<T> {
//出栈
public T pop();
//入栈
public void push(T element) throws Exception;
//获取栈顶元素
public T top() throws Exception;
//判断栈为空
public boolean isEmpty();
//判断是否溢栈
public boolean isFull();
//获取栈长度
public int getLength();
//清空
public void setEmpty();
}
实现类package stack;
import java.util.Arrays;
class AStack<T> implements IStack {
//定义栈空间
private final int STACK_DEFAULT_SIZE=3;
//栈最大值
private int max_size;
//栈数组
private T[] arrayObj;
//栈顶指针，初始为-1
private int top=-1;
/*
*默认的构造函数
* */
public AStack(){
this.max_size=STACK_DEFAULT_SIZE;
this.arrayObj=(T[]) new Object[this.max_size];
top=-1;
}
/*
* 带初始值的构造函数
* @param=size
* */
public AStack(int size){
this.max_size=size;
this.arrayObj=(T[]) new Object[this.max_size];
top=-1;
}
/*
* 出栈
* 判断栈是否为空，不为空则将top指针下的元素返回，并将该位置清空，top--；
* */
@Override
public Object pop() {
if(isEmpty()){
System.out.println("栈为空");
return null;
}
T result=(T) arrayObj[top];
arrayObj[top]=null;
top--;
return result;
}
/*
* 入栈，首先判断入栈元素是否为空，不为空则入栈成功
*其次，判断栈是否为满，若未满则入栈失败，将元素存入数组，top++
* */
@Override
public void push(Object element) throws Exception {
if(null==element){
throw new Exception("入栈元素不能为空");
}
if (isFull()){
System.out.println("栈满！");
}else{
this.arrayObj[++top]= (T) element;
}
}
/*
* 获取栈顶元素，首先判断栈是否为空，若为空则抛出异常
*若不为空则返回top指针下的元素
* */
@Override
public Object top() throws Exception {
if(isEmpty()){
throw new Exception("栈为空");
}else{
return this.arrayObj[top];
}
}
/*
* 判断栈为空
* * */
@Override
public boolean isEmpty() {
if(top == -1){
return true;
}
return false;
}
/*
* 判断栈溢出
* */
@Override
public boolean isFull() {
if(top == arrayObj.length-1){
return true;
}
return false;
}
/*
* 获取当前栈所存元素的长度
* */
@Override
public int getLength() {
return this.top;
}
/*
* 清空栈
* */
@Override
public void setEmpty() {
//将数组置空
Arrays.fill(arrayObj,null);
//指针归位
this.top=-1;
this.max_size=this.STACK_DEFAULT_SIZE;
this.arrayObj=(T[]) new Object[max_size];
}
}- 用链表实现一个链式栈
package stack;
interface IStack<T> {
//出栈
public T pop();
//入栈
public void push(T element) throws Exception;
//获取栈顶元素
public T top() throws Exception;
//判断栈为空
public boolean isEmpty();
//判断是否溢栈
public boolean isFull();
//获取栈长度
public int getLength();
//清空
public void setEmpty();
}
package stack;
import java.util.Arrays;
class AStack<T> implements IStack {
//定义栈空间
private final int STACK_DEFAULT_SIZE=3;
//栈最大值
private int max_size;
//栈数组
private T[] arrayObj;
//栈顶指针，初始为-1
private int top=-1;
/*
*默认的构造函数
* */
public AStack(){
this.max_size=STACK_DEFAULT_SIZE;
this.arrayObj=(T[]) new Object[this.max_size];
top=-1;
}
/*
* 带初始值的构造函数
* @param=size
* */
public AStack(int size){
this.max_size=size;
this.arrayObj=(T[]) new Object[this.max_size];
top=-1;
}
/*
* 出栈
* 判断栈是否为空，不为空则将top指针下的元素返回，并将该位置清空，top--；
* */
@Override
public Object pop() {
if(isEmpty()){
System.out.println("栈为空");
return null;
}
T result=(T) arrayObj[top];
arrayObj[top]=null;
top--;
return result;
}
/*
* 入栈，首先判断入栈元素是否为空，不为空则入栈成功
*其次，判断栈是否为满，若未满则入栈失败，将元素存入数组，top++
* */
@Override
public void push(Object element) throws Exception {
if(null==element){
throw new Exception("入栈元素不能为空");
}
if (isFull()){
System.out.println("栈满！");
}else{
this.arrayObj[++top]= (T) element;
}
}
/*
* 获取栈顶元素，首先判断栈是否为空，若为空则抛出异常
*若不为空则返回top指针下的元素
* */
@Override
public Object top() throws Exception {
if(isEmpty()){
throw new Exception("栈为空");
}else{
return this.arrayObj[top];
}
}
/*
* 判断栈为空
* * */
@Override
public boolean isEmpty() {
if(top == -1){
return true;
}
return false;
}
/*
* 判断栈溢出
* */
@Override
public boolean isFull() {
if(top == arrayObj.length-1){
return true;
}
return false;
}
/*
* 获取当前栈所存元素的长度
* */
@Override
public int getLength() {
return this.top;
}
/*
* 清空栈
* */
@Override
public void setEmpty() {
//将数组置空
Arrays.fill(arrayObj,null);
//指针归位
this.top=-1;
this.max_size=this.STACK_DEFAULT_SIZE;
this.arrayObj=(T[]) new Object[max_size];
}
}- 编程模拟实现一个浏览器的前进、后退功能
package stack;
import java.util.Scanner;
public class BracketMatchSolution {
public static void main(String[] args) throws Exception{
AStack<Character> stack=null;
//用户输入
Scanner scanner = new Scanner(System.in);
String str=scanner.next();
//关闭输入流
scanner.close();
if(null == str || str.equals("")){
System.out.println("输入错误！");
}else{
//若输入为奇数，则未匹配成功
if(str.length()%2==1){
System.out.println("不匹配");
}else{
//创建自定义的栈对象
stack = new AStack<Character>(100);
//对单个字符进行判断
for (int i=0;i<str.length();i++){
//当栈为空时，压入栈
if(stack.isEmpty()){
stack.push(str.charAt(i));
}else{
//栈不为空时，获取栈顶元素与当前元素进行匹配，成功则出栈，不成功则入栈
if((char)(stack.top())=='('&&str.charAt(i)==')'||
(char)(stack.top())=='['&&str.charAt(i)==']'||
(char)(stack.top())=='{'&&str.charAt(i)=='}'){
stack.pop();
}else{
stack.push(str.charAt(i));
}
}
}
}
}
if (stack.isEmpty()){
System.out.println("匹配成功");
}else{
System.out.println("匹配失败");
}
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
