用python实现简单编程题

1.编程实现字符串反转

def fanzhaun(str):
    print('反转前的字符为：', str)
    stack = list(str)             # 将待反转的字符串压栈
    new_str = ' '                 # 创建一个空字符串来接受即将反转的字符串
    for i in range(len(str)):     # 根据字符串的长度来遍历字符串中的每个元素
        new_str += stack.pop()    # 将出栈的元素放进空字符串中
    print('反转后的字符为：',new_str)
str = input('请输入需要反转的字符：')
print(fanzhaun(str))

2.编程实现括号匹配

# 括号匹配
# 1.准备相关材料，待匹配的字符串，栈
def kuohao(str):
    Left  = '{[('                              #把左括号与右括号分别放在一组
    Right = '}])'
    kuohao_ = {'}':'{',']':'[',')':'('}        #根据括号的匹配关系建立一个字典,右括号当key,左括号当value
    Stack = [ ]                                # 建立一个栈，初始值为空列表
    for char in (str):                         # 2.依次扫描字符串的每个字符
        if char in Left:                       # 3.针对每一个字符，做相关处理。如果当前字符非左右括号，处理下一个字符
            Stack.append(char)                 # 3.1如果该字符是左括号，压栈
        if char in Right:                      # 3.2如果该字符是右括号,判断栈是否为空
            if Stack == []:
                return False                   #（1）当栈为空时，说明没有左括号与该右括号匹配，返回False
            else:
                if kuohao_[char] == Stack[-1]: #（2）当栈不为空，利用字典将其与栈顶元素进行比较
                    Stack.pop()                #（2.1）匹配，弹出栈顶元素
                else:
                    return False               #（2.2）不匹配，返回False
    if Stack == []:                            # 遍历完成后判断栈是否为空
        return True                            # 若栈为空则说明括号匹配，返回True
    else:
        return False                           # 若栈不为空，则说明该字符串中有多余的括号，即括号不匹配，返回False
str = input('请输入字符：')
print(kuohao(str))

3.编程实现回文数判断

def huiwen(Str):
    Stack = []                   # 1.准备待判断的字符串，一个栈，一个队列
    Queue = []
    if len(Str) % 2 != 0:       # 2.若字符串的长度为奇数则取出正中间的那个元素，若为偶数则字符串不变
        Str = str(Str[:int(len(Str)/2)]) + str(Str[int(len(Str)/2)+1:])
    else:
        Str = Str
    k = len(Str)/2
    for i in Str:               # 3.左边部分压栈，右边部分入队
        if k > 0 :
            Stack.append(i)
            k -= 1
        else:
            Queue.insert(0,i)
    while Stack != [ ] or Queue != [ ]:     # 4.对于栈和队列同时执行出栈和出队操作，直到栈或队列为空结束
        A = Stack.pop()                     # 设出栈元素为A，出队元素为B
        B = Queue.pop()
        if A == B:                          # （1）相等，继续下一次操作
            continue
        else:                               #（2）不相等，得出结论此字符串非回文
            print('该字符串非回文')
            break
    if Stack == [] and Queue == []:         # 当栈和队列都为空，则是回文，其他情况均为非回文
        print('该字符串是回文')

Str = input('请输入字符：')
print(huiwen(Str))

4.编程实现MinStack

class MinStack:
    def __init__(self):
        self.datestack = [ ]   # 定义一个数据栈来来支持压栈，出栈和栈顶操作
        self.Minstack = [ ]    # 定义一个辅助栈，其栈顶为当前最小值
    def push(self, x):
        self.datestack.append(x)    # 将待压栈元素x压入数据栈
        if self.Minstack == [ ] or x <= self.Minstack[-1]:  # 当辅助栈为空或者待压栈元素x小于等于辅助栈的栈顶元素时，将x压入辅助栈
            self.Minstack.append(x)
    def pop(self):
        top = self.datestack[-1]
        self.datestack.pop()             # 数据栈进行出栈操作
        if top == self.Minstack[-1]:    # 当数据栈出栈的元素与辅助栈的栈顶元素相等时，辅助栈进行出栈操作
            self.Minstack.pop()
    def top(self):
        return self.datestack[-1]
    def getMin(self):
        return self.Minstack[-1]

注意：代码仅供参考（水平有限）