Mari analisa aplikasi dan latihan berkaitan baris gilir Python bersama-sama

Artikel ini membawa anda pengetahuan yang berkaitan tentang python Ia terutamanya memperkenalkan latihan aplikasi berkaitan baris gilir, termasuk cara menggunakan dua tindanan untuk melaksanakan baris gilir, dan cara menggunakan dua baris gilir melaksanakan tindanan, menentukan. kesinambungan elemen dalam timbunan, dsb. Saya harap ia akan membantu semua orang.

Pembelajaran yang disyorkan: tutorial python

0 Objektif pembelajaran

Kami telah mempelajari konsep baris gilir yang berkaitan dan pelaksanaannya, dan juga mempelajari tentang aplikasi baris gilir yang meluas dalam masalah praktikal. kerumitan masa penyelesaian kepada beberapa masalah yang kompleks.

1. Laksanakan baris gilir menggunakan dua tindanan

[Soalan] Memandangkan dua tindanan, laksanakan baris gilir menggunakan hanya operasi asas tindanan.

[Idea] Kunci untuk menyelesaikan masalah ini terletak pada ciri pembalikan timbunan Satu siri elemen yang ditolak ke dalam timbunan akan dikembalikan dalam susunan terbalik apabila muncul daripada timbunan. Oleh itu, menggunakan dua tindanan boleh mencapai pengembalian unsur dalam susunan yang sama (jujukan unsur terbalik akan diterbalikkan semula untuk mendapatkan susunan asal). Operasi khusus ditunjukkan dalam rajah di bawah:

[Algoritma]

Sertai pasukan enqueue:
     Tolak elemen pada tindanan stack_1
Nyah gilir dequeue:
Jika tindanan stack_2 tidak kosong:
Tolak elemen atas keluar daripada tindanan stack_2 Jika tidak:
Tolak semua elemen Pop daripada
dan tolak ke dalam stack_1stack_2        
Elemen teratas tindanan muncul stack_2

[Kod]

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()

[Kerumitan ruang-masa] Kerumitan masa beratur ialah O (1), jika timbunan tidak kosong, maka kerumitan masa nyah gilir ialah stack_2O(1) jika tindanan kosong, anda perlu memindahkan elemen daripada stack_2 ke stack_1, tetapi memandangkan bilangan elemen yang dipindahkan dalam stack_2 dan bilangan elemen yang ditolak adalah sama, kerumitan masa terlunas bagi dequeuing ialah stack_2O(1) .

2. Laksanakan tindanan menggunakan dua baris gilir

[Soalan] Memandangkan dua baris gilir, laksanakan tindanan hanya menggunakan operasi asas baris gilir.

[Idea] Memandangkan baris gilir tidak mempunyai ciri menterbalikkan susunan, susunan unsur-unsur itu adalah tertib di mana unsur-unsur itu disingkirkan. Oleh itu, jika anda ingin memasukkan elemen terakhir, anda perlu terlebih dahulu menyahpintar semua elemen sebelumnya. Oleh itu, untuk menggunakan dua baris gilir untuk melaksanakan timbunan, kita perlu menggunakan salah satu baris gilir untuk menyimpan elemen, dan baris gilir yang lain store_queue untuk menyimpan elemen yang ditamatkan buat sementara waktu untuk mendapatkan elemen terakhir . Operasi temp_queue memasukkan elemen yang diberikan ke dalam baris gilir storan push; operasi store_queue mula-mula memindahkan semua elemen kecuali elemen terakhir dalam baris gilir storan pop ke baris gilir sementara store_queue, dan kemudian menyimpan Dequeues elemen terakhir dalam baris gilir temp_queue dan mengembalikannya. Operasi khusus ditunjukkan dalam rajah di bawah: store_queue

[Algoritma]

 算法运行过程需要始终保持其中一个队列为空，用作临时队列
 入栈 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. Mari analisa aplikasi dan latihan berkaitan baris gilir Python bersama-sama

[问题] 给定一个整数队列 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)$。

Pembelajaran yang disyorkan: tutorial python

Atas ialah kandungan terperinci Mari analisa aplikasi dan latihan berkaitan baris gilir Python bersama-sama. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!