Structures de données et algorithmes (6) - Stack Stack

• Les définitions de base

Quelle est la pile: la pile il y a un ensemble de commande éléments de données. Dans l'empilement, ajoutés, et les éléments démontés sont produisent uniquement à la même extrémité, cette extrémité de la pile d'appel (Top), l'autre extrémité de la pile, aucune opération est appelée un fond (base).

Caractéristiques: LIFO, dernier sorti

• Le fonctionnement de base de la pile

Nous devons savoir qu'il n'y a pas pile en python, mais nous pouvons simuler une pile.

Tout d'abord, une partie de l'opération de base de la pile, nous devons définir:

Empiler()	Créer une pile vide, il ne contient aucun élément de données
poussoir (article)	L'élément ajouté à la pile, aucune valeur de retour
pop()	La partie supérieure de l'élément de données de la pile est enlevé et retourné, la pile a été modifiée
peek ()	Afficher les éléments de données pile, les éléments de retour sans enlever le haut de la pile, et ne modifie pas la pile
est vide()	Retourne si la pile est vide
Taille()	pile de retour du nombre d'éléments de données

 

 

 

 

 

 

 

 

Ici, nous pouvons mettre en œuvre une pile avec une liste des types d'opération:

. 1  classe Stack:
 2      '' ' 
3.      Leur propre définition d'une pile
 4 de  　　la pile est une extrémité arrière, l'extrémité arrière peut être fixée en haut de la pile
 5.      ''' 
6.      DEF  le __init__ (self):
 . 7          self.items = []
 . 8      DEF isEmpty (auto-):
 . 9          retour self.items == []
 10      DEF push (Soi, Item)
 . 11          self.items.append (point)
 12 est      DEF POP (Self):
 13 est          self.items.pop ()
 14      DEF PEEK (auto-):
 15          retour self.items [len (self.items) -1 ]
16      def taille (self):
 17          retour len (self.items)
 18  si  __name__ == ' __main__ ' :
 19      s = Stack ()
 20      s.push ( ' 1 ' )
 21      s.push ( ' un ' )
 22      print (s.isEmpty ())
 23      impression (s.peek ())
 24      impression (s.size ())

1  [out]:
 2  Faux
 3  a
 4 2
 5  
6 Processus terminé avec le code de sortie 0

 

• Pile d'applications

1. supports correspondants simples

Tâche: faire correspondre les parenthèses correspondant gauche et droite, entre parenthèses construire un algorithme de correspondance. De gauche à droite, crochets de balayage la dernière parenthèse ouverte gauche, parenthèse droite doit correspondre à la première rencontre 

Flowchart:

 

 

 code:

1  à partir de la pile importation Stack
 2  def parChecker (symbolString):
 3      s = Stack ()
 4      pondérées = Vrai
 5      index = 0
 6      tandis que l' indice <len (symbolString) et équilibré:
 7          symbole = symbolString [index]
 8          si le symbole == " ( " :
 9              s.push (symbole)
 10 d'          autre :
 11              si s.isEmpty ():
 12                  équilibré =Faux
 13              autres :
 14                  s.pop ()
 15          index = indice + 1
 16      si équilibré et s.isEmpty ():
 17          retour Vrai
 18      autres :
 19          retour Faux
 20  impression (parChecker ( ' ((())))) ' ))
 21  impression (parChecker ( ' (((()))) ' ))

[SORTIE]: 
1  Faux
 2  Vrai
 3  
4 Processus terminé avec le code de sortie 0

Dans la pratique, cependant, le support est souvent plus complexe, tel que {} () []

Référence: https://www.bilibili.com/video/BV1QJ411w7bB?p=17