栈的简易实现

Posted 2022-01-30 小智RE0

栈的简易实现

简单实现栈的结构;底层结构采用链表的节点;

package com.xiaozhi.day04stack;

import java.util.Iterator;

/**
 * @author by @CSDN 小智RE0
 * @date 2021-12-26
 */
public class MyStack<T> implements Iterable<T>

    class ListNode
        //数据域;
        public T data;
        //下一个节点;
        public ListNode next;
        //初始化;
        public ListNode(T data,ListNode next)
            this.data = data;
            this.next = next;
        
    
    //栈的头结点;
    public ListNode head;
    //栈的元素个数;
    public   int size;

    //初始化;
    public MyStack()
        this.head = new ListNode(null,null);
        this.size = 0;
    

    //判断栈是否为空;
    public boolean isEmpty()
        return this.size == 0;
    

    //计算栈的元素个数;
    public int getSize()
        return this.size;
    

    //添加元素处理;
    public void push(T ele)
        //这里的实现,先找到头结点的后一个;将新节点拼到其中即可;
        ListNode temp = head.next;
        ListNode newNode = new ListNode(ele,null);
        head.next = newNode;
        newNode.next = temp;

        this.size ++;
    

    //删除栈中元素且返回该元素;
    public T pop()
      //弹出头结点的后一个元素即可;
      ListNode temp = head.next;
      if(temp == null) return null;

      head.next = temp.next;
      this.size --;
      return temp.data;
    


    //遍历方法
    @Override
    public Iterator<T> iterator() 
        return new MyIterator();
    

    //自定义迭代器内部类;
    class MyIterator implements Iterator

        private ListNode node;

        public MyIterator() 
            this.node = head;
        

        @Override
        public boolean hasNext() 
            return node.next != null;
        

        @Override
        public Object next() 
            node = node.next;
            return node.data;
        
    

测试

package com.xiaozhi.day04stack;
/**
 * @author by @CSDN 小智RE0
 * @date 2021-12-27 12:42
 */
public class Test 
    public static void main(String[] args) 
        MyStack<String> myStack = new MyStack<>();
        myStack.push("通过");
        myStack.push("Java");
        myStack.push("学习");
        myStack.push("成为");
        myStack.push("Java");
        myStack.push("爱好者");
        myStack.iterator().forEachRemaining(a-> System.out.print(a +"<-"));
        System.out.println();
        System.out.println("--------------------");
        System.out.println("弹出栈顶元素:::"+myStack.pop());
        myStack.iterator().forEachRemaining(a-> System.out.print(a +"<-"));
    

测试结果

爱好者<-Java<-成为<-学习<-Java<-通过<-
--------------------
弹出栈顶元素:::爱好者
Java<-成为<-学习<-Java<-通过<-

小括号匹配问题

比如现在有一段字符串;其中包括了括号;当左右括号匹配为一对时;
我们就说这是合理匹配的;有一个不符合都不行;

例如1: 字符串:  (字符串串) 
这样就说明括号匹配

例如2: 字符串  ((啦啦啦来了))
括号匹配

例如3: 字符串  ((啦啦啦啦21231)
括号不匹配;

例如4: 字符串 ()()
括号匹配

考虑用栈来解决这个匹配问题;
首先遍历字符串时,先判断将左括号( 压入栈,
否则找右括号),若不是右括号,继续遍历判断左括号,
若当前字符是右括号),则从栈中弹出一个元素[左括号]和当前的字符[右括号]进行比对;
如果弹出的元素是空的,直接说明栈空(不匹配返回false);
扎个时候还在遍历字符串,那么就得判断字符串是否已经遍历完了,若没有继续回到第一步判断左括号;
若字符串已经结束,则判断一下栈是否为空的;若为空则说明括号匹配,若栈不为空则不匹配(左括号多余);

那么来具体实现一下;

public class Solution 
    public static boolean matchParentheses(String s)
        if(s==null||s.length()==0)return false;
    
        //使用栈存储左括号;
        Stack<Character>  stack = new Stack<>();

        for (int i = 0; i < s.length(); i++) 
            char c = s.charAt(i);
            if(c=='(')
                stack.push(c);
            else if(c==')')
                Character pop = stack.pop();
                if(pop == null)
                    return false;
                
            
        

        //最后再判断栈是否为空;
        return stack.size() == 0;
    

测试

//测试;
    public static void main(String[] args) 
        boolean b1 = matchParentheses("(字符串串) ");
        System.out.println(b1);//true

        boolean b2 = matchParentheses("((啦啦啦来了))");
        System.out.println(b2);//true

        boolean b3 = matchParentheses("((啦啦啦啦21231)");
        System.out.println(b3);//false

        boolean b4 = matchParentheses("()()");
        System.out.println(b4);//true
    

这样的题之前有做过,LeetCode(20) --有效的括号(Java),原理差不多