玩转数据结构之使用数组实现自定义栈

前言

上一篇我们手动实现了动态数组功能,这一篇我们使用前面自定义的动态数组实现栈功能，栈这个数据结构(后进先出)对于大家也都比较熟悉，这里也就不再赘述；

相关代码

• 首先我们定义一个接口，主要涵盖栈的相对应的方法

package com.sjgd.stack;

/**
 * 自定义栈
 * on 2022/7/19
 */
public interface Stack<E> {

    /**
     * 获取栈中元素的个数
     *
     * @return
     */
    int getSize();

    /**
     * 当前栈中元素是否为空
     *
     * @return
     */
    boolean isEmpty();

    /**
     * 向栈中新增元素
     *
     * @param e
     */
    void push(E e);

    /**
     * 移除栈顶元素
     *
     * @return
     */
    E pop();

    /**
     * 查看栈顶元素
     *
     * @return
     */
    E peek();
}

• 利用上一节的动态数组实现栈对应的功能

package com.sjgd.stack;

/**
* 基于动态数组实现自定义栈功能
* on 2022/7/19
*/
public class ArrayStack<E> implements Stack<E> {
   /**
    * 维护动态数组
    */
   private Array<E> array;

   public ArrayStack() {
       array = new Array<>();
   }

   public ArrayStack(int capacity) {
       array = new Array<>(capacity);
   }


   @Override
   public int getSize() {
       return array.getSize();
   }

   @Override
   public boolean isEmpty() {
       return array.isEmpty();
   }

   @Override
   public void push(E e) {
       array.addLast(e);
   }

   @Override
   public E pop() {
       return array.removeLast();
   }

   @Override
   public E peek() {
       return array.get(getSize() - 1);
   }


   /**
    * 遍历输出stack中元素
    *
    * @return
    */
   @Override
   public String toString() {
       StringBuilder stringBuilder = new StringBuilder();
       stringBuilder.append("Stack: [");
       for (int i = 0; i < array.getSize(); i++) {
           stringBuilder.append(array.get(i));
           if (i != array.getSize() - 1) {
               stringBuilder.append(",");
           }
       }
       stringBuilder.append("] top");
       return stringBuilder.toString();
   }
}

• 测试代码以及解决LeetCode问题

package com.sjgd.stack;

/**
* on 2022/6/14
*/
public class Test {
   public static void main(String[] args) {
       //验证自定义Stack功能
       ArrayStack<Integer> arrayStack = new ArrayStack<>();
       for (int i = 0; i < 10; i++) {
           arrayStack.push(i);
           System.out.println(arrayStack);
       }
       arrayStack.pop();
       System.out.println(arrayStack);

       //使用自定义Stack解决LeetCode功能
       System.out.println(isValid("()[]{}")); //true
       System.out.println(isValid("([)]")); // false
   }


   /**
    * 使用自定义Stack 解决LeetCode 有效的括号问题
    * 给定一个只包括 '('，')'，'{'，'}'，'['，']'的字符串 s ，判断字符串是否有效。
    * 有效字符串需满足：
    * 左括号必须用相同类型的右括号闭合。
    * 左括号必须以正确的顺序闭合。
    * 来源：力扣（LeetCode）
    * 链接：https://leetcode.cn/problems/valid-parentheses
    */

   public static boolean isValid(String s) {
       ArrayStack<Character> arrayStack = new ArrayStack<>();
       for (int i = 0; i < s.length(); i++) {
           char c = s.charAt(i);
           if (c == '(' || c == '{' || c == '[') {
               //判断是左括号则入栈
               arrayStack.push(c);
           } else {
               if (arrayStack.isEmpty()) {
                   return false;
               }
               //取出栈顶元素
               char top = arrayStack.pop();
               if (c == ')' && top != '(') {
                   return false;
               }
               if (c == '}' && top != '{') {
                   return false;
               }
               if (c == ']' && top != '[') {
                   return false;
               }
           }
       }

       //入栈出栈完成，该栈中没有元素则表示匹配成功
       return arrayStack.isEmpty();
   }

}

时间复杂度

由于入栈和出栈并不需要数组中元素进行移动，因此入栈和出栈时间复杂度均为O(1);