Analysons ensemble les applications et les exercices liés aux files d'attente Python

Cet article vous apporte des connaissances pertinentes sur python, qui présente principalement des exercices d'application liés aux files d'attente, notamment comment utiliser deux piles pour implémenter une file d'attente, comment utiliser deux files d'attente pour implémenter une pile et juger de la continuité des éléments de la pile, etc. J'espère que cela sera utile à tout le monde.

Apprentissage recommandé : Tutoriel Python

0. Objectifs d'apprentissage

Nous avons appris les concepts associés aux files d'attente et à leur mise en œuvre, et avons également compris la large application des files d'attente dans des problèmes pratiques. L'objectif principal de cette section. Il s'agit d'approfondir davantage la compréhension des files d'attente grâce à des exercices liés aux files d'attente, et en même temps, les files d'attente peuvent être utilisées pour réduire la complexité temporelle de la résolution de certains problèmes complexes.

1. Utilisez deux piles pour implémenter une file d'attente

[Question] Étant donné deux piles, implémentez une file d'attente en utilisant uniquement les opérations de base de la pile.

[Idée] La clé pour résoudre ce problème réside dans la fonction d'inversion de la pile. Une série d'éléments poussés sur la pile sera renvoyée dans l'ordre inverse lorsqu'elle sera retirée de la pile. Par conséquent, l'utilisation de deux piles peut obtenir le retour des éléments dans le même ordre (la séquence inversée des éléments sera à nouveau inversée pour obtenir l'ordre d'origine). L'opération spécifique est illustrée dans la figure ci-dessous :

[Algorithme]

Mettre en file d'attentemettre en file d'attente :
 Pousser les éléments sur la pilestack_1
Retirer dequeue :
Si la pile stack_2 n'est pas vide :
Retirer stack_2 de la file d'attente : pop l'élément supérieur de la pile
     Sinon :
       Supprimez tous les éléments de stack_1 et poussez-les dans stack_2
       stack_2 Pop l'élément supérieur de la pile enqueue：
   将元素推入栈 stack_1
 出队 dequeue：
   如果栈 stack_2 不为空：
     stack_2 栈顶元素出栈
   否则：
     将所有元素依次从 stack_1 弹出并压入 stack_2
     stack_2 栈顶元素出栈

[代码]

class Queue:
    def __init__(self):
        self.stack_1 = Stack()
        self.stack_2 = Stack()
    def enqueue(self, data):
        self.stack_1.push(data)
    def dequeue(self):
        if self.stack_2.isempty():
            while not self.stack_1.isempty():
                self.stack_2.push(self.stack_1.pop())
        return self.stack_2.pop()

[时空复杂度] 入队时间复杂度为$O(1)$，如果栈 stack_2 不为空，那么出队的时间复杂度为 $O(1)$，如果栈 stack_2 为空，则需要将元素从 stack_1 转移到 stack_2，但由于 stack_2 中转移的元素数量和出队的元素数量是相等的，因此出队的摊销时间复杂度为 $O(1)$。

2. Analysons ensemble les applications et les exercices liés aux files dattente Python

[问题] 给定两个队列，仅使用队列的基本操作实现一个栈。

[思路] 由于队列并不具备反转顺序的特性，入队顺序即为元素的出队顺序。因此想要获取最后一个入队的元素，需要首先将之前所有元素出队。因此为了使用两个队列实现栈，我们需要将其中一个队列 store_queue 用于存储元素，另一个队列 temp_queue 则用来保存为了获取最后一个元素而保存临时出队的元素。push 操作将给定元素入队到存储队列 store_queue 中；pop 操作首先把存储队列 store_queue 中除最后一个元素外的所有元素都转移到临时队列 temp_queue 中，然后存储队列 store_queue

[Code]

class Stack:
    def __init__(self):
        self.queue_1 = Queue()
        self.queue_2 = Queue()
    def isempty(self):
        return self.queue_1.isempty() and self.queue_2.isempty()
    def push(self, data):
        if self.queue_2.isempty():
            self.queue_1.enqueue(data)
        else:
            self.queue_2.enqueue(data)
    def pop(self):
        if self.isempty():
            raise IndexError("Stack is empty")
        elif self.queue_2.isempty():
            while not self.queue_1.isempty():
                p = self.queue_1.dequeue()
                if self.queue_1.isempty():
                    return p
                self.queue_2.enqueue(p)
        else:
            while not self.queue_2.isempty():
                p = self.queue_2.dequeue()
                if self.queue_2.isempty():
                    return p
                self.queue_1.enqueue(p)

[Complexité temporelle et spatiale] La complexité temporelle de la mise en file d'attente est O(1) , si la pile stack_2 n'est pas vide, alors la complexité temporelle du retrait de la file d'attente est $O(1)$ si la pile stack_2 est vide, les éléments doivent donc être transférés de stack_1 à stack_2, mais en raison du éléments transférés dans stack_2 Le nombre et le nombre d'éléments retirés de la file d'attente sont égaux, donc la complexité temporelle amortie de la sortie de la file d'attente est O (1).

🎜2. Implémentez une pile utilisant deux files d'attente🎜🎜🎜[Question]🎜 Étant donné deux files d'attente, implémentez une pile en utilisant uniquement les opérations de base de la file d'attente. 🎜🎜🎜[Idée]🎜 Puisque la file d'attente n'a pas la fonction d'inverser l'ordre, l'ordre dans lequel les éléments sont mis en file d'attente est l'ordre dans lequel les éléments sont retirés de la file d'attente. Par conséquent, si vous souhaitez mettre le dernier élément en file d’attente, vous devez d’abord retirer tous les éléments précédents de la file d’attente. Par conséquent, afin d'utiliser deux files d'attente pour implémenter une pile, nous devons utiliser l'une des files d'attente store_queue pour stocker les éléments, et l'autre file d'attente temp_queue pour enregistrer les éléments dans récupère le dernier élément temporairement retiré de la file d'attente. L'opération push met l'élément donné en file d'attente dans la file d'attente de stockage store_queue ; l'opération pop met d'abord l'élément donné en file d'attente dans la file d'attente de stockage store_queue. Tous les éléments sauf le dernier élément sont transférés vers la file d'attente temporaire temp_queue, puis le dernier élément de la file d'attente de stockage store_queue est retiré de la file d'attente et renvoyé. L'opération spécifique est illustrée dans la figure ci-dessous : 🎜🎜🎜🎜🎜🎜[Algorithme]🎜🎜

 算法运行过程需要始终保持其中一个队列为空，用作临时队列
 入栈 push：在非空队列中插入元素 data。
   若队列 queue_1 为空：
     将 data 插入 队列 queue_2 中
   否则：
     将 data 插入 队列 queue_1 中
 出栈 pop：将队列中的前$n-1$ 个元素插入另一队列，删除并返回最后一个元素
   若队列 queue_1 不为空：
     将队列 queue_1 的前$n-1$ 个元素插入 queue_2，然后 queue_1 的最后一个元素出队并返回
   若队列 queue_2 不为空：
     将队列 queue_2 的前$n-1$ 个元素插入 queue_1，然后 queue_2 的最后一个元素出队并返回

[代码]

class Stack:
    def __init__(self):
        self.queue_1 = Queue()
        self.queue_2 = Queue()
    def isempty(self):
        return self.queue_1.isempty() and self.queue_2.isempty()
    def push(self, data):
        if self.queue_2.isempty():
            self.queue_1.enqueue(data)
        else:
            self.queue_2.enqueue(data)
    def pop(self):
        if self.isempty():
            raise IndexError("Stack is empty")
        elif self.queue_2.isempty():
            while not self.queue_1.isempty():
                p = self.queue_1.dequeue()
                if self.queue_1.isempty():
                    return p
                self.queue_2.enqueue(p)
        else:
            while not self.queue_2.isempty():
                p = self.queue_2.dequeue()
                if self.queue_2.isempty():
                    return p
                self.queue_1.enqueue(p)

[时空复杂度] push 操作的时间复杂度为$O(1)$，由于 pop 操作时，都需要将所有元素从一个队列转移到另一队列，因此时间复杂度$O(n)$。

3. 栈中元素连续性判断

[问题] 给定一栈 stack1，栈中元素均为整数，判断栈中每对连续的数字是否为连续整数(如果栈有奇数个元素，则排除栈顶元素)。例如，输入栈 [1, 2, 5, 6, -5, -4, 11, 10, 55]，输入为 True，因为排除栈顶元素 55 后，(1, 2)、(5, 6)、(-5, -4)、(11, 10) 均为连续整数。

[思路] 由于栈中可能存在奇数个元素，因此为了正确判断，首次需要将栈中元素反转，栈顶元素变为栈底，然后依次出栈，进行判断。

[算法]

 栈 stack 中所有元素依次出栈，并插入队列 queue 中
 队列 queue 中所有元素出队，并入栈 stack
  while 栈 stack 不为空：
   栈顶元素 e1 出栈，并插入队列 queue 中
   如果栈 stack 不为空：
     栈顶元素 e2 出栈，并插入队列 queue 中
     如果 |e1-e2|!=1：
       返回 False，跳出循环
 队列 queue 中所有元素出队，并入栈 stack

[代码]

def check_stack_pair(stack):
    queue = Queue()
    flag = True
    # 反转栈中元素
    while not stack.isempty():
        queue.enqueue(stack.pop())
    while not queue.isempty():
        stack.push(queue.dequeue())
    while not stack.isempty():
        e1 = stack.pop()
        queue.enqueue(e1)
        if not stack.isempty():
            e2 = stack.pop()
            queue.enqueue(e2)
            if abs(e1-e2) != 1:
                flag = False
                break
    while not queue.isempty():
        stack.push(queue.dequeue())
    return flag

[时空复杂度] 时间复杂度为$O(n)$，空间复杂度为$O(n)$。

4. Analysons ensemble les applications et les exercices liés aux files dattente Python

[问题] 给定一个整数队列 queue，将队列的前半部分与队列的后半部分交错来重新排列元素。例如输入队列为 [1, 2, 3, 4, 5, 6, 7, 8, 9]，则输出应为 [1, 6, 2, 7, 3, 8, 4, 9, 5]。

[思路] 通过获取队列的前半部分，然后利用栈的反转特性，可以实现重排操作，如下图所示：

[算法]

 如果队列 queue 中的元素数为偶数：
   half=queue.size//2
 否则：
   half=queue.size//2+1
 1. 将队列 queue 的前半部分元素依次出队并入栈 stack
 2. 栈 stack 中元素出栈并入队 queue
 3. 将队列 queue 中在步骤 1中未出队的另一部分元素依次出队并插入队尾
 4. 将队列 queue 的前半部分元素依次出队并入栈 stack
 5. 将栈 stack 和队列 queue 中的元素交替弹出并入队
 6. 如果栈 stack 非空：
   栈 stack 中元素出栈并入队

[代码]

def queue_order(queue):
    stack = Stack()
    size = queue.size    if size % 2 == 0:
        half = queue.size//2
    else:
        half = queue.size//2 + 1
    res = queue.size - half    for i in range(half):
        stack.push(queue.dequeue())
    while not stack.isempty():
        queue.enqueue(stack.pop())
    for i in range(res):
        queue.enqueue(queue.dequeue())
    for i in range(half):
        stack.push(queue.dequeue())
    for i in range(res):
        queue.enqueue(stack.pop())
        queue.enqueue(queue.dequeue())
    if not stack.isempty():
        queue.enqueue(stack.pop())

[时空复杂度] 时间复杂度为$O(n)$，空间复杂度为$O(n)$。

5. 反转队列中前 m 个元素的顺序

[问题] 给定一个整数 m 和一个整数队列 queue，反转队列中前 k 个元素的顺序，而其他元素保持不变。如 m=5，队列为 [1, 2, 3, 4, 5, 6, 7, 8, 9]，算法输出为 [5, 4, 3, 2, 1, 6, 7, 8, 9]。

[思路] 结合 [问题4] 我们可以发现，此题就是 [问题4] 的前 3 步，如下图所示：

[算法]

 1. 将队列 queue 的前 m 个元素依次出队并入栈 stack
 2. 栈 stack 中元素出栈并入队 queue
 3. 将队列 queue 中在步骤 1中未出队的另一部分元素依次出队并插入队尾

[代码]

def reverse_m_element(queue, m):
    stack = Stack()
    size = queue.size    if queue.isempty() or m>size:
        return
    for i in range(m):
        stack.push(queue.dequeue())
    while not stack.isempty():
        queue.enqueue(stack.pop())
    for i in range(size-m):
        queue.enqueue(queue.dequeue())

[时空复杂度] 时间复杂度为$O(n)$，空间复杂度为 $O(n)$。

Apprentissage recommandé : Tutoriel 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!