estructura de datos pitón (1)

Detectar si una palabra es una palabra invertido letras

palabra si se detecta # es la palabra de letras invertidas 
DEF Anagrama (S1, S2): 
    num1 = [0] * 26 es 
    num2 = [0] * 26 es 
    porque en la gama (len (S1)): 
        POS = ord (S1 [ I]) - la ord ( 'a') 
        num1 [POS] + = 1. 
    para I en Rango (len (S2)): 
        POS = la ord (S2 [I]) - la ord ( 'a') 
        num2 [POS] + = . 1 
    J = 0 
    Estado = True 
    el mientras J <26 es y Estado: 
        SI num1 [J] = num2 [J] :! 
            Estado = False 
            ROTURA 
        J + = 1. 
    retorno Estado 
el while True: 
    A = entrada ( 'entrar palabra:') 
    b = input ( 'entrar palabra:') 
    respuesta = Anagram (A, B) 
    de impresión (respuesta)

　　

Implementación de una pila (como el final de la lista en la pila) la complejidad es O (1)

pila de clases (): 
    def __init __ (self): 
        self.items = [] 
    def isEmpty (self): 
        self.items retorno == [] 
    empuje def (auto, elemento): 
        print ( '入栈:', elemento) 
        auto .items.append (punto) 
    pop def (auto): 
        res = self.items.pop () 
        print ( '出栈:', res) 
        res de retorno 
    def peek (auto): 
        self.items retorno [len (self.items ) -1] 
    def tamaño (self): 
        print ( '栈的大小:') 
        de retorno len (self.items) 
l = pila () 
l.push ( '1') 
l.push ( '2') 
l.push ( '3') 
l.push ( '4') 
de impresión (l.size ()) 
res = l.pop () 
de impresión (res)
imprimir (l.size ())

Aplicación de las dos pilas (apilar una lista de cabecera) la complejidad es O (n)

si se detecta la palabra # invertida carta palabra 
clase Stack (): 
    DEF la __init __ (self): 
        print ( 'pila de inicialización') 
        self.items = [] 
    DEF isEmpty (Ser): 
        self.items retorno == [] 
    DEF push (Ser, del programa): 
        print ( 'pila:', punto) 
        self.items.insert (0, artículo) 
    DEF POP (Ser): 
        RES = self.items.pop (0) 
        Imprimir ( "la pila: ' , RES) 
        volver RES 
    DEF PEEK (Self): 
        RES = self.items [. len (self.items) - 1] 
        de impresión ( 'el elemento superior', RES) 
        volver RES 
    tamaño DEF (Self): 
        RES = len (Ser. material) 
        Imprimir ( 'tamaño de la pila:', RES) 
        volver RES 
L = pila ()
l.size () 
l.push ( '1') 
l.push ( '2') 
l.push ( '3') 
l.push ( '4') 
l.size () 
res = l.pop () 
l .Talla()

Aplicación (soportes que coinciden)

si se detecta la palabra # invertida carta palabra 
clase Stack (): 
    DEF la __init __ (self): 
        print ( 'pila de inicialización') 
        self.items = [] 
    DEF isEmpty (Ser): 
        self.items retorno == [] 
    DEF push (Ser, del programa): 
        print ( 'pila:', punto) 
        self.items.insert (0, artículo) 
    DEF POP (Ser): 
        RES = self.items.pop (0) 
        Imprimir ( "la pila: ' , RES) 
        volver RES 
    DEF PEEK (Self): 
        RES = self.items [. len (self.items) - 1] 
        de impresión ( 'el elemento superior', RES) 
        volver RES 
    tamaño DEF (Self): 
        RES = len (Ser. material) 
        Imprimir ( 'tamaño de la pila:', RES) 
        volver RES 
DEF parcheck (STR):
    Pila = S () 
    Marcos = True 
    index = 0 
    el mientras que el índice <len (STR) y Mark: 
        Símbolo STR = [índice] 
        # se presiona en paréntesis izquierdo 
        SI == '(' Símbolo: 
            s.push () Símbolo 
        caso # cuerdas el paréntesis derecho, la pila de lanzar un paréntesis izquierdo 
        de la persona: 
            SI s.isempty (): 
                Marcos = false 
            else: 
                s.pop () 

        . índice 1 = + 
    SI == True y s.isempty Marcos (): 
        print ( 'partido' ) 
        devolverá True 
    else: 
        print ( 'desajuste') 
        devolverá False 

# parcheck ( '()') 
# parcheck ( '()))') 
del while True: 
    S = input ( 'entrar en soportes de prueba' ").tira()
    parcheck (s)

soportes universales coincidentes

Aplicación de la decimal a la conversión binaria

clase de pila (): 
    DEF la __init __ (self): 
        print ( 'pila de inicialización') 
        self.items = [] 
    DEF estaVacia (Ser): 
        self.items retorno == [] 
    DEF empuje (Ser, del programa): 
        Imprimir ( 'en pila: 'punto) 
        self.items.insert (0, artículo) 
    DEF POP (Ser): 
        RES = self.items.pop (0) 
        Imprimir (' la pila:', RES) 
        volver RES 
    DEF PEEK (Ser): 
        self.items = RES [len (self.items) - 1.] 
        de impresión ( 'el elemento superior', RES) 
        volver RES 
    tamaño DEF (Self): 
        RES = len (self.items) 
        Imprimir ( "tamaño de la pila: ' RES) 
        de retorno RES 
DEF divideby2 (NUM): 
    S = Stack ()
    = Resultado '' 
    NUM = int (NUM) 
    el mientras NUM> 0: 
        # resto 
        Q = 2% NUM 
        s.push (Q) 
        # comercialmente 
        NUM = NUM 2 // 
    el mientras s.isempty No (): # de salida 
        resultado = resultado + STR (s.pop) () 

    devolver resultado 

del while True: 
    . S = input ( 'Enter para convertir el número decimal>') Gaza () 
    Resultado = divideby2 (S) 
    de impresión (Resultado)

 

------------ ------------ restaurar empieza el contenido

Detectar si una palabra es una palabra invertido letras

palabra si se detecta # es la palabra de letras invertidas 
DEF Anagrama (S1, S2): 
    num1 = [0] * 26 es 
    num2 = [0] * 26 es 
    porque en la gama (len (S1)): 
        POS = ord (S1 [ I]) - la ord ( 'a') 
        num1 [POS] + = 1. 
    para I en Rango (len (S2)): 
        POS = la ord (S2 [I]) - la ord ( 'a') 
        num2 [POS] + = . 1 
    J = 0 
    Estado = True 
    el mientras J <26 es y Estado: 
        SI num1 [J] = num2 [J] :! 
            Estado = False 
            ROTURA 
        J + = 1. 
    retorno Estado 
el while True: 
    A = entrada ( 'entrar palabra:') 
    b = input ( 'entrar palabra:') 
    respuesta = Anagram (A, B) 
    de impresión (respuesta)

　　

Implementación de una pila (como el final de la lista en la pila) la complejidad es O (1)

pila de clases (): 
    def __init __ (self): 
        self.items = [] 
    def isEmpty (self): 
        self.items retorno == [] 
    empuje def (auto, elemento): 
        print ( '入栈:', elemento) 
        auto .items.append (punto) 
    pop def (auto): 
        res = self.items.pop () 
        print ( '出栈:', res) 
        res de retorno 
    def peek (auto): 
        self.items retorno [len (self.items ) -1] 
    def tamaño (self): 
        print ( '栈的大小:') 
        de retorno len (self.items) 
l = pila () 
l.push ( '1') 
l.push ( '2') 
l.push ( '3') 
l.push ( '4') 
de impresión (l.size ()) 
res = l.pop () 
de impresión (res)
impresión (l.size ())

Aplicación de las dos pilas (apilar una lista de cabecera) la complejidad es O (n)

si se detecta la palabra # invertida carta palabra 
clase Stack (): 
    DEF la __init __ (self): 
        print ( 'pila de inicialización') 
        self.items = [] 
    DEF isEmpty (Ser): 
        self.items retorno == [] 
    DEF push (Ser, del programa): 
        print ( 'pila:', punto) 
        self.items.insert (0, artículo) 
    DEF POP (Ser): 
        RES = self.items.pop (0) 
        Imprimir ( "la pila: ' , RES) 
        volver RES 
    DEF PEEK (Self): 
        RES = self.items [. len (self.items) - 1] 
        de impresión ( 'el elemento superior', RES) 
        volver RES 
    tamaño DEF (Self): 
        RES = len (Ser. material) 
        Imprimir ( 'tamaño de la pila:', RES) 
        volver RES 
L = pila ()
l.size () 
l.push ( '1') 
l.push ( '2') 
l.push ( '3') 
l.push ( '4') 
l.size () 
res = l.pop () 
l .Talla()

Aplicación (soportes que coinciden)

si se detecta la palabra # invertida carta palabra 
clase Stack (): 
    DEF la __init __ (self): 
        print ( 'pila de inicialización') 
        self.items = [] 
    DEF isEmpty (Ser): 
        self.items retorno == [] 
    DEF push (Ser, del programa): 
        print ( 'pila:', punto) 
        self.items.insert (0, artículo) 
    DEF POP (Ser): 
        RES = self.items.pop (0) 
        Imprimir ( "la pila: ' , RES) 
        volver RES 
    DEF PEEK (Self): 
        RES = self.items [. len (self.items) - 1] 
        de impresión ( 'el elemento superior', RES) 
        volver RES 
    tamaño DEF (Self): 
        RES = len (Ser. material) 
        Imprimir ( 'tamaño de la pila:', RES) 
        volver RES 
DEF parcheck (STR):
    Pila = S () 
    Marcos = True 
    index = 0 
    el mientras que el índice <len (STR) y Mark: 
        Símbolo STR = [índice] 
        # se presiona en paréntesis izquierdo 
        SI == '(' Símbolo: 
            s.push () Símbolo 
        caso # cuerdas el paréntesis derecho, la pila de lanzar un paréntesis izquierdo 
        de la persona: 
            SI s.isempty (): 
                Marcos = false 
            else: 
                s.pop () 

        . índice 1 = + 
    SI == True y s.isempty Marcos (): 
        print ( 'partido' ) 
        devolverá True 
    else: 
        print ( 'desajuste') 
        devolverá False 

# parcheck ( '()') 
# parcheck ( '()))') 
del while True: 
    S = input ( 'entrar en soportes de prueba' ").tira()
    parcheck (s)

soportes universales coincidentes

Aplicación de la decimal a la conversión binaria

clase de pila (): 
    DEF la __init __ (self): 
        print ( 'pila de inicialización') 
        self.items = [] 
    DEF estaVacia (Ser): 
        self.items retorno == [] 
    DEF empuje (Ser, del programa): 
        Imprimir ( 'en pila: 'punto) 
        self.items.insert (0, artículo) 
    DEF POP (Ser): 
        RES = self.items.pop (0) 
        Imprimir (' la pila:', RES) 
        volver RES 
    DEF PEEK (Ser): 
        self.items = RES [len (self.items) - 1.] 
        de impresión ( 'el elemento superior', RES) 
        volver RES 
    tamaño DEF (Self): 
        RES = len (self.items) 
        Imprimir ( "tamaño de la pila: ' RES) 
        de retorno RES 
DEF divideby2 (NUM): 
    S = Stack ()
    = Resultado '' 
    NUM = int (NUM) 
    el mientras NUM> 0: 
        # resto 
        Q = 2% NUM 
        s.push (Q) 
        # comercialmente 
        NUM = NUM 2 // 
    el mientras s.isempty No (): # de salida 
        resultado = resultado + STR (s.pop) () 

    devolver resultado 

del while True: 
    . S = input ( 'Enter para convertir el número decimal>') Gaza () 
    Resultado = divideby2 (S) 
    de impresión (Resultado)

Aplicación (a su vez sufijo expresión infija)

la implementación del código

si se detecta la palabra # invertida carta palabra 
clase Stack (): 
    DEF la __init __ (self): 
        print ( 'pila de inicialización') 
        self.items = [] 
    DEF isEmpty (Ser): 
        self.items retorno == [] 
    DEF push (Ser, del programa): 
        print ( 'pila:', punto) 
        self.items.insert (0, artículo) 
    DEF POP (Ser): 
        RES = self.items.pop (0) 
        Imprimir ( "la pila: ' , RES) 
        volver RES 
    DEF PEEK (Self): 
        RES = self.items [. len (self.items) - 1] 
        de impresión ( 'el elemento superior', RES) 
        volver RES 
    tamaño DEF (Self): 
        RES = len (Ser. artículos) 
        Imprimir ( "tamaño de la pila: 'res) 
        res de retorno 

def infixtopostfix (objetivos):
    # Operador precedencia 

    prec = {} 
    prec [ '*'] = 3. 
    Prec [ '/'] = 3. 
    Prec [ '+'] = 2 
    prec [ '-'] = 2 
    . Prec [ '('] = 1 
    # operador de pila 
    opstack = pila () 
    postfixlist = [] 
    # aquí la mala figura 
    goallist = Lista (objetivos) 
    en el goallist Meta: 
        si el objetivo de 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'or Meta en' 0123456789 ': 
            postfixlist.append (Meta) 
        elif == Objetivo '(': 
            opstack.push (Meta) 
        elif Objetivo == ')': 
            topgoal = opstack.pop () 
            al mismo tiempo topgoal = '(': 
                postfixlist.append (topgoal) 
                topgoal opstack.pop = ()
        otra cosa: 
            cuando (no opstack.isempty ()) y (prec [opstack.peek ()]> = prec [objetivo]): 
                postfixlist.append (opstack.pop ()) 
            opstack.push (objetivo) 
    , mientras que no opstack.isempty (): 
        postfixlist.append (opstack.pop ()) 
    de retorno '' .join (postfixlist) 

while True: 
    s = entrada. ( '请输入要转换的表达式>') tira () 
    resultado = infixtopostfix (s) 
    de impresión (resultado)

 Aplicación (expresión postfix)

la implementación del código

si se detecta la palabra # invertida carta palabra 
clase Stack (): 
    DEF la __init __ (self): 
        print ( 'pila de inicialización') 
        self.items = [] 
    DEF isEmpty (Ser): 
        self.items retorno == [] 
    DEF push (Ser, del programa): 
        print ( 'pila:', punto) 
        self.items.insert (0, artículo) 
    DEF POP (Ser): 
        RES = self.items.pop (0) 
        Imprimir ( "la pila: ' , RES) 
        volver RES 
    DEF PEEK (Self): 
        RES = self.items [. len (self.items) - 1] 
        de impresión ( 'el elemento superior', RES) 
        volver RES 
    tamaño DEF (Self): 
        RES = len (Ser. artículos) 
        Imprimir ( "tamaño de la pila: 'res) 
        res de retorno 

def infixtopostfix (objetivos):
    # Operador precedencia 

    prec = {} 
    prec [ '*'] = 3. 
    Prec [ '/'] = 3. 
    Prec [ '+'] = 2 
    prec [ '-'] = 2 
    . Prec [ '('] = 1 
    # operador de pila 
    opstack = pila () 
    postfixlist = [] 
    # aquí la mala figura 
    goallist = Lista (objetivos) 
    en el goallist Meta: 
        si el objetivo de 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'or Meta en' 0123456789 ': 
            postfixlist.append (Meta) 
        elif == Objetivo '(': 
            opstack.push (Meta) 
        elif Objetivo == ')': 
            topgoal = opstack.pop () 
            al mismo tiempo topgoal = '(': 
                postfixlist.append (topgoal) 
                topgoal opstack.pop = ()
        otra cosa: 
            cuando (no opstack.isempty ()) y (prec [opstack.peek ()]> = prec [objetivo]): 
                postfixlist.append (opstack.pop ()) 
            opstack.push (objetivo) 
    , mientras que no opstack.isempty (): 
        postfixlist.append (opstack.pop ()) 
    de retorno '' .join (postfixlist) 

def postfixeval (express): 
    opertostack = pila () 
    expresar lista = lista (expreso) 
    de impresión (lista expresa) 
    para i en lista expresa: 
        si i en '0123456789': 
            opertostack.push (int (i)) 
        más: 
            oper2 opertostack.pop = () 
            oper1 opertostack.pop = () 

            resultado = Domath (i, oper1, oper2)
            opertostack.push (Resultado) 
    volver opertostack.pop () 
DEF domath (OP, OP-1, OP2): 
    SI OP == '*': 
        retorno OP1 OP2 * 
    OP elif == '/': 
        el retorno de OP-1 / OP2 
    elif OP == '+': 
        el retorno de OP-1 + OP2 
    la otra cosa: 
        el retorno de OP-1-OP2 

el while True: 
    . S = input ( 'introducir la expresión que se desea convertir>') Gaza () 
    RESULT1 = infixtopostfix (S) 
    de impresión (RESULT1) 
    result2 postfixeval = ( resultado1) 
    Imprimir (result2)