数据结构小记【Python/C++版】——栈篇

stack = []

#基于append函数实现入栈操作
stack.append('a')
stack.append('b')
stack.append('c')

print('Initial stack:')
print(stack)

print('\nElements popped from stack:')

#基于pop函数实现出栈操作
print(stack.pop())
print(stack.pop())

print('\nStack after elements are popped:')
print(stack)

from collections import deque
stack = deque()

#基于append函数实现入栈操作
stack.append('a')
stack.append('b')
stack.append('c')

print('Initial stack:')
print(stack)

print('\nElements popped from stack:')

#基于pop函数实现出栈操作
print(stack.pop())
print(stack.pop())

print('\nStack after elements are popped:')
print(stack)

from queue import LifoQueue

stack = LifoQueue(maxsize=3)
print(stack.qsize())

#基于put函数实现入栈操作
stack.put('a')
stack.put('b')
stack.put('c')

print("Full: ", stack.full())
print("Size: ", stack.qsize())

#基于get函数实现出栈操作
print('\nElements popped from the stack')
print(stack.get())
print(stack.get())

print("\nEmpty: ", stack.empty())

class Stack:
    #初始化栈
    def __init__(self, size):
        self.arr = [None] * size
        self.capacity = size
        self.top = -1

    #入栈操作
    def push(self, val):
        if self.isFull():
            print('Stack is full…')
            exit(-1)

        print(f'Inserting {val} into the stack…')
        self.top = self.top + 1
        self.arr[self.top] = val

    #出栈操作
    def pop(self):
        if self.isEmpty():
            print('Stack is empty..')
            exit(-1)
        print(f'Removing {self.peek()} from the stack')
        top = self.arr[self.top]
        self.top = self.top - 1
        return top

    #返回栈顶元素
    def peek(self):
        if self.isEmpty():
            exit(-1)
        return self.arr[self.top]

    def size(self):
        return self.top + 1

    def isEmpty(self):
        return self.size() == 0

    def isFull(self):
        return self.size() == self.capacity

if __name__ == '__main__':
    stack = Stack(3)

    stack.push(1)
    stack.push(2)
    stack.pop()
    stack.pop()

    stack.push(3)
    stack.push(4)
    print('Top element is', stack.peek())
    print('The stack size is', stack.size())

    stack.pop()
    if stack.isEmpty():
        print('The stack is empty')
    else:
        print('The stack is not empty')

Inserting 1 into the stack…
Inserting 2 into the stack…
Removing 2 from the stack
Removing 1 from the stack
Inserting 3 into the stack…
Inserting 4 into the stack…
Top element is 4
The stack size is 2
Removing 4 from the stack
The stack is not empty

#include <iostream>
#include <stack>
using namespace std;
void main()
{
       stack<int> mystack;
       mystack.push(0);
       mystack.push(1);
       mystack.push(2);
       //弹出并打印栈顶元素
       while (!mystack.empty()) {
              cout << ' ' << mystack.top();
              mystack.pop();
       }}

#include<iostream>
using namespace std;
#define MAX 1024
class Stack
{
    int top;
public:
    int myStack[MAX];
    Stack() { top = -1; }
    bool push(int x);
    int pop();
    bool isEmpty();
};
bool Stack::push(int item)
{
    if (top >= (MAX - 1)) {
        cout << "stack is full..";
        return false;
    }
    else {
        myStack[++top] = item;
        cout << item << endl;
        return true;
    }
}
int Stack::pop()
{
    if (top < 0) {
        cout << "stack is empty..";
        return 0;
    }
    else {
        int item = myStack[top--];
        return item;
    }
}
bool Stack::isEmpty()
{
    return (top < 0);
}
int main()
{
    class Stack stack;
    cout << "The Stack Push " << endl;
    stack.push(2);
    stack.push(4);
    stack.push(6);
    cout << "The Stack Pop : " << endl;
    while (!stack.isEmpty())
    {
        cout << stack.pop() << endl;
    }
    return 0;
}

The Stack Push
2
4
6
The Stack Pop :
6
4
2

class Stack:
    def __init__(self):
        self.items = []

    def isEmpty(self):
        return self.items == []

    def push(self, item):
        self.items.insert(0, item)

    def pop(self):
        return self.items.pop(0)

    def peek(self):
        return self.items[0]

    def size(self):
        return len(self.items)

def parChecker(symbolString):
    s = Stack()
    balanced = True
    index = 0
    while index < len(symbolString) and balanced:
        symbol = symbolString[index]
        if symbol == "(":
            s.push(symbol)
        else:
            if s.isEmpty():
                balanced = False
            else:
                s.pop()
        index = index + 1

    if balanced and s.isEmpty():
        return True
    else:
        return False

if __name__ == '__main__':
    test_st1 = "((()))"
    print("The check result is :", parChecker(test_st1))
    test_st2 = "((())"
    print("The check result is :", parChecker(test_st2))

The check result is : True
The check result is : False