ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 编程语言> 文章详细

python数据结构（1）

2020-03-16 22:55:21  阅读：163  来源： 互联网

标签：return python res self items print 数据结构 def 


检测单词是否是由颠倒字母组成的词
#检测单词是否是由颠倒字母组成的词
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)

　　

 

标签：return,python,res,self,items,print,数据结构,def
来源： https://www.cnblogs.com/2018-1025/p/12495559.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有