chapter_stack_and_queue/queue/

[giscus[bot]]

chapter_stack_and_queue/queue/

一本动画图解、能运行、可提问的数据结构与算法入门书

https://www.hello-algo.com/chapter_stack_and_queue/queue/

[JackCmd233]

针对Java的Queue类补充一些知识点：

	抛出异常	返回特殊值
插入	add(e)	offer(e)
删除	remove()	poll()
查看队头元素	element()	peek()

队列除了基本的 Collection 操作外，还提供特有的插入、提取和检查操作(如上)。每个方法都存在两种形式：一种抛出异常（操作失败时），另一种返回一个特殊值（null 或 false，具体取决于操作）。
除非有容量限制，否则在大多数实现中，插入操作不会失败。

[krahets]

顶

[cylovecode]

基于数组的实现，入队后将将输入元素赋值给 rear 索引处，感觉后面少了一句rear+1

[krahets]

不需要哈，rear 应该指向的就是尾元素

[zdxkaixin]

循环数组 -🐂的

[64yuer]

pop = que.popleft() 这里python的实现应该是pop = que.pop(0)，3.9.0版本无popleft用法，pooleft是用于collections中的deque对象

[64yuer]

抱歉，没看注释，没问题写的

[MackieLin]

队列一章中，包括双向队列，有些地方入队用 push , 有些地方入队用 offer，建议统一一下使文章更严谨。比如统一使用 Java 中的用词 offer

[krahets]

谢谢建议，已统一为 push()

[FFFPrime]

class typing.Deque 3.9 版后已移除，这个类型注解会导致程序报错

import typing
import collections
que: Deque[int] = collections.deque()
-------------------------------------------------
NameError: name 'Deque' is not defined

[krahets]

谢谢！本来采用的是 typing 标准，与 LeetCode 统一。已在 439 中更新为 PEP 585 标准，请拉取最新代码运行测试～

[zhuasdfg]

打卡，手敲了一遍链表和循环数组实现队列，不过我好像只能跟着敲。

[krahets]

第一遍跟着敲，后面慢慢就能自己写了～

[fiona-liu12]

基于链表实现的队列进行入队操作，如果队列不为空，则将该节点添加到尾节点后中的else语句里这两句不理解 rear.next = node; rear = node;，不应该只用rear.next = node;就行了嘛

[kiii0927]

rear.next = node; rear = node; 它们不是同时都指向新的尾结点了嘛。不应该是把下一个next指向新的尾结点node就可以吗

[bodaq99]

不知道是不是队尾rear和它的next都是node，然后node又是rear，所以node的next又是node，从而形成闭环，不知道这样理解对不对

[bodaq99]

噢我这个理解错了

[ZZY080]

属于尾插法需要不断更新尾
节点

[ZZY080]

rear.next = node; rear = node; 意思是 当前尾节点的下一个节点是node ； 然后把尾节点更改为node

[stySunshine]

问题：执行到 rear.next = node;（1处）这里后，当此时push的是2的时候，real.next.val = 2这个很好理解，为什么front.next.val = 2 也会赋值呢？在push的时候，又没有写front.next = node; 这里我不太理解~
/* 初始化队列 */
LinkedListQueue queue = new LinkedListQueue();

    /* 元素入队 */
    queue.push(1);
    queue.push(3);
    queue.push(2);
    queue.push(5);
    queue.push(4);
    System.out.println("队列 queue = " + Arrays.toString(queue.toArray()));

/* 入队 */
public void push(int num) {
// 尾节点后添加 num
ListNode node = new ListNode(num);
// 如果队列为空，则令头、尾节点都指向该节点
if (front == null) {
front = node;
rear = node;
// 如果队列不为空，则将该节点添加到尾节点后
} else {
rear.next = node; // 1处
rear = node;
}
queSize++;
}

[palp1tate]

用数组实现队列的三张演示图中的第二张，也就是push操作，并没有提及rear自增1的操作：

三个步骤应该是：

1. 将元素添加至rear处
2. 将rear自增1
3. 将queSize自增1

[krahets]

请看一下代码，rear 是用 font 和 queSize 计算的，图中的步骤没问题

[palp1tate]

get it，thanks

[l0190]

问题:环形数组队列的有效长度不应该是Maxsize=len(self.__nums)-1
python代码中的if self.__size == self.capacity()是不是不能作为队列已满的条件。应该改成if (self.__size+1) == self.capacity()

[krahets]

环形数组队列最大长度为 n - 1 、保留一个空位的原因是为了区分队列为空 or 满。文中的实现利用了一个 size 变量来记录数组长度，因此无需保留这个空位了

[yasaorder]

res = [0] * self.size()这种初始化队列的方式，会导致res 的每个元素引用相同的地址吗，就是如果我改动res[0]=1，那么res[1]、res[2]、...会不会因为存放的是相同的地址，导致都变为1

[krahets]

不会，但二维数组就不行了，例如 res = [[0] * self.size()] ，这样相当于多次引用了同一个一维列表 [0] 。

[sunshinesDL]

K 大这里的回复有些问题，小白重新梳理下供后来的小伙伴参考，需补充说明的是：python3中的变量实质上相当于 C 语言中的指针，存储的是引用对象的地址而非其值。此外，列表中每个元素存储的也是所引用对象的地址，故也相当于 "指针"。 参考如何理解 Python 列表的可变性。
如下列代码所示 (python3.12)：

In [7]: lst = [[0] * 10]	# 复制得到 10 个 0，使内层列表的 10 个元素都指向 0 这个整数对象
In [8]: lst
Out[8]: [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
In [9]: id(lst[0][0]), id(lst[0][1])	
Out[9]: (140727625132440, 140727625132440)	# 内层列表各个元素存储的地址相同

In [10]: lst[0][0] = 1	# 由于整数类型不可变，程序会新建一个对象 1，并使 lst[0][0]指向新对象的地址，内层列表的其他元素不受影响
In [11]: lst
Out[11]: [[1, 0, 0, 0, 0, 0, 0, 0, 0, 0]]	# 只有 lst[0][0] 指向的对象改变
In [12]: id(lst[0][0]), id(lst[0][1])
Out[12]: (140727625132472, 140727625132440)	# 只有 lst[0][0]存储的内存地址改变，验证上述结论

可见，对于 res = [[0] * self.size()] ，内层列表依旧相当于多次引用了整数对象 0，因此当内层列表某个元素改变时，由于整数对象的不可变性，内层列表的其他元素不受影响；

K大的意思可能是对于 res = [[0]] * self.size()，此时内层列表相当于多次引用了一维列表 [0]，当某个内层列表改变时，由于列表对象的可变性，程序会直接原地修改这个列表，使得引用该列表的其他内层列表也一同更新。

[ChinaYong]

在5.2.2的第1节基于链表的实现，C语言代码的打印队列函数中，for循环语句条件queue->front != queue->rear是用来检测队列是否为空吗？但是如果队列中只有一个元素，好像就会打印不出那个单独的元素

[Gonglja]

感谢指正，已修复

[pureliumy]

环形数组队列扩容

    /* 入队 */
    push(num) {
        if (this.size === this.capacity) {
            this.extendCapacity();
        }

        // ...
    }

    /* 扩容 */
    extendCapacity() {
      const extraSize = Math.round(this.capacity * 0.5);
      const arr = new Array(extraSize);

      this.#nums = this.toArray().concat(...arr);
      this.#front = 0;
      this.capacity += extraSize;
    }

[BIGcarter]

c++链表实现的队列，入队push()那里我有两个疑问：
（1）当链表为空时，front=node; rear = node; rear 不应该指向front吗？
（2）当链表不为空时，rear->next = node; read=node; 为什么不是node->next = rear; rear = node;
新节点指向原来的rear节点, 然后node成为新的rear节点？
感觉我还是对链表不甚了解..

[krahets]

emmm 感觉你需要重新看一下链表章节

[CitySunRise]

/* 出队 */
void pop(linkedListQueue *queue) {
int num = peek(queue);
ListNode *tmp = queue->front;
queue->front = queue->front->next;
free(tmp);
queue->queSize--;
}
这段代码中的 num 是为了记录出队元素吧 但是没看到相关的用处 原文中没有把它return出去

[krahets]

这里当时是为了和 C++ 内置队列的 pop() 操作行为对齐，是不 return 的。不过为了多语言一致性，我准备添加 return 了。

[FrierenGreatDemonLord]

这个用“环形数组”实现队列真的太巧妙了，各种操作刚好保证了下标不会溢出，而且数据在数组里都是连续存储的，也不会被覆盖或者打印了内存里的垃圾值（如 python 里默认给的0，C 里该地址上的随机值……）

[FrierenGreatDemonLord]

这设计、这操作够学一辈子😀

[yexiaoye-blue]

你好，在 队列实现 => 基于链表的实现章节 python代码中

def pop(self) -> int:
  """出队"""
  num = self.peek()
  # 删除头节点
  self._front = self._front.next
  self._size -= 1
  return num

是否需要考虑当队列中只有1个元素的情况，文章中的self._front=self._front.next虽在“只有1个元素”时，将_front至为None，但是_rear仍然有值。只是初学者，单纯不太懂其中含义。

# 出队
def pop(self) -> int:
  num = self.peek()
  if self.size() == 1:
    self._front = None
    self._rear = None
  else:
    self._front = self._front.next
  self._size -= 1
  return num

[YiChau]

我也觉得这里有问题，当只有一个元素时，front和rear都应该置为null。

[coronabear]

有一个元素，意味着头和尾都是它啊，你在想什么？

[jiuerya7]

只有一个元素的时候，self._front.next就是None

[KeepHard]

push 时判断了 所以pop这边可以不用这个判断

if (front == null) {
            front = node;
            rear = node;
        // 如果队列不为空，则将该节点添加到尾节点后
        } else {
            rear.next = node;
            rear = node;
        }

[22097212d]

我的想法是尾结点可能的作用有两个：1.被直接访问（像peek()那样直接返回值），但在queue中不允许直接访问尾结点,必须通过头结点.next 2.在增加新元素时确定下一个尾结点，但在push中，若头结点为空(只有一个节点的queue pop后）,尾结点会直接被赋值为新节点；当只存在一个节点且被pop时，rear无法被front.next访问（已经设为none),也不会对新的尾结点产生影响（会被直接覆盖）， 因此不用单独更改rear的值，

[wangbingqiang909]

在 hello-algo 里面的基于环形数组实现的队列用c语言在vim上运行之后最后的答案是有问题的

[wangbingqiang909]

在测试环形数组那一节得出来的答案有问题的。

[shyGuide]

/* 入队 */
public void push(int num) {
// 在尾节点后添加 num
ListNode node = new ListNode(num);
// 如果队列为空，则令头、尾节点都指向该节点
if (front == null) {
front = node;
rear = node;
// 如果队列不为空，则将该节点添加到尾节点后
} else {
rear.next = node;
rear = node;
}
queSize++;
}

---

rear.next = node;
rear = node;

这两行还是理解了很长时间

[YiChau]

先把node添加到现有的队列的尾节点之后，再让尾指针指向最新的“尾”节点。

[xuaidongx]

#ifndef __CUSTOMQUEUE_HPP__
#define __CUSTOMQUEUE_HPP__

/**
 * @file customQueue.hpp
 * @brief 基于数组和链表实现队列
 */

#include <cstdint>
#include <memory>
#include <stdexcept>

template<typename T, template<typename> typename Container>
class customQueue
{
public:
    void push_back(const T& v){m_elements.push_back(v);}
    void pop_front() {m_elements.pop_front();}
    const T& front() const {return m_elements.front();}
    T& front() {return const_cast<T&>(const_cast<const customQueue*>(this)->front());}
    bool empty() const {return m_elements.empty();}
    std::size_t size() const {return m_elements.size();}
private:
    Container<T> m_elements;
};

template<typename T>
class listContainer
{
struct linknode
{
    T value;
    std::shared_ptr<linknode> next;
    linknode(const T& v, std::shared_ptr<linknode> node):value(v), next(node){}
};
public:
    void push_back(const T& v)
    {
        if (!m_front && !m_rear)
        {
            m_front = std::make_shared<linknode>(v, m_rear);
            m_rear = m_front;
        }
        else
        {
            m_rear->next = std::make_shared<linknode>(v, nullptr);
            m_rear = m_rear->next;
        }
        ++m_size;
    }

    void pop_front()
    {
        if (empty())
            return;
        
        if (m_front == m_rear)
        {
            m_front = nullptr, m_rear = nullptr;
            --m_size;
            return;
        }

        m_front = m_front->next;
        --m_size;
    }

    const T& front() const {return m_front->value;}

    bool empty() const {return m_size == 0;}
    std::size_t size() const {return m_size;}
private:
    std::size_t m_size{0};
    std::shared_ptr<linknode> m_front{nullptr};
    std::shared_ptr<linknode> m_rear{nullptr};
};

template<typename T>
class arrayContainer
{
public:
    arrayContainer(std::size_t capacity = 100):m_capacity(capacity)
    {
        m_array = std::make_unique<T[]>(m_capacity);
    }

    void push_back(const T& v)
    {
        if (m_size == m_capacity && !realloc())
            return;

        auto rear = (m_front + m_size) % m_capacity;
        m_array[rear] = v;
        ++m_size;
    }

    void pop_front()
    {
        if (empty())
            return;
        
        m_front = (m_front + 1) % m_capacity;
        --m_size;
    }

    const T& front() const
    {
        if (empty())
            throw std::out_of_range("container is empty");
        
        return m_array[m_front];
    }

    bool empty() const {return m_size == 0;}
    std::size_t size() const {return m_size;}

    bool realloc()
    {
        auto new_capacity = m_capacity * 2;
        auto new_array = std::make_unique<T[]>(new_capacity);
        if (!new_array)
            return false;
        std::copy(&m_array[0], &m_array[m_size - 1], &new_array[0]);
        m_array = std::move(new_array);
        m_capacity = new_capacity;
        return true;
    }
private:
    std::size_t m_size{0};
    std::size_t m_capacity{0};
    std::unique_ptr<T[]> m_array;

    std::size_t m_front{0};
};

template<typename T>
using queueByList = customQueue<T, listContainer>;

template<typename T>
using queueByArray = customQueue<T, arrayContainer>;

#endif

[Unsichtbare1]

分享一个我在引入扩容机制的时候遇到的问题吧。一开始我在尝试用.size()去处理扩容问题，但是会遇到如下问题：
假设初始长度=5，
1：push成[1,2,3,4,5]
2：pop(), [2,3,4,5]
3: push(6), push(7)打印的结果会是[2,3,4,5,0,7] 这是因为用size计数push(6)的时候不会触发扩容，也就是push(6)之后的数组是[6,2,3,4,5]，再push(7)触发扩容变成[6,2,3,4,5,0,7]了。（扩容就是在后边加很多0）

所以要解决这个就是要在push(6)的时候就扩容，也就是对push也计数并根据push的个数来触发扩容，这样就可以解决这个问题。

[hrymdkjj]

成果展示
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#define MAX_SIZE 5

typedef struct
{
int *data; // 指向存放数据的数组
int front, rear;
int que_size;
} ArrayQueue;

ArrayQueue *new_array_queue()
{
ArrayQueue *que = malloc(sizeof(ArrayQueue));
que->front = -1;
que->rear = 2;
que->data = malloc(sizeof(int) * MAX_SIZE);
que->que_size = 0;
return que;
}
// 入队
void push(ArrayQueue *q, int data)
{
if (q->que_size == MAX_SIZE)
{
printf("队列已满 \n");
return;
}

q->rear = (q->rear + 1) % MAX_SIZE;
q->data[q->rear] = data;

if (q->que_size == 0) // 空队列队首就是队尾
{
    q->front = q->rear;
}

q->que_size++;

}

// 访问队首元素
int peek(ArrayQueue *q)
{
if (q->que_size == 0)
{
printf("队列为空 \n");
return INT_MAX;
}
return q->data[q->front];
}

// 出队
int pop(ArrayQueue *q)
{
int num = peek(q);
if (q->que_size == 0)
{
printf("队列为空");
return -1;
}
q->front = (q->front + 1) % MAX_SIZE;
q->que_size--;
return num;
}

/* 析构函数 */
void delArrayQueue(ArrayQueue *q) {
free(q->data);
free(q);
}

int main(int argc, char const *argv[])
{
ArrayQueue *q = new_array_queue();

push(q, 7);
push(q, 8);
push(q, 9);
push(q, 10);
// push(q, 11);
// push(q, 12);

printf("队首 %d \n", q->front);
printf("队尾 %d \n", q->rear);

for (int i = 0; i < MAX_SIZE; i++)
{
    printf("%d ", q->data[i]);
}
printf("\n");

// while (q->que_size)
// {
printf("出队 %d \n", pop(q));

printf("队首 %d \n", q->front);
printf("队尾 %d \n", q->rear);

for (int i = 0; i < MAX_SIZE; i++)
{
    printf("%d ", q->data[i]);
}
printf("\n");

push(q, 12);
push(q, 13);
push(q, 14);

printf("队首 %d \n", q->front);
printf("队尾 %d \n", q->rear);

for (int i = 0; i < MAX_SIZE; i++)
{
    printf("%d ", q->data[i]);
}
printf("\n");

delArrayQueue(q);

return 0;

}

[dblab0]

链表实现的队列pop函数可以优化下：

def pop(self) -> int:
    num = self.peek()
    self._front = self._front.next
    self._size -= 1
    # 补充空队列时的尾指针重置
    if self._size == 0:
        self._rear = None  # 新增逻辑
    return num

[jiuerya7]

如果队列为空，头节点不还是和初始化时的值一样为空？是否有些多余？

[TwentyInAQuiver]

这是尾节点， 如果不加这个判断，当最后一个元素被弹出后，_front 变为 None，但 _rear 仍然指向旧的节点， 这会导致队列状态不一致。

[sunshinesDL]

Hi，用链表实现的队列，当执行 pop() 使得队列为空时，其实不用重置尾指针 self._rear，因为在后续执行元素入队时会重置头、尾指针：

def push(self, num: int):
        """入队"""
        # 在尾节点后添加 num
        node = ListNode(num)
        # 如果队列为空，则令头、尾节点都指向该节点
        if self._front is None:
            self._front = node
            self._rear = node            # 重置尾指针
        # 如果队列不为空，则将该节点添加到尾节点后
        else:
            self._rear.next = node
            self._rear = node
        self._size += 1

即使后续不再有元素入队，当前尾指针的指向也不影响其他成员方法的执行 😁

[Limit1996]

对指针不熟理解链表实现的队列还是有点难度。。。

/// <summary>
/// 数组队列
/// </summary>
/// <typeparam name="T"></typeparam>
public class CustomArrayQueue<T>
{
    private readonly T[] _array = new T[10];
    private int _count = 0;
    private int _headIndex = 0;
    private int TailIndex => _headIndex + _count;
    public int Capacity => _array.Length;
    public int Count => _count;

    public void Enqueue(T value)
    {
        if (_count == _array.Length)
            throw new InvalidOperationException("队列已满");
        _array[TailIndex % Capacity] = value;
        _count++;
    }

    public T Dequeue()
    {
        var res = Peek();
        _array[_headIndex % Capacity] = default!;
        _headIndex++;
        _count--;
        return res;
    }

    public T Peek()
    {
        if (_count == 0)
            throw new InvalidOperationException("队列为空");
        return _array[_headIndex % Capacity];
    } 
}

[llsedu]

使用C语言中的void* 模拟其他语言中的泛型实现队列，确保队列的通用性。

#include "ListNode.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define LISTNODE_GENERIC
#ifdef LISTNODE_GENERIC

ListNode *newListNode(void *value,size_t size){
    ListNode *node = malloc(sizeof(ListNode));
    if(!node){
        printf("Memory allocation failed\n");
        exit(EXIT_FAILURE);
    }
    node->value = malloc(size);
    if(!node->value){
        printf("Memory allocation failed\n");
        exit(EXIT_FAILURE);
    }
    memcpy(node->value,value,size);
    node->elementSize = size;
    node->next = NULL;
    return node;

}


ListNode *addListNode(ListNode *head, void *value, size_t size){
    ListNode *newNode =  newListNode(value,size);
    newNode->next = head;
    return newNode;
    
}

ListNode *delListNode(ListNode *head, void *value,size_t size){
    ListNode *previous =NULL;
    ListNode *current = head;
    while(current !=NULL &&current->elementSize ==size&&memcmp(current->value,value,size)){
        previous = current;
        current = current->next;
    }

    if(current ==NULL){
        printf("未找到相关值");
        return head;
    }

    if(previous ==NULL){
        head = current->next;
    }
    else{
        previous->next = current->next;
    }
    free(current->value);
    free(current);
    return head;

}


ListNode * delListNodeByIndex(ListNode *head, int index){
    if(!head || index<0){
        printf("Invalid index\n");
        return head;
    }
    ListNode *pre  = NULL;
    ListNode *cur = head;
    int currentIndex = 0;
    while(!cur && currentIndex<index){
        pre=cur;
        cur=cur->next;
        currentIndex++;
    }
    if(!cur){
        printf("Index out of bounds\n");
        return head;
    }
    if(pre ==NULL){
        head = cur->next;
    }
    else{
        pre->next = cur->next;
    }

    free(cur->value);
    free(cur);
    return head;
}

void printListNode(ListNode *head, void (*printFunc)(void *)){
    if(!head){
        printf("List is empty\n");
        return;
    }
    ListNode *cur = head;
    while(cur){
        printFunc(cur->value);
        cur=cur->next;
    }
    printf("\n");

}

void freeListNode(ListNode *head){
    ListNode *cur = head;
    ListNode *next=NULL;

    while(cur){
        ListNode *next= cur->next;
        free(cur->value);
        free(cur);
        cur=next;
    }


}

#endif

#ifdef TEST_LISTNODE_GENERIC
void printInt(void *value) {
    printf("%d -> ", *(int *)value);
}

int main() {
    ListNode *head = NULL;
    
    // 添加节点到链表
    int value1 = 10, value2 = 20, value3 = 30;
    head = addListNode(head, &value1, sizeof(int));
    head = addListNode(head, &value2, sizeof(int));
    head = addListNode(head, &value3, sizeof(int));
    
    // 打印链表
    printf("原始链表: ");
    printListNode(head, printInt);
    
    // 删除值为20的节点
    int valueToDelete = 20;
    ListNode *node = delListNode(head, &valueToDelete, sizeof(int));

    
    // 打印删除后的链表
    printf("删除后的链表: ");
    printListNode(head, printInt);
    
    // 释放链表
    freeListNode(head);
    
    return 0;
}

#endif
#ifdef LISTNODE_INT

ListNode *newListNode(int value){
    ListNode *node =  malloc(sizeof(ListNode));
    if(!node){
        printf("Memory allocation failed\n");
        exit(EXIT_FAILURE);
    }
    node->value = value;
    node->next = NULL;
    return node;
}


ListNode *addListNode(ListNode *head, int value){
    ListNode *newNode  = malloc(sizeof(ListNode));
    if(!newNode){
        printf("Memory allocation failed\n");
        exit(EXIT_FAILURE);
    }
    newNode->value = value;
    newNode->next = head;
    head = newNode;
    return head;
}


ListNode *delListNode(ListNode *head,int value){

    ListNode *previous = NULL;
    ListNode *current = head;

    while(current!=NULL  && current->value!=value){
        previous = head;
        current=current->next;
    }

    if (current==NULL){
        printf("未找到相关值");
        return head;
    }
    if(previous==NULL){
        head = current->next;
    }
    else{
        previous->next = current->next;
    }

    free(current);
    return head;
}

void freeListNode(ListNode *head){
    ListNode *temp;
    while(head){
        temp=head;
        head =  head->next;
        free(temp);
    }

    free(head);
}
#endif

队列实现

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include "ListNode.h"

typedef struct LinkedListQueue{
    ListNode *head;
    ListNode *tail;
    int queueSize;
    
} LinkedListQueue;


LinkedListQueue* newLinkedListQueue(){
    LinkedListQueue *queue = malloc(sizeof(LinkedListQueue));
    if(!queue){
        printf("Memory allocation failed\n");
        exit(EXIT_FAILURE);
    }

    queue->head = NULL;
    queue->tail = NULL;
    queue->queueSize = 0;
    return queue;
}

void delLinkedListQueue(LinkedListQueue *queue){
    ListNode * temp = queue->head;
    while(temp){
        ListNode *next = temp->next;
        free(temp);
        temp = next;
    }
    free(queue);
}



int size(LinkedListQueue *queue){
    return queue->queueSize;
}

bool isEmpty(LinkedListQueue *queue){
    return queue->queueSize == 0;

}

LinkedListQueue* enqueue(LinkedListQueue *queue, void *value,size_t elementSize){
    ListNode *node = newListNode(value,elementSize);
    if(queue->head==NULL){
        queue->head=queue->tail=node;
    }else{
        queue->tail->next=node;
        queue->tail=node;
    }
    queue->queueSize++;
    return queue;
}


void* peek(LinkedListQueue *queue){
    if(isEmpty(queue)){
        printf("Queue is empty\n");
        return NULL;
    }
    return queue->head->value;
}

void* deqeueu(LinkedListQueue *queue,size_t elementSize){
    if(isEmpty(queue)){
        printf("Queue is empty\n");
        return NULL;
    }
    void* temp=peek(queue);
    ListNode *tempNode = queue->head;
    queue->head=queue->head->next;
    free(tempNode);
    queue->queueSize--;
    
    return temp;
}

void printLinkedListQueue(LinkedListQueue* queue, void (*printFunc)(void*)){
    if(isEmpty(queue)){
        printf("Queue is empty\n");
        return;
    }
    ListNode *temp = queue->head;
    while(temp){
        printFunc(temp->value);
        temp = temp->next;
    }
    printf("\n");
}

#define TEST_LINKEDLISTQUEUE
#ifdef TEST_LINKEDLISTQUEUE

void printIntQueue(void *value){
    printf("%d->",*(int*)value);
}


int main(){
    LinkedListQueue *queue = newLinkedListQueue();
    int a=1,b=3,c=5,d=7,e=9;
    enqueue(queue,&a,sizeof(int));
    enqueue(queue,&b,sizeof(int));
    enqueue(queue,&c,sizeof(int));
    enqueue(queue,&d,sizeof(int));
    enqueue(queue,&e,sizeof(int));
    printLinkedListQueue(queue,printIntQueue);
    printf("Queue size: %d\n",size(queue));
    printf("Queue is empty: %d\n",isEmpty(queue));
    printf("Peek: %d\n",*(int*)peek(queue));
    printf("Dequeue: %d\n",*(int*)deqeueu(queue,sizeof(int)));
    printLinkedListQueue(queue,printIntQueue);
}
#endif

[xiaozhuge123]

day04

[Ivy129]

打卡 2025年6月12日

[Mars13333]

发现一个问题，容易引起歧义。
在 基于数组的实现 的Go版本代码中，push方法的内部备注有问题。
// 当 rear == queCapacity 表示队列已满

[rongchuan17]

捉个虫，循环队列c语言中" queSize"的注释因该是队列长度吧，感觉写错了