链队列银行排队叫号系统

链队列银行排队叫号系统是一种数据结构，用于实现银行排队的叫号系统。该系统中，每个客户都可以取一个号码，并按照号码顺序排队等待办理业务。系统会不断地叫出下一个待办业务的客户号码，直至所有客户完成办理。

在该系统中，号码可以通过链队列进行存储和处理。链队列是一种基于链式存储结构的队列，它具有入队和出队的操作，可以实现先进先出的数据存储和处理。在银行排队叫号系统中，每个客户的号码可以作为一个节点，通过链式链接起来，形成一个完整的队列。

当客户到达银行后，系统会为其分配一个号码，并将该号码插入到队列的末尾。当银行业务处理完一个客户后，系统会从队列头部取出下一个客户的号码，并宣布其办理业务。该客户完成业务后，将自己的号码从队列头部删除，等待下一个客户办理业务。

通过链队列银行排队叫号系统，银行可以有效地管理客户流程，提高服务效率和客户体验。

相关问题

运用循环队列和链队列银行排队叫号系统

银行排队叫号系统是一个典型的队列应用场景，可以使用循环队列或者链队列来实现。

1. 循环队列实现

循环队列的特点是可以利用数组首尾相连的特性来实现循环利用队列空间，同时可以通过取余运算计算队头和队尾指针的值，避免队列满时浪费空间。

下面是使用循环队列实现银行排队叫号系统的示例代码。

class CircularQueue:
    def __init__(self, capacity):
        self.queue = [None] * capacity
        self.capacity = capacity
        self.head = 0
        self.tail = 0

    def enqueue(self, item):
        if (self.tail + 1) % self.capacity == self.head:
            return False  # 队列满了
        self.queue[self.tail] = item
        self.tail = (self.tail + 1) % self.capacity
        return True

    def dequeue(self):
        if self.tail == self.head:
            return None  # 队列为空
        item = self.queue[self.head]
        self.head = (self.head + 1) % self.capacity
        return item

    def is_empty(self):
        return self.head == self.tail

    def is_full(self):
        return (self.tail + 1) % self.capacity == self.head


class BankQueue:
    def __init__(self):
        self.queue = CircularQueue(100)
        self.current_number = 0

    def get_number(self):
        self.current_number += 1
        return self.current_number

    def enqueue(self):
        number = self.get_number()
        result = self.queue.enqueue(number)
        if result:
            print("顾客" + str(number) + "排队成功！")
        else:
            print("队列已满，无法排队！")

    def dequeue(self):
        number = self.queue.dequeue()
        if number is None:
            print("队列为空，无法出队！")
        else:
            print("当前叫号：" + str(number))

    def display(self):
        if self.queue.is_empty():
            print("队列为空！")
        else:
            print("当前排队情况：", end="")
            for i in range(self.queue.head, self.queue.tail):
                print(str(self.queue.queue[i]) + " ", end="")
            print()

2. 链队列实现

链队列的特点是利用链表来存储队列元素，因此可以动态地分配内存空间，避免了循环队列可能出现的空间浪费问题。

下面是使用链队列实现银行排队叫号系统的示例代码。

class Node:
    def __init__(self, data):
        self.data = data
        self.next_node = None


class LinkedQueue:
    def __init__(self):
        self.head = None
        self.tail = None

    def enqueue(self, item):
        new_node = Node(item)
        if self.tail is None:
            self.head = new_node
        else:
            self.tail.next_node = new_node
        self.tail = new_node

    def dequeue(self):
        if self.head is None:
            return None  # 队列为空
        item = self.head.data
        self.head = self.head.next_node
        if self.head is None:
            self.tail = None
        return item

    def is_empty(self):
        return self.head is None

    def is_full(self):
        return False


class BankQueue:
    def __init__(self):
        self.queue = LinkedQueue()
        self.current_number = 0

    def get_number(self):
        self.current_number += 1
        return self.current_number

    def enqueue(self):
        number = self.get_number()
        self.queue.enqueue(number)
        print("顾客" + str(number) + "排队成功！")

    def dequeue(self):
        number = self.queue.dequeue()
        if number is None:
            print("队列为空，无法出队！")
        else:
            print("当前叫号：" + str(number))

    def display(self):
        if self.queue.is_empty():
            print("队列为空！")
        else:
            print("当前排队情况：", end="")
            node = self.queue.head
            while node is not None:
                print(str(node.data) + " ", end="")
                node = node.next_node
            print()

链队列银行排队叫号系统，模拟银行客户排队办理业务的过程：通过取号进队、排队等候、叫号服务、当前不排队，余下依次等待、下班等

待状态。具体实现如下：

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

class Queue:
    def __init__(self):
        self.head = None
        self.tail = None
        self.size = 0

    def is_empty(self):
        return self.size == 0

    def enqueue(self, data):
        node = Node(data=data)
        if self.tail is None:
            self.head = node
        else:
            self.tail.next = node
        self.tail = node
        self.size += 1

    def dequeue(self):
        if self.is_empty():
            raise Exception("Queue is empty")
        data = self.head.data
        self.head = self.head.next
        self.size -= 1
        if self.is_empty():
            self.tail = None
        return data

class BankQueue:
    def __init__(self):
        self.queue = Queue()
        self.current_num = 0
        self.max_num = 99

    def get_number(self):
        if self.current_num > self.max_num:
            raise Exception("Bank is closed")
        self.current_num += 1
        return self.current_num

    def enqueue_customer(self):
        number = self.get_number()
        self.queue.enqueue(number)

    def serve_customer(self):
        return self.queue.dequeue()

bank = BankQueue()
for i in range(10):
    bank.enqueue_customer()

for i in range(4):
    print(f"Serving customer {bank.serve_customer()}")

for i in range(6):
    bank.enqueue_customer()
print(f"Next customer to serve is {bank.serve_customer()}")

在上述代码中，我们定义了一个 `Queue` 类来实现链队列，然后定义了一个 `BankQueue` 类来实现银行排队叫号系统。在 `BankQueue` 类中，我们定义了一个 `get_number` 方法来获取一个新的号码，它从 1 开始，直到 99，然后抛出异常表示银行已经关闭。我们还定义了 `enqueue_customer` 方法来将新客户入队，以及 `serve_customer` 方法来服务下一个客户。

在主函数中，我们首先让 10 个客户进入队列，然后依次服务前 4 个客户，然后让另外 6 个客户进入队列，最后服务下一个客户。输出如下：

Serving customer 1
Serving customer 2
Serving customer 3
Serving customer 4
Next customer to serve is 5