Structure de données Python et file d'attente à double extrémité d'apprentissage d'algorithmes

Cet article vous apporte des connaissances pertinentes sur python, qui présente principalement les problèmes liés aux files d'attente à double extrémité, y compris les concepts de base des files d'attente à double extrémité, la mise en œuvre des files d'attente à double extrémité et les applications des files d'attente à double extrémité. J'espère utile à tout le monde.

Apprentissage recommandé : Tutoriel Python

0. Objectifs d'apprentissage

Une file d'attente à double extrémité est une autre structure de données linéaire. Bien qu'il s'agisse également d'une table linéaire restreinte, contrairement aux piles et aux files d'attente, les files d'attente à double extrémité ont peu de restrictions. Ses opérations de base sont également un sous-ensemble des opérations de table linéaire, mais du point de vue du type de données, elles sont extrêmement différentes des tables linéaires. . Cette section présentera la définition d'une file d'attente double et ses différentes implémentations, et donnera quelques applications pratiques d'une file d'attente double.
En étudiant cette section, vous devez maîtriser le contenu suivant :

• Les concepts de base et les différentes méthodes de mise en œuvre des files d'attente doubles
• La mise en œuvre et la complexité temporelle des opérations de base des files d'attente doubles
• Utiliser les opérations de base de files d'attente à double extrémité pour implémenter des algorithmes complexes

1. Le concept de base de la file d'attente à double extrémité

1.1 Le concept de base de la file d'attente à double extrémité

File d'attente à double extrémité (file d'attente à double extrémité code>, <code>deque) est également inséré et les opérations de suppression sont limitées aux listes linéaires aux deux extrémités de la séquence respectivement, mais contrairement aux piles et aux files d'attente, les files d'attente à double extrémité ont peu de restrictions pour les files d'attente à double extrémité. , l'arrière de la file d'attente (rear) et l'avant de la file d'attente (front) permettent à la fois l'insertion et la suppression d'éléments. De nouveaux éléments peuvent être ajoutés en tête ou en queue de la file d'attente. De même, les éléments existants peuvent être supprimés à chaque extrémité. Dans un sens, une file d'attente à double extrémité peut être considérée comme une combinaison d'une pile et d'une file d'attente. double-end queue, deque) 也是插入和删除操作分别被限制在序列两端的线性表，但与栈和队列不同的是，Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes的限制很少，对于Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes而言，队尾 (rear) 和队头 (front) 均允许插入元素和删除元素。新元素既可以被添加到队头， 也可以被添加到队尾。同理，已有的元素也能从任意一端移除。某种意义上，可以认为Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes是栈和队列的结合。

尽管Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes有栈和队列的很多特性，但是它并不要求按照这两种数据结构所限定的 LIFO 原则和 FIFO 原则操作元素。

1.2 Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes抽象数据类型

除了添加和移除元素外，Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes还具有初始化、判队空和求队长度等辅助操作。具体而言，Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes的抽象数据类型定义如下：

 基本操作：
  1. __itit__(): 初始化Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes
   创建一个空Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes
  2. size(): 求取并返回Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes中所含元素的个数 n
   若Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes为空，则返回整数0
  3. isempty(): 判断是否为空Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes
   判断Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes中是否存储元素
  4. addfront(data): Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes队头添加元素
   将元素 data 插入队头
  5. addrear(data): Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes队尾添加元素
   将元素 data 插入队尾
  6. removefront(): 删除Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes队头元素
   删除并返回队头元素
  7. removerear(): 删除Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes队尾元素
   删除并返回队尾元素

2. Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes的实现

和普通队列一样，Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes同样有顺序存储和链式存储两种存储表示方式。

2.1 顺序Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes的实现

类似于顺序队列，Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes的顺序存储结构利用一组地址连续的存储单元依次存放从Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes头到Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes尾的元素，同时需要用两个指针 front 和 rear 分别指示队列头元素和队列尾元素的位置。初始化空Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes时，front=rear=0，当元素入队时，rear 加 1，而元素出队时，front 加 1，同时为了重复利用空闲空间，我们将顺序Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes假设尾环状空间，最后一个空间和第一个空间视为连续空间(具体原因参考)：

同样顺序Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes可以是固定长度和动态长度，当Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes满时，定长顺序Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes会抛出Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes满异常，动态顺序Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes则会动态申请空闲空间。

2.1.1 Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes的初始化

顺序Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes的初始化需要 4 部分信息：deque 列表用于存储数据元素，max_size 用于存储 queue 列表的最大长度，以及 front 和 rear

🎜 Opérations de base : 🎜 ˜ 1. __itit__() : initialiser le deque 🎜 ˜Créer un deque vide 🎜 ˜ 2. size() : Rechercher l'union Renvoie le nombre n d'éléments contenus dans la file d'attente double. Si la file d'attente double est vide, l'entier 0 est renvoyé. isempty() : Détermine si la file d'attente double est vide. : Ajoutez des éléments en tête de la file d'attente à double extrémité 🎜     Insérez les données d'élément au début de la file d'attente 🎜   5. addrear(data) : Ajoutez des éléments à la fin de la file d'attente à double extrémité 🎜     Insérez les données d'élément à la fin de la file d'attente 🎜   6. removefront() : Supprime le double L'élément de tête de la file d'attente à double extrémité 🎜 ˆ ˜ supprime et renvoie l'élément avant 🎜 ˆ 7. removerear() : supprime l'élément arrière de la file d'attente à double extrémité 🎜 ˆ ˆ supprime et renvoie l'élément arrière de la file d'attente à double extrémité 🎜

class Deque:
    def __init__(self, max_size=6):
        self.max_size = max_size
        self.deque = [None] * self.max_size
        self.front = 0
        self.rear = 0

2.1.2 Trouver la longueur de la file d'attente à double extrémité

Puisque front et rear sont utilisés pour enregistrer l'index de l'élément head et de l'élément tail respectivement, nous pouvons facilement calculer la longueur de la file d'attente à double extrémité ; en même temps, nous devons considérer que la file d'attente à double extrémité est une file d'attente circulaire front peut être plus grande que . arrière et ne peut pas être directement transmis via le code arrière-avant>, nous devons utiliser une formule de calcul pour résoudre ce problème :
front 和 rear 分别用于记录队头元素和队尾元素的索引，因此我们可以方便的计算出Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes的长度；同时我们需要考虑Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes为Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes，front 可能大于 rear，不能直接通过 rear-front，我们需要利用公式计算解决此问题：

Python 实现如下：

    def size(self):
        return (self.rear-self.front+self.max_size) % self.max_size

2.1.3 判Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes空

根据 front 和 rear 的值可以方便的判断Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes是否为空：

    def isempty(self):
        return self.rear==self.front

2.1.4 判Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes满

根据 front 和 rear 的值可以方便的判断Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes是否还有空余空间：

    def isfull(self):
        return ((self.rear+1) % self.max_size == self.front)

2.1.5 Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes队头和队尾添加元素

添加元素时，需要首先判断Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes中是否还有空闲空间，然后根据Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes为定长顺序Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes或动态顺序Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes，添加元素操作稍有不同：
[定长顺序Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes的添加元素操作] 如果队满，则引发异常：

    # 注意队头和队尾修改索引的添加元素的不同顺序
    def addrear(self, data):
        if not self.isfull():
            self.deque[self.rear] = data
            self.rear = (self.rear+1) % self.max_size        else:
            raise IndexError("Full Deque Exception")
    
    def addfront(self, data):
        if self.isfull():
            self.resize()
        if self.isempty():
            # 当Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes
            self.deque[self.rear] = data
            self.rear = (self.rear+1) % self.max_size        else:
            self.front = (self.front - 1 + self.max_size) % self.max_size
            self.deque[self.front] = data

[动态顺序Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes的添加元素操作] 如果Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes满，则首先申请新空间，然后再执行添加操作：

    def resize(self):
        new_size = 2 * self.max_size
        new_deque = [None] * new_size
        d = new_size - self.max_size        for i in range(self.max_size):
            new_deque[(self.front+i+d) % new_size] = self.deque[(self.front+i) % self.max_size]
        self.deque = new_deque
        self.front = (self.front+d) % new_size
        self.max_size = new_size        
    # 注意队头和队尾修改索引的添加元素的不同顺序
    def addrear(self, data):
        if self.isfull():
            self.resize()
        self.deque[self.rear] = data
        self.rear = (self.rear+1) % self.max_size    def addfront(self, data):
        if self.isfull():
            self.resize()
        self.front = (self.front - 1 + self.max_size) % self.max_size
        self.deque[self.front] = data

与动态顺序队列类似，我们同样需要考虑复制之后的索引，否则可能出现存在不能用的空闲空间：

添加元素的时间复杂度为$O(1)$。虽然当动态顺序Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes满时，原Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes中的元素需要首先复制到新Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes中，然后添加新元素，但参考《顺序表及其操作实现》中顺序表追加操作的介绍，由于 n 次添加元素操作的总时间$T(n)$ 与$O(n)$ 成正比，因此其摊销时间复杂度可以认为$O(1)$。

2.1.6 删除队头或队尾的元素

若Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes不空，则删除并返回指定端元素：

    # 注意队头和队尾修改索引的删除元素的不同顺序
    def removefront(self):
        if not self.isempty():
            result = self.deque[self.front]
            self.front = (self.front+1) % self.max_size            return result        else:
            raise IndexError("Empty Deque Exception")
    
    def removerear(self):
        if not self.isempty():
            self.rear = (self.rear - 1 + self.max_size) % self.max_size
            result = self.deque[self.rear]
            return result        else:
            raise IndexError("Empty Deque Exception")

2.2 链Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes的实现

Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes的另一种存储表示方式是使用链式存储结构，因此也常称为链Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes，其中 addfront 操作和 addrear 操作分别是通过在链表头部和尾部插入元素来实现的，而 removefront 操作和 removerear 操作分别是通过从头部和尾部删除结点来实现的。为了降低在尾部删除结点的时间复杂度，接下来基于双向链表实现Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes。

2.2.1 Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes结点

Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes的结点实现与双向链表并无差别：

class Node:
    def __init__(self, data=None):
        self.data = data
        self.next = None
    def __str__(self):
        return str(self.data)

2.2.2 Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes的初始化

Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes的初始化函数中，使其队头指针 front 和队尾指针 rear 均指向 None，并初始化Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes长度：

class Deque:
    def __init__(self):
        self.front = None
        self.rear = None
        self.num = 0

2.2.3 求Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes长度

返回 num 的值用于求取Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes的长度，如果没有 num 属性，则需要遍历整个链表才能得到Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes长度：

    def size(self):
        return self.num

2.2.4 判Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes空

根据Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes的长度可以很容易的判断其是否为空Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes：

    def isempty(self):
        return self.num <h4>2.2.5 添加元素</h4><p>Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes添加元素时，可以在队尾或队头插入新元素，因此需要修改 <code>rear</code> 和 <code>front</code> 指针，并且同时也要修改结点的 <code>next</code> 和 <code>previous</code></p><code>Python</code> est implémenté comme suit : 🎜<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false">    def addrear(self, data):
        node = Node(data)
        # 如果添加元素前Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes为空，则添加结点时，需要将front指针也指向该结点
        if self.front is None:
            self.rear = node
            self.front = node        else:
            node.previous = self.rear
            self.rear.next = node
            self.rear = node
        self.num += 1
    
    def addfront(self, data):
        node = Node(data)
        # 如果添加元素前Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes为空，则添加结点时，需要将rear指针也指向该结点
        if self.rear is None:
            self.front = node
            self.rear = node        else:
            node.next = self.front
            self.front.previous = node
            self.front = node
        self.num += 1