python数据结构

Posted 2021-03-05 hcy12

检测单词是否是由颠倒字母组成的词

#检测单词是否是由颠倒字母组成的词
def anagram(s1,s2):
    num1=[0]*26
    num2=[0]*26
    for i in range(len(s1)):
        pos=ord(s1[i])-ord(\'a\')
        num1[pos]+=1
    for i in range(len(s2)):
        pos = ord(s2[i]) - ord(\'a\')
        num2[pos]+= 1
    j=0
    state=True
    while j<26 and state:
        if num1[j]!=num2[j]:
            state=False
            break
        j += 1
    return state
while True:
    a=input(\'请输入单词：\')
    b=input(\'请输入单词：\')
    answer=anagram(a,b)
    print(answer)

　　

栈的实现方法一（以列表末尾为栈顶）复杂度为O(1)

class stack():
    def __init__(self):
        self.items=[]
    def isempty(self):
        return self.items==[]
    def push(self,item):
        print(\'入栈：\',item)
        self.items.append(item)
    def pop(self):
        res=self.items.pop()
        print(\'出栈：\',res)
        return res
    def peek(self):
        return self.items[len(self.items)-1]
    def size(self):
        print(\'栈的大小：\')
        return len(self.items)
l=stack()
l.push(\'1\')
l.push(\'2\')
l.push(\'3\')
l.push(\'4\')
print(l.size())
res=l.pop()
print(res)
print(l.size())

栈的实现方法二（以列表首端为栈顶）复杂度为O(n)

#检测单词是否是由颠倒字母组成的词
class stack():
    def __init__(self):
        print(\'栈初始化\')
        self.items=[]
    def isempty(self):
        return self.items==[]
    def push(self,item):
        print(\'入栈：\',item)
        self.items.insert(0,item)
    def pop(self):
        res=self.items.pop(0)
        print(\'出栈：\',res)
        return res
    def peek(self):
        res=self.items[len(self.items) - 1]
        print(\'栈顶元素\',res)
        return res
    def size(self):
        res=len(self.items)
        print(\'栈的大小：\',res)
        return res
l=stack()
l.size()
l.push(\'1\')
l.push(\'2\')
l.push(\'3\')
l.push(\'4\')
l.size()
res=l.pop()
l.size()

应用（括号匹配）

#检测单词是否是由颠倒字母组成的词
class stack():
    def __init__(self):
        print(\'栈初始化\')
        self.items=[]
    def isempty(self):
        return self.items==[]
    def push(self,item):
        print(\'入栈：\',item)
        self.items.insert(0,item)
    def pop(self):
        res=self.items.pop(0)
        print(\'出栈：\',res)
        return res
    def peek(self):
        res=self.items[len(self.items) - 1]
        print(\'栈顶元素\',res)
        return res
    def size(self):
        res=len(self.items)
        print(\'栈的大小：\',res)
        return res
def parcheck(str):
    s=stack()
    mark=True
    index=0
    while index<len(str) and mark:
        symbol=str[index]
        #左括号压入
        if symbol==\'(\':
            s.push(symbol)
        #字符串遇到右括号，栈里抛出一个左括号
        else:
            if s.isempty():
                mark=False
            else:
                s.pop()

        index+=1
    if mark==True and s.isempty():
        print(\'匹配\')
        return True
    else:
        print(\'不匹配\')
        return False

# parcheck(\'()\')
# parcheck(\'()))\')
while True:
    s=input(\'请输入括号测试》\').strip()
    parcheck(s)

通用括号匹配

应用将10进制数转化为2进制

class stack():
    def __init__(self):
        print(\'栈初始化\')
        self.items=[]
    def isempty(self):
        return self.items==[]
    def push(self,item):
        print(\'入栈：\',item)
        self.items.insert(0,item)
    def pop(self):
        res=self.items.pop(0)
        print(\'出栈：\',res)
        return res
    def peek(self):
        res=self.items[len(self.items) - 1]
        print(\'栈顶元素\',res)
        return res
    def size(self):
        res=len(self.items)
        print(\'栈的大小：\',res)
        return res
def divideby2(num):
    s=stack()
    result = \'\'
    num=int(num)
    while num>0:
        #余数
        q=num%2
        s.push(q)
        #商
        num=num//2
    while not s.isempty():　　　　#输出结果
        result=result+ str (s.pop())

    return result

while True:
    s=input(\'请输入要转换的十进制数>\').strip()
    result=divideby2(s)
    print(result)

 

------------恢复内容开始------------

检测单词是否是由颠倒字母组成的词

#检测单词是否是由颠倒字母组成的词
def anagram(s1,s2):
    num1=[0]*26
    num2=[0]*26
    for i in range(len(s1)):
        pos=ord(s1[i])-ord(\'a\')
        num1[pos]+=1
    for i in range(len(s2)):
        pos = ord(s2[i]) - ord(\'a\')
        num2[pos]+= 1
    j=0
    state=True
    while j<26 and state:
        if num1[j]!=num2[j]:
            state=False
            break
        j += 1
    return state
while True:
    a=input(\'请输入单词：\')
    b=input(\'请输入单词：\')
    answer=anagram(a,b)
    print(answer)

　　

栈的实现方法一（以列表末尾为栈顶）复杂度为O(1)

class stack():
    def __init__(self):
        self.items=[]
    def isempty(self):
        return self.items==[]
    def push(self,item):
        print(\'入栈：\',item)
        self.items.append(item)
    def pop(self):
        res=self.items.pop()
        print(\'出栈：\',res)
        return res
    def peek(self):
        return self.items[len(self.items)-1]
    def size(self):
        print(\'栈的大小：\')
        return len(self.items)
l=stack()
l.push(\'1\')
l.push(\'2\')
l.push(\'3\')
l.push(\'4\')
print(l.size())
res=l.pop()
print(res)
print(l.size())

栈的实现方法二（以列表首端为栈顶）复杂度为O(n)

#栈的实现方法二
class stack():
    def __init__(self):
        print(\'栈初始化\')
        self.items=[]
    def isempty(self):
        return self.items==[]
    def push(self,item):
        print(\'入栈：\',item)
        self.items.insert(0,item)
    def pop(self):
        res=self.items.pop(0)
        print(\'出栈：\',res)
        return res
    def peek(self):
        res=self.items[len(self.items) - 1]
        print(\'栈顶元素\',res)
        return res
    def size(self):
        res=len(self.items)
        print(\'栈的大小：\',res)
        return res
l=stack()
l.size()
l.push(\'1\')
l.push(\'2\')
l.push(\'3\')
l.push(\'4\')
l.size()
res=l.pop()
l.size()

应用（括号匹配）

#括号匹配
class stack():
    def __init__(self):
        print(\'栈初始化\')
        self.items=[]
    def isempty(self):
        return self.items==[]
    def push(self,item):
        print(\'入栈：\',item)
        self.items.insert(0,item)
    def pop(self):
        res=self.items.pop(0)
        print(\'出栈：\',res)
        return res
    def peek(self):
        res=self.items[len(self.items) - 1]
        print(\'栈顶元素\',res)
        return res
    def size(self):
        res=len(self.items)
        print(\'栈的大小：\',res)
        return res
def parcheck(str):
    s=stack()
    mark=True
    index=0
    while index<len(str) and mark:
        symbol=str[index]
        #左括号压入
        if symbol==\'(\':
            s.push(symbol)
        #字符串遇到右括号，栈里抛出一个左括号
        else:
            if s.isempty():
                mark=False
            else:
                s.pop()

        index+=1
    if mark==True and s.isempty():
        print(\'匹配\')
        return True
    else:
        print(\'不匹配\')
        return False

# parcheck(\'()\')
# parcheck(\'()))\')
while True:
    s=input(\'请输入括号测试》\').strip()
    parcheck(s)

通用括号匹配

应用将10进制数转化为2进制

class stack():
    def __init__(self):
        print(\'栈初始化\')
        self.items=[]
    def isempty(self):
        return self.items==[]
    def push(self,item):
        print(\'入栈：\',item)
        self.items.insert(0,item)
    def pop(self):
        res=self.items.pop(0)
        print(\'出栈：\',res)
        return res
    def peek(self):
        res=self.items[len(self.items) - 1]
        print(\'栈顶元素\',res)
        return res
    def size(self):
        res=len(self.items)
        print(\'栈的大小：\',res)
        return res
def divideby2(num):
    s=stack()
    result = \'\'
    num=int(num)
    while num>0:
        #余数
        q=num%2
        s.push(q)
        #商
        num=num//2
    while not s.isempty():　　　　#输出结果
        result=result+ str (s.pop())

    return result

while True:
    s=input(\'请输入要转换的十进制数>\').strip()
    result=divideby2(s)
    print(result)

应用（表达式中缀转后缀）

代码实现

#表达式中缀转后缀
class stack():
    def __init__(self):
        print(\'栈初始化\')
        self.items=[]
    def isempty(self):
        return self.items==[]
    def push(self,item):
        print(\'入栈：\',item)
        self.items.insert(0,item)
    def pop(self):
        res=self.items.pop(0)
        print(\'出栈：\',res)
        return res
    def peek(self):
        res=self.items[len(self.items) - 1]
        print(\'栈顶元素\',res)
        return res
    def size(self):
        res=len(self.items)
        print(\'栈的大小：\',res)
        return res

def infixtopostfix(goals):
    #操作符优先级

    prec={}
    prec[\'*\'] = 3
    prec[\'/\'] = 3
    prec[\'+\'] = 2
    prec[\'-\'] = 2
    prec[\'(\'] = 1
    #操作符栈
    opstack=stack()
    postfixlist=[]
    #上图此处有误
    goallist=list(goals)
    for goal in goallist:
        if goal in \'ABCDEFGHIJKLMNOPQRSTUVWXYZ\'or goal in \'0123456789\':
            postfixlist.append(goal)
        elif goal==\'(\':
            opstack.push(goal)
        elif goal==\')\':
            topgoal=opstack.pop()
            while topgoal !=\'(\':
                postfixlist.append(topgoal)
                topgoal=opstack.pop()
        else:
            while (not opstack.isempty()) and (prec[opstack.peek()] >= prec[goal]):
                postfixlist.append(opstack.pop())
            opstack.push(goal)
    while not opstack.isempty():
        postfixlist.append(opstack.pop())
    return \'\'.join(postfixlist)

while True:
    s=input(\'请输入要转换的表达式>\').strip()
    result=infixtopostfix(s)
    print(result)

 应用（后缀表达式求值）

代码实现

#后缀表达式求值
class stack():
    def __init__(self):
        print(\'栈初始化\')
        self.items=[]
    def isempty(self):
        return self.items==[]
    def push(self,item):
        print(\'入栈：\',item)
        self.items.insert(0,item)
    def pop(self):
        res=self.items.pop(0)
        print(\'出栈：\',res)
        return res
    def peek(self):
        res=self.items[len(self.items) - 1]
        print(\'栈顶元素\',res)
        return res
    def size(self):
        res=len(self.items)
        print(\'栈的大小：\',res)
        return res

def infixtopostfix(goals):
    #操作符优先级

    prec={}
    prec[\'*\'] = 3
    prec[\'/\'] = 3
    prec[\'+\'] = 2
    prec[\'-\'] = 2
    prec[\'(\'] = 1
    #操作符栈
    opstack=stack()
    postfixlist=[]
    #上图此处有误
    goallist=list(goals)
    for goal in goallist:
        if goal in \'ABCDEFGHIJKLMNOPQRSTUVWXYZ\'or goal in \'0123456789\':
            postfixlist.append(goal)
        elif goal==\'(\':
            opstack.push(goal)
        elif goal==\')\':
            topgoal=opstack.pop()
            while topgoal !=\'(\':
                postfixlist.append(topgoal)
                topgoal=opstack.pop()
        else:
            while (not opstack.isempty()) and (prec[opstack.peek()] >= prec[goal]):
                postfixlist.append(opstack.pop())
            opstack.push(goal)
    while not opstack.isempty():
        postfixlist.append(opstack.pop())
    return \'\'.join(postfixlist)

def postfixeval(express):
    opertostack=stack()
    expresslist=list(express)
    print(expresslist)
    for i in expresslist:
        if i in \'0123456789\':
            opertostack.push(int(i))
        else:
            oper2 = opertostack.pop()
            oper1=opertostack.pop()

            result=domath(i,oper1,oper2)
            opertostack.push(result)
    return opertostack.pop()
def domath(op,op1,op2):
    if op==\'*\':
        return op1*op2
    elif op==\'/\':
        return op1/op2
    elif op==\'+\':
        return op1+op2
    else :
        return op1-op2

while True:
    s=input(\'请输入要转换的表达式>\').strip()
    result1 = infixtopostfix(s)
    print(result1)
    result2=postfixeval(result1)
    print(result2)