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

🎜🎜Bien que le deque ait une pile et files d'attente, mais il ne nécessite pas d'éléments opérationnels selon les principes LIFO et FIFO définis par ces deux structures de données. 🎜🎜🎜1.2 Type de données abstraits de file d'attente à double extrémité🎜🎜🎜En plus de l'ajout et de la suppression d'éléments, les files d'attente à double extrémité ont également des opérations auxiliaires telles que l'initialisation, le jugement de file d'attente vide et la longueur de la file d'attente. Plus précisément, le type de données abstraites de la file d'attente à double extrémité est défini comme suit : 🎜

🎜 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é 🎜

🎜2. Implémentation de la file d'attente à double extrémité 🎜🎜 et ordinaire Comme les files d'attente, les files d'attente à double extrémité ont également deux représentations de stockage : le stockage séquentiel et le stockage en chaîne. 🎜🎜🎜2.1 Implémentation d'une file d'attente séquentielle à double extrémité🎜🎜🎜Semblable à une file d'attente séquentielle, la structure de stockage séquentiel d'une file d'attente à double extrémité utilise un ensemble d'unités de stockage avec des adresses consécutives pour stocker les éléments de la tête de la file d'attente à double extrémité. file d'attente jusqu'à la queue de la file d'attente double en séquence. Utilisez deux pointeurs front et rear pour indiquer respectivement les positions de l'élément de tête de file d'attente et de l'élément de queue de file d'attente. Lors de l'initialisation d'une file d'attente double vide, front=rear=0, lorsqu'un élément est ajouté à la file d'attente, rear est augmenté de 1, et lorsqu'un élément est retiré de la file d'attente , front est augmenté de 1, et afin de réutiliser l'espace libre, nous supposons que la file d'attente séquentielle à double extrémité a un espace en anneau de queue, et le dernier espace et le premier espace sont considérés comme des espaces continus (pour des raisons spécifiques, veuillez vous référer à <file d s>) : 🎜🎜🎜🎜De la même manière, les files d'attente séquentielles à double extrémité peuvent être de longueur fixe et de longueur dynamique. Lorsque la file d'attente à double extrémité est pleine, la file d'attente séquentielle à double extrémité lèvera une exception complète de file d'attente à double extrémité, et la file d'attente séquentielle dynamique à double extrémité s'appliquera dynamiquement à l'espace libre. 🎜<h4>🎜2.1.1 Initialisation de la file d'attente à double extrémité🎜</h4>🎜L'initialisation de la file d'attente séquentielle à double extrémité nécessite 4 informations : la liste <code>deque est utilisée pour stocker les éléments de données, max_size est utilisé pour stocker la longueur maximale de la liste queue, et front et rear sont utilisés pour enregistrer les index des éléments de tête et de queue de la file d'attente respectivement :🎜.

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

Copier après la connexion

🎜🎜2.1.3 Déterminer que la file d'attente à double extrémité est vide🎜🎜🎜selon front et <code>rear peuvent facilement déterminer si la file d'attente à double extrémité est vide : 🎜

    def removefront(self):
        if self.isempty():
            raise IndexError("Empty Queue Exception")
        result = self.front.data
        self.front = self.front.next
        self.num -= 1
        if self.isempty():
            self.rear = self.front        else:
            # 若删除操作完成后，Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes不为空，将 front 指针的前驱指针指向 None
            self.front.previous = None
        return result    
    def removerear(self):
        if self.isempty():
            raise IndexError("Empty Queue Exception")
        result = self.rear.data
        self.rear = self.rear.previous
        self.num -= 1
        if self.isempty():
            self.front = self.rear        else:
            # 若删除操作完成后，Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes不为空，将 rear 指针的后继指针指向 None
            self.rear.next = None
        return result

🎜🎜2.1.4 Déterminer si la file d'attente à double extrémité est pleine🎜🎜🎜selon avant et la valeur de arrière peut facilement déterminer s'il y a de l'espace libre dans la file d'attente à double extrémité : 🎜

# 初始化一个最大长度为5的Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmesdq = Deque(5)print('Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes空?', dq.isempty())for i in range(3):
    print('队头添加元素：', 2*i)
    dq.addfront(2*i)
    print('队尾添加元素：', 2*i+1)
    dq.addrear(2*i+1)print('Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes长度为：', dq.size())for i in range(3):
    print('队尾删除元素：', dq.removerear())
    print('队头删除元素：', dq.removefront())print('Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes长度为：', dq.size())

🎜2.1.5 Ajouter des éléments à la tête et à la queue de la file d'attente à double extrémité🎜🎜Lors de l'ajout d'éléments, vous devez d'abord déterminer si il y a de l'espace libre dans la file d'attente, et selon que la file d'attente à double extrémité est une file d'attente séquentielle à double extrémité de longueur fixe ou une file d'attente séquentielle à double extrémité dynamique, l'opération d'ajout d'élément est légèrement différente :
🎜 [Ajouter une opération d'élément de la file d'attente séquentielle à double extrémité de longueur fixe]🎜 Si la file d'attente est pleine, une exception est levée : 🎜

Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes空? True队头添加元素： 0队尾添加元素： 1队头添加元素： 2队尾添加元素： 3队头添加元素： 4队尾添加元素： 5Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes长度为： 6队尾删除元素： 5队头删除元素： 4队尾删除元素： 3队头删除元素： 2队尾删除元素： 1队头删除元素： 0Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes长度为： 0

🎜🎜[Ajouter une opération d'élément de la séquence dynamique deque]🎜 Si la file d'attente est pleine, un nouvel espace est appliqué en premier, puis l'opération d'ajout est effectuée : 🎜

# 初始化新队列dq = Deque()print('Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes空?', dq.isempty())for i in range(3):
    print('队头添加元素：', i)
    dq.addfront(2*i)
    print('队尾添加元素：', i+3)
    dq.addrear(2*i+1)print('Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes长度为：', dq.size())for i in range(3):
    print('队尾删除元素：', dq.removerear())
    print('队头删除元素：', dq.removefront())print('Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes长度为：', dq.size())

🎜Avec séquence dynamique La file d'attente est similaire Nous devons également considérer l'index après la copie, sinon il peut y avoir de l'espace libre inutilisable : 🎜🎜🎜🎜La complexité temporelle de l'ajout d'éléments estO( 1). Bien que lorsque la file d'attente séquentielle dynamique à double extrémité est pleine, les éléments de la file d'attente double d'origine doivent d'abord être copiés dans la nouvelle file d'attente double, puis de nouveaux éléments sont ajoutés. Cependant, reportez-vous à l'introduction de la file d'attente séquentielle. opération d'ajout de table dans "Table de séquence et mise en œuvre de ses opérations", en raison de la durée totale de n opérations d'ajout d'élémentsT ( n) et $O(n)$ est proportionnel à la complexité temporelle amortie de ">O span>(1). 🎜🎜🎜2.1.6 Supprimer l'élément en tête ou en queue de la file d'attente🎜🎜🎜Si la file d'attente à double extrémité n'est pas vide, supprimez et renvoyez l'élément de fin spécifié : 🎜

Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes空? True队头添加元素： 0队尾添加元素： 3队头添加元素： 1队尾添加元素： 4队头添加元素： 2队尾添加元素： 5Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes长度为： 6队尾删除元素： 5队头删除元素： 4队尾删除元素： 3队头删除元素： 2队尾删除元素： 1队头删除元素： 0Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes长度为： 0

🎜2.2 Implémentation de la chaîne double- file d'attente terminée🎜

🎜Une autre représentation de stockage d'une file d'attente à double extrémité consiste à utiliser une structure de stockage en chaîne, elle est donc aussi souvent appelée file d'attente à double extrémité en chaîne, où l'opération addfront et les opérations addrear sont respectivement réalisées en insérant des éléments en tête et en queue de la liste chaînée, tandis que les opérations removefront et removerear sont implémentées en supprimant les nœuds de la tête et de la queue respectivement. Afin de réduire la complexité temporelle de la suppression des nœuds en queue, une file d'attente à double extrémité est implémentée sur la base d'une liste doublement chaînée. 🎜🎜🎜🎜2.2.1 Double Nœud de file d'attente à double extrémité 🎜🎜L'implémentation du nœud de la file d'attente à double extrémité n'est pas différente de celle de la liste doublement chaînée : 🎜

def ispalindrome(string):
    deque = Deque()
    for ch in string:
        deque.addfront(ch)
    flag = True
    while deque.size() > 1 and flag:
        ch1 = deque.removefront()
        ch2 = deque.removerear()
        if ch1 != ch2:
            flag = False
    return flag

🎜2.2.2 Initialisation de la file d'attente à double extrémité🎜🎜Dans la fonction d'initialisation de la file d'attente à double extrémité file d'attente, définissez son pointeur de tête front et le pointeur de queue de file d'attente <code>rear pointant tous deux sur Aucun, et initialisez la longueur de la file d'attente à double extrémité : 🎜

print('abcba是否为回文序列：', ispalindrome('abcba'))print('charaahc是否为回文序列：', ispalindrome('charaahc'))

🎜2.2.3 Trouver la longueur de la file d'attente à double extrémité🎜🎜return La valeur de num est utilisée pour trouver la longueur de la file d'attente à double extrémité s'il n'y a pas de num. , vous devez parcourir toute la liste chaînée pour obtenir la longueur de la file d'attente à double extrémité : 🎜

abcba是否为回文序列： True
charaahc是否为回文序列： False

🎜2.2.4 Détermination de la file d'attente à double extrémité La file d'attente est vide🎜🎜Vous pouvez facilement juger si elle est vide selon la longueur de la file d'attente double :🎜rrreee🎜2.2.5 Ajout d'éléments🎜🎜Lors de l'ajout d'éléments à la file d'attente double, vous pouvez insérer de nouveaux éléments en fin ou en tête de la file d'attente, donc le Les pointeurs Rear et front doivent être modifiés, et les pointeurs next et previous du nœud doivent également être modifiés en même temps. time; Si la file d'attente à double extrémité est vide avant d'ajouter des éléments, vous devez la gérer en conséquence : 🎜

    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

2.2.6 删除元素

若Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes不空，可以从删除队头或队尾元素并返回，删除操作需要更新队头指针 front 以及尾指针 rear，同时也要修改结点的 next 和 previous 指针，若出队元素尾队中最后一个结点，还需要进行相应处理：

    def removefront(self):
        if self.isempty():
            raise IndexError("Empty Queue Exception")
        result = self.front.data
        self.front = self.front.next
        self.num -= 1
        if self.isempty():
            self.rear = self.front        else:
            # 若删除操作完成后，Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes不为空，将 front 指针的前驱指针指向 None
            self.front.previous = None
        return result    
    def removerear(self):
        if self.isempty():
            raise IndexError("Empty Queue Exception")
        result = self.rear.data
        self.rear = self.rear.previous
        self.num -= 1
        if self.isempty():
            self.front = self.rear        else:
            # 若删除操作完成后，Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes不为空，将 rear 指针的后继指针指向 None
            self.rear.next = None
        return result

2.3 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的不同实现对比与栈的不同实现类似，可以参考《栈及其操作实现》。

3. 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，以验证操作的有效性，然后利用实现的基本操作来解决实际算法问题。

3.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 deque，然后测试相关操作：

# 初始化一个最大长度为5的Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmesdq = Deque(5)print('Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes空?', dq.isempty())for i in range(3):
    print('队头添加元素：', 2*i)
    dq.addfront(2*i)
    print('队尾添加元素：', 2*i+1)
    dq.addrear(2*i+1)print('Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes长度为：', dq.size())for i in range(3):
    print('队尾删除元素：', dq.removerear())
    print('队头删除元素：', dq.removefront())print('Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes长度为：', dq.size())

测试程序输出结果如下：

Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes空? True队头添加元素： 0队尾添加元素： 1队头添加元素： 2队尾添加元素： 3队头添加元素： 4队尾添加元素： 5Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes长度为： 6队尾删除元素： 5队头删除元素： 4队尾删除元素： 3队头删除元素： 2队尾删除元素： 1队头删除元素： 0Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes长度为： 0

3.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 queue，然后测试相关操作：

# 初始化新队列dq = Deque()print('Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes空?', dq.isempty())for i in range(3):
    print('队头添加元素：', i)
    dq.addfront(2*i)
    print('队尾添加元素：', i+3)
    dq.addrear(2*i+1)print('Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes长度为：', dq.size())for i in range(3):
    print('队尾删除元素：', dq.removerear())
    print('队头删除元素：', dq.removefront())print('Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes长度为：', dq.size())

测试程序输出结果如下：

Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes空? True队头添加元素： 0队尾添加元素： 3队头添加元素： 1队尾添加元素： 4队头添加元素： 2队尾添加元素： 5Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes长度为： 6队尾删除元素： 5队头删除元素： 4队尾删除元素： 3队头删除元素： 2队尾删除元素： 1队头删除元素： 0Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes长度为： 0

3.3 利用Structure de données Python et file dattente à double extrémité dapprentissage dalgorithmes基本操作实现复杂算法

[1] 给定一字符串 string (如：abamaba)，检查其是否为回文。

使用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 ispalindrome(string):
    deque = Deque()
    for ch in string:
        deque.addfront(ch)
    flag = True
    while deque.size() > 1 and flag:
        ch1 = deque.removefront()
        ch2 = deque.removerear()
        if ch1 != ch2:
            flag = False
    return flag

验证算法有效性：

print('abcba是否为回文序列：', ispalindrome('abcba'))print('charaahc是否为回文序列：', ispalindrome('charaahc'))

结果输出如下：

abcba是否为回文序列： True
charaahc是否为回文序列： False

推荐学习：python教程

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!