Linked Stack in Python

1. Node

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

    def __str__(self):
        return str(self.data)
    
    def __eq__(self, data):
        return self.data == data

2. Stack

class Stack:
    def __init__(self):
        self.size = 0
        self.top = None
    
    def push(self, data):
        n = Node(data)
        if self.top:
            n.next = self.top
        self.top = n
        self.size += 1
    
    def peek(self):
        return self.top if not self.empty() else None
    
    def pop(self):
        ptr = None
        if not self.empty():
            ptr = self.top
            self.top = ptr.next
            self.size -= 1
        return ptr       
    
    def empty(self):
        return self.size == 0
    
    def size(self):
        return self.size
    
    def traverse(self):
        print(f"The current length: {self.size}")
        for val in self.iter():
            print(val)
    
    def iter(self):
        ptr = self.top
        while ptr:
            val = ptr.data
            ptr = ptr.next
            yield val

3. Test Codes

def test_stack():
    s = Stack()
    s.push("eggs")
    s.push("ham")
    s.push("spam")
    
    print('-' * 15)
    s.traverse()
    
    print('-' * 15)
    p = s.pop()
    s.traverse()
    
    while not s.empty():
        ptr = s.pop()
        if ptr:
            print(ptr, " is poped.")
        s.traverse()

4. Case: bracket matching check

def check_brackets_match(sent):
    match = True
    s = Stack()
    for c in sent:
        if c in "([{":
            s.push(c)
        elif c in ")]}":
            top_c = s.pop()             
            if (top_c == '(' and c == ')') or \
               (top_c == '[' and c == ']') or \
               (top_c == '{' and c == '}'):
                continue
            else:
                match = False
                break
    return s.empty() and match
 

if __name__ == '__main__':
    # test_stack()

    sl = (
        "{(foo)(bar)}[hello](((this)is)a)test",
        "{(foo)(bar)}[hello](((this)is)atest",
        "{(foo)(bar)}[hello](((this)is)a)test))"
    )

    for s in sl:
        ret = check_brackets_match(s)
        print(f"{s}: {ret}")