java编程（一）栈

栈

1. 用数组实现一个顺序栈

 

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];

    }
}

1.  
2. 用链表实现一个链式栈

   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];
   
       }
   }
   

    

3. 编程模拟实现一个浏览器的前进、后退功能

   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("匹配失败");
           }
       }
   }