队列基础练习（C语言实现）

已于 2024-02-24 22:04:29 修改
阅读量886 收藏 13
点赞数 21
分类专栏： 算法/数据结构练习 文章标签： c语言 开发语言 数据结构
于 2024-02-24 22:02:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73281594/article/details/136276589
版权

目录

队列基础练习

用队列实现栈

用栈实现队列

设计循环队列

队列基础练习

用队列实现栈

题目链接：225. 用队列实现栈 - 力扣（LeetCode）

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（ push、 top、 pop 和 empty）。
实现 MyStack 类：
void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

思路解析：

本题要求用两个队列实现一个栈，队列的入队和出队顺序为先进先出，而栈的入栈和出栈顺序为后进先出，则在设计时可以参考以下思路：

因为队列满足先进先出，所以一个队列中的数据转移到另一个队列时不改变原来队列中数据的排列顺序，但是栈的数据是后进先出，所以当非空队列向空队列转移数据时只需要保留非空队列中的最后一个数据，再让该数据出队即可，而栈和队列的添加数据顺序相同，都是放在最后一个数据后的位置，所以插入数据只需要插入到当前非空队列的尾部即可

参考答案：

/*
 * @lc app=leetcode.cn id=225 lang=c
 *
 * [225] 用队列实现栈
 */

// @lc code=start

// 队列头文件
// 定义队列数据类型
typedef int QDataType;

// 定义队列的数据节点
typedef struct QueueNode
{
    QDataType data;
    struct QueueNode *next; // 下一个数据节点的位置
} QNode;

// 定义管理队列的结构
typedef struct Queue
{
    QNode *phead; // 队列头
    QNode *ptail; // 队列尾，便于找尾结点，省去每次入队都需要遍历队列
    int size;     // 队列的数据个数
} Queue;

// 初始化队列
void QueueInit(Queue *q);
// 销毁队列
void QueueDestroy(Queue *q);
// 数据入队
void QueuePush(Queue *q, QDataType x);
// 数据出队
void QueuePop(Queue *q);
// 获取队尾数据
QDataType QueueRear(Queue *q);
// 获取队头数据
QDataType QueueFront(Queue *q);
// 判断队列是否为空
bool QueueEmpty(Queue *q);
// 获取队列元素个数
int QueueSize(Queue *q);

// 队列实现
// 初始化队列
void QueueInit(Queue *q)
{
    // 判断是否存在队列
    assert(q);

    q->phead = q->ptail = NULL;
    q->size = 0;
}
// 销毁队列
void QueueDestroy(Queue *q)
{
    // 确保有队列的存在
    assert(q);
    // 删除队列的每一个节点
    // 注意循环条件不要用!QueueEmpty(q)，因为如果!QueueEmpty(q)只能说明队列不为空，但是q->phead是否为空不确定
    while (q->phead)
    {
        QNode *next = q->phead->next;
        free(q->phead);
        q->phead = next;
    }
    q->phead = q->ptail = NULL;
    q->size = 0;
}
// 数据入队
void QueuePush(Queue *q, QDataType x)
{
    // 确保存在队列
    assert(q);

    // 为数据创建节点
    QNode *newNode = (QNode *)malloc(sizeof(QNode));
    assert(newNode);
    newNode->data = x;
    newNode->next = NULL;
    // 插入数据
    // 队列为空，更新头和尾节点
    // 队列不为空，更新尾结点
    // 尾插思路
    if (!q->ptail)
    {
        q->phead = q->ptail = newNode;
    }
    else
    {
        q->ptail->next = newNode;
        q->ptail = q->ptail->next; // 更新ptail到新的节点
    }

    // 注意更新size
    q->size++;
}
// 数据出队
void QueuePop(Queue *q)
{
    // 确保有队列存在
    assert(q);
    // 如果队列为空不执行删除
    assert(!QueueEmpty(q));

    // 头删思路
    if (q->phead == q->ptail)
    {
        // 注意考虑到最后一个指针的ptail需要置空问题，防止野指针
        q->ptail = NULL;
    }
    QNode *next = q->phead->next;
    free(q->phead);
    q->phead = next;

    // 注意更新size
    q->size--;
}
// 获取队尾数据
QDataType QueueRear(Queue *q)
{
    // 确保有队列存在
    assert(q);
    // 确保队列不为空
    assert(!QueueEmpty(q));

    // 返回ptail指向的位置的值
    return q->ptail->data;
}
// 获取队头数据
QDataType QueueFront(Queue *q)
{
    // 确保有队列存在
    assert(q);
    // 确保队列不为空
    assert(!QueueEmpty(q));

    // 返回phead指向的位置的值
    return q->phead->data;
}
// 判断队列是否为空
bool QueueEmpty(Queue *q)
{
    // 确保有队列的存在
    assert(q);

    //&&只有全部满足才返回为真
    return q->phead == NULL && q->ptail == NULL && q->size == 0;
}
// 获取队列元素个数
int QueueSize(Queue *q)
{
    // 确保有队列的存在
    assert(q);

    return q->size;
}

typedef struct
{
    // 定义两个队列结构
    Queue q1;
    Queue q2;
} MyStack;

MyStack *myStackCreate()
{
    // 初始化队列和栈
    MyStack *stack = (MyStack *)malloc(sizeof(MyStack));

    // 初始化维护队列指针
    QueueInit(&(stack->q1));
    QueueInit(&(stack->q2));

    return stack;
}

void myStackPush(MyStack *obj, int x)
{
    assert(obj);
    // 向非空的队列中插入数据
    if (QueueEmpty(&(obj->q1)))
    {
        QueuePush(&(obj->q2), x);
    }
    else
    {
        QueuePush(&(obj->q1), x);
    }
}

int myStackPop(MyStack *obj)
{
    assert(obj);
    // 向非空的队列中插入数据
    // 获取非空队列和空队列
    Queue *pNotEmpty = &(obj->q1);
    Queue *pEmpty = &(obj->q2);
    if (QueueEmpty(&(obj->q1)))
    {
        pNotEmpty = &(obj->q2);
        pEmpty = &(obj->q1);
    }

    // 非空队列中留下一个数据，剩余数据转移到空队列
    while (pNotEmpty->phead != pNotEmpty->ptail)
    {
        QueuePush(pEmpty, QueueFront(pNotEmpty));
        QueuePop(pNotEmpty);
    }
    // 也可以通过size判断
    // while (QueueSize(pNotEmpty) > 1)
    // {
    //     QueuePush(pEmpty, QueueFront(pNotEmpty));
    //     QueuePop(pNotEmpty);
    // }

    int data = pNotEmpty->ptail->data;
    QueuePop(pNotEmpty);

    return data;
}

int myStackTop(MyStack *obj)
{
    assert(obj);
    // 获取非空队列的队头数据
    if (QueueEmpty(&(obj->q1)))
    {
        return obj->q2.ptail->data;
    }
    else
    {
        return obj->q1.ptail->data;
    }
}

bool myStackEmpty(MyStack *obj)
{
    assert(obj);
    return QueueEmpty(&(obj->q1)) && QueueEmpty(&(obj->q2));
}

void myStackFree(MyStack *obj)
{
    assert(obj);
    QueueDestroy(&(obj->q1));
    QueueDestroy(&(obj->q2));
    free(obj);
}

/**
 * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
 * myStackPush(obj, x);

 * int param_2 = myStackPop(obj);

 * int param_3 = myStackTop(obj);

 * bool param_4 = myStackEmpty(obj);

 * myStackFree(obj);
*/
// @lc code=end

用栈实现队列

题目链接：232. 用栈实现队列 - 力扣（LeetCode）

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（ push、 pop、 peek、 empty）：
实现 MyQueue 类：
void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空，返回 true ；否则，返回 false
说明：
你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

思路解析：

本题和上题思路类似，但是不建议直接照搬上一题的思路，参考以下思路：

定义两个栈，但是不同于上题的两个队列（两个队列没有区分），本题中的两个栈需要作区分，一个栈作为数据出模拟队列的栈，另一个作为数据入模拟队列的栈

因为数据出栈顺序为后进先出，所以在pushST中的数据转移到popST中后会改变原数据的顺序，而改变后的顺序中数据出栈刚好和队列中的数据出队相同，所以可以区分两个不同的栈，一个专用为存储进队列的数据，另一个专用为存储出队列的数据，当popST数据全部出完后再将pushST中数据转移到popST进行下一次的数据出队

参考答案：

/*
 * @lc app=leetcode.cn id=232 lang=c
 *
 * [232] 用栈实现队列
 */

// @lc code=start
// 栈的实现
typedef int STDataType;
typedef struct stack
{
    STDataType *data;
    int top;      // 栈顶位置
    int capacity; // 元素个数
} ST;

// 栈的初始化
void STInit(ST *st);
// 栈的销毁
void STDestroy(ST *st);
// 数据入栈
void STPush(ST *st, STDataType x);
// 数据出栈
void STPop(ST *st);
// 判断栈是否为空
bool STEmpty(ST *st);
// 获取栈顶元素
STDataType STTop(ST *st);
// 获取栈内数据个数
int STSize(ST *st);

// 栈的初始化
void STInit(ST *st)
{
    // 判断是否存在队列
    assert(st);
    // 初始化队列
    st->data = NULL;
    st->top = 0; // 栈顶指针指向存储数据的下一个位置，代表栈内无数据
    // st->top = -1;//栈顶指针指向存储数据的位置，代表栈内无数据
    st->capacity = 0;
}

// 栈的销毁
void STDestroy(ST *st)
{
    // 确保有栈的存在
    assert(st);
    // 销毁栈
    free(st->data);
    st->data = NULL;
    // top和capacity更改为无数据的位置
    st->top = st->capacity = 0;
}

// 数据入栈
void STPush(ST *st, STDataType x)
{
    // 确保有栈的存在
    assert(st);
    // 向top位置增加数据，并使top向后移动
    // 需要判断栈的容量大小
    if (st->top == st->capacity)
    {
        // 如果栈的空间为0，则开辟四个空间，如果栈容量不为0，则扩容原来容量的2倍
        int newCapacity = st->capacity == 0 ? 4 : st->capacity * 2;
        STDataType *tmp = (STDataType *)realloc(st->data, sizeof(STDataType) * newCapacity);
        assert(tmp);
        st->data = tmp;
        // 注意更新容量大小
        st->capacity = newCapacity;
    }

    // 数据压栈并改变top
    st->data[st->top++] = x;
}
// 数据出栈
void STPop(ST *st)
{
    // 确保有栈的存在
    assert(st);
    // 确保栈不会越界
    assert(!STEmpty(st));

    // 直接移动top指针，“看不见即删除”
    st->top--;
}
// 判断栈是否为空
bool STEmpty(ST *st)
{
    // 确保有栈的存在
    assert(st);
    // 栈为空返回真，栈不为空返回假
    return st->top == 0; // 判断表达式返回值只有1和0，如果为真返回1(true)，如果为假返回0(false)
}
// 获取栈顶元素
STDataType STTop(ST *st)
{
    // 确保栈存在
    assert(st);
    // 确保栈不为空
    assert(!STEmpty(st));
    // top为栈内数据的下一个位置，要获取当前位置的元素需要-1操作
    return st->data[st->top - 1];
}

// 获取栈内数据个数
int STSize(ST *st)
{
    assert(st);
    return st->top;
}

typedef struct
{
    ST pushST;
    ST popST;
} MyQueue;

MyQueue *myQueueCreate()
{
    // 初始化栈
    MyQueue *Queue = (MyQueue *)malloc(sizeof(MyQueue));
    STInit(&(Queue->pushST));
    STInit(&(Queue->popST));

    return Queue;
}

void myQueuePush(MyQueue *obj, int x)
{
    assert(obj);

    // 向pushSt栈中插入数据
    STPush(&(obj->pushST), x);
}

int myQueuePop(MyQueue *obj)
{
    assert(obj);
    // 复用myQueuePeek函数
    int data = myQueuePeek(obj);
    STPop(&(obj->popST));
    return data;
}

int myQueuePeek(MyQueue *obj)
{
    assert(obj);
    int data = 0;
    // 获取队列的头元素相当于栈的顶部元素
    // 如果popST不为空先执行popST
    if (!STEmpty(&(obj->popST)))
    {
        data = STTop(&(obj->popST));
        return data;
    }
    //  如果pushST中有数据并且popST为空，将数据移到popST中
    while (!STEmpty(&(obj->pushST)))
    {
        STPush(&(obj->popST), STTop(&(obj->pushST)));
        STPop(&(obj->pushST));
    }

    // 从popST中出数据
    data = STTop(&(obj->popST));
    return data;
}

bool myQueueEmpty(MyQueue *obj)
{
    assert(obj);
    return STEmpty(&(obj->pushST)) && STEmpty(&(obj->popST));
}

void myQueueFree(MyQueue *obj)
{
    assert(obj);
    STDestroy(&(obj->pushST));
    STDestroy(&(obj->popST));

    free(obj);
}

/**
 * Your MyQueue struct will be instantiated and called as such:
 * MyQueue* obj = myQueueCreate();
 * myQueuePush(obj, x);

 * int param_2 = myQueuePop(obj);

 * int param_3 = myQueuePeek(obj);

 * bool param_4 = myQueueEmpty(obj);

 * myQueueFree(obj);
*/
// @lc code=end

设计循环队列

题目链接：622. 设计循环队列 - 力扣（LeetCode）

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。
循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。
你的实现应该支持如下操作：
MyCircularQueue(k): 构造器，设置队列长度为 k 。
Front: 从队首获取元素。如果队列为空，返回 -1 。
Rear: 获取队尾元素。如果队列为空，返回 -1 。
enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
isEmpty(): 检查循环队列是否为空。
isFull(): 检查循环队列是否已满。

思路解析：

设计一个循环队列时需要考虑如何区分什么时候代表队列为满和队列为空，因为本题可以用数组来实现，故可以考虑当最后一个数据的位置的下一个位置为第一个元素所在的位置即为队列满状态，同样，可以定义一个记录有效数据的变量，当有效数据值为0时说明循环队列为空（注意不要使用该变量判断是否未满，因为数据在存储到数组中的最后一个有效位置时，还可以因为是循环回到数组的第一个有效位置开始继续存），下面是本题的每一个函数的基本思路：

  1. 循环队列的结构体设计

在循环队列中，需要有一个队列存在，故需要一个指向数组的指针data，另外需要一个数据的位置的下一个位置，故需要一个变量rear记录该位置，而因为需要获取队头数据，故需要一个变量front记录该位置（切忌认为数组的第一个数据即为队头数据），再者需要一个变量记录当前队列中的有效数据个数size，最后因为题目并未固定循环队列的大小，故需要一个变量k来确定数组在开辟时的大小

  1. 循环队列的初始化

在循环队列的初始化函数MyCircularQueue *myCircularQueueCreate(int k)中，函数参数为循环队列的大小，所以初始化过程中不可遗忘将该k给结构中的k，另外在初始化过程中，开辟的数组大小为k+1，但是数组的最后一个有效位置（即第k个位置）在队头指针front为数组的第一个元素的位置时不存储数据，其作用是在判断数组的下一个数据的位置时不会是因为循环回到了front的位置从而使rear == front

因为数组本身的物理结构是不可循环的（即数组下标不会在下一次访问越界时直接回到开头位置，需要人为控制），所以本题的主要思路是通过模运算来代替数组的下标，而因为当前数组的有效大小为k+1，此时数组最后一个有效数据下一个位置的下标为k（也即当前的rear位置），那么构成循环队列就是让rear指针指向的下一个有效数据位置为数组第一个元素的位置，那么因为数组实际开辟了6个空间，最后一个位置的下标为5，则有规律：小于6的数值取6的模可以得到原来被除数（即余数），大于等于6的数值取6的模可以得到被除数大于6的部分（即余数），此时直接用rear当做被除数，而k+1为除数来使下标构成循环，从而达到循环队列的目的，特殊情况例如，当rear越界为6时取6的模可以直接回到数组的第一个元素的位置，即rear % (k+1)

  1. 判断队列为空和判断队列为满

队列为空说明size == 0（或者front == rear时（注意这个判断用在开辟的空间为k+1时））； 队列为满说明front == (rear + 1) % (k + 1)，即当前rear所在位置的下一个位置

  1. 数据入队和数据出队

数据入队时，首先需要判断是否队列为满，如果队列为满直接返回false，不为满时向rear%(k+1)的位置添加数据，同时更新rear = (rear + 1) % (k + 1)和size；数据出队时，需要判断队列是否为空，如果队列为空则直接放回false，不为空才可以删除数据，队列删除数据时会改变头的位置，所以需要更新front，即front = (front + 1) % (k + 1)，同时需要更新size

  1. 获取队列头数据和获取队列尾数据

如果队列不为空，则队列头数据即为front所在的位置的数据，否则无数据返回-1；如果队列不为空，则队列尾数据为rear所在位置的前一个位置的数据，但是注意rear为有效数据的下一个位置，所以需要获取rear的上一个位置的下标，参考取模思路，因为数组的最后一个元素下标为k，而模为k + 1，此时被除数取k + 1的模可以得到0~k值，因为rear % (k + 1)可以取到的范围已经是0 ~ k，所以此时需要加最大模值使被除数增大才可以使模从0开始，而最大增加数为k，所以此时取(rear + k) % (k + 1)即可返回到rear上一个元素的位置

  1. 循环队列空间释放

释放空间需要先释放数组的空间，再释放循环队列结构的空间

参考答案：

/*
 * @lc app=leetcode.cn id=622 lang=c
 *
 * [622] 设计循环队列
 */

// @lc code=start

// 数组实现
// 数组实现
typedef struct
{
    int *data; // 存储队列数据
    int k;     // 队列大小
    int size;  // 有效数据个数
    int front; // 队列头
    int rear;  // 队列尾
} MyCircularQueue;

MyCircularQueue *myCircularQueueCreate(int k)
{
    MyCircularQueue *Queue = (MyCircularQueue *)malloc(sizeof(MyCircularQueue));
    Queue->data = (int *)malloc(sizeof(int) * (k + 1));
    Queue->front = Queue->rear = 0;
    Queue->size = 0;
    Queue->k = k;

    return Queue;
}

bool myCircularQueueIsEmpty(MyCircularQueue *obj)
{
    assert(obj);
    if (obj->size == 0)
    {
        return true;
    }
    else
    {
        return false;
    }
}

bool myCircularQueueIsFull(MyCircularQueue *obj)
{
    assert(obj);
    // 当rear的下一个为front时为队列满
    if (obj->front == (obj->rear + 1) % (obj->k + 1))
    {
        return true;
    }
    else
    {
        return false;
    }
}

bool myCircularQueueEnQueue(MyCircularQueue *obj, int value)
{
    assert(obj);
    if (!myCircularQueueIsFull(obj))
    {
        // 队列未满时插入数据
        obj->data[obj->rear % (obj->k + 1)] = value;
        obj->rear = (obj->rear + 1) % (obj->k + 1);
        obj->size++;
        return true;
    }
    else
    {
        return false;
    }
}

bool myCircularQueueDeQueue(MyCircularQueue *obj)
{
    assert(obj);
    if (!myCircularQueueIsEmpty(obj))
    {
        // 队列不为空时删除数据
        obj->front = (obj->front + 1) % (obj->k + 1);
        obj->size--;
        return true;
    }
    else
    {
        return false;
    }
}

int myCircularQueueFront(MyCircularQueue *obj)
{
    assert(obj);
    if (!myCircularQueueIsEmpty(obj))
    {
        return obj->data[obj->front % (obj->k + 1)];
    }
    else
    {
        return -1;
    }
}

int myCircularQueueRear(MyCircularQueue *obj)
{
    assert(obj);
    if (!myCircularQueueIsEmpty(obj))
    {
        return obj->data[(obj->rear + obj->k) % (obj->k + 1)];
    }
    else
    {
        return -1;
    }
}

void myCircularQueueFree(MyCircularQueue *obj)
{
    assert(obj);
    free(obj->data);
    free(obj);
}

/**
 * Your MyCircularQueue struct will be instantiated and called as such:
 * MyCircularQueue* obj = myCircularQueueCreate(k);
 * bool param_1 = myCircularQueueEnQueue(obj, value);

 * bool param_2 = myCircularQueueDeQueue(obj);

 * int param_3 = myCircularQueueFront(obj);

 * int param_4 = myCircularQueueRear(obj);

 * bool param_5 = myCircularQueueIsEmpty(obj);

 * bool param_6 = myCircularQueueIsFull(obj);

 * myCircularQueueFree(obj);
*/
// @lc code=end
怡晗★
关注
  • 21
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C语言-数据结构-栈队列实现
03-10
C语言-数据结构-栈队列实现
算法：C语言实现++第1-4部分++基础知识、数据结构、排序及搜索
04-21
《算法:C语言实现(第1-4部分)基础知识、数据结构、排序及搜索(原书第3版)》细腻讲解计算机算法的C语言实现。全书分为四部分，共16章。包括基本算法分析原理，基本数据结构、抽象数据结构、递归和树等数据结构知识，...
循环队列的实现（C语言）
多多想的博客
10-17 190
/数组，存储MaxSize-1个元素//队列头，队列尾}SqQueue;
【C语言】队列
就爱摆烂
10-03 1587
今天我们来介绍一种新的数据结构，队列。 目录队列的概念即结构队列的实现栈与队列练习题 队列的概念即结构 队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表。 队列具有先进先出FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾 出队列：进行删除操作的一端称为队头 队列的实现 队列与栈类似。也可以选择数组或者链表来实现。 但是使用链表结构的话更优一些，因为使用数组的结构，出队列在数组的头部，效率低于链表。 栈与队列练习题 ...
C语言实现基础数据结构——栈
小何代码咖啡馆
02-22 934
在初始化过程中注意top的初始值设置为0代表栈内数据的下一个位置，因为初始化栈代表栈内没有元素，如果用0代表栈内数据的当前位置，那么需要考虑该元素从何而来，既然没有数据，说明当前栈顶指针指向没有数据的位置，而数组下标为0代表第一个元素的位置，没有元素就不可能有第一个元素的位置，所以此时下标为0代表下一个元素的位置，此时说明栈内没有元素，但是准备在下一个位置（第一个元素）的位置添加数据。注意在栈中数据出栈的顺序不一定和入栈的顺序相同，当数据入栈后又出栈不影响下一个数据的入栈顺序。出栈：栈的删除操作叫做出栈。
C语言小知识——循环队列
lijianyi0219的博客
11-05 1598
文章目录前言一、循环队列的直观印象二、“双指针+数组”实现循环队列1.初始化2.入队3.出队4.队列长度三、队空与队满的判断1.队空判断2.队满判断总结 前言 在算法中，队列是个常用的数据类型，具有先进先出的存储特点。 在python中我们直接调用 collections.deque() 就可以构建一个队列，那么在C语言中，该如何简单地实现一个队列呢？ 一、循环队列的直观印象 为了节省内存空间，C中的队列要用循环队列实现，它可以循环使用位置存放数据。以此实现新入队的数据，直接覆盖前面已出队的无用数据。 而
【数据结构】队列的基本操作（C语言版）
上上谦. 的博客
04-03 6299
文章目录前言前情回顾 前言 在学过 “栈” 这个数据结构之后，本篇博客将继续介绍另一个常见的数据结构 ——— “队列”。本篇还将继续带来几道OJ题对栈和队列进行巩固。 前情回顾 栈的基本操作 + OJ练习 （C语言版） ...
数据结构之实现队列
Ly的博客
11-17 704
数据结构之队列的实现
二叉树链式结构-c语言实现
m0_46343224的博客
11-29 1006
绝对的高质量，带你秒解多项递归（二叉树）
C语言的实现的程序算法,算法：C语言实现（Algorithms In C）的学习
weixin_35476698的博客
05-20 435
这是chapter 1的Introduce部分原文：Readers of thisbook are expected to have at least a year's experience programming in high andlow-level languages. Also, some exposure to elementary algorithms on simpledata s...
数据结构 - 队列 实现与常见题型（C语言）
qq_61386381的博客
05-21 674
目录 前言： 队列的概念及结构 队列的实现 队列的定义 接口函数 实现接口函数 完整代码 Queue.h Queue.c 栈与队列的OJ练习 T1、用队列实现栈 T2、用栈实现队列 T3、设计循环队列 栈和队列的用途 前言： 队列的概念及结构 队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出 FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾 ............
算法：C语言实现
11-21
《算法:C语言实现(第1-4部分)基础知识、数据结构、排序及搜索(原书第3版)》细腻讲解计算机算法的C语言实现。全书分为四部分，共16章。包括基本算法分析原理，基本数据结构、抽象数据结构、递归和树等数据结构知识，...
算法c语言实现（英文版）part1-4
10-03
算法:C语言实现(第1-4部分)基础知识、数据结构、排序及搜索(原书第3版)》细腻讲解计算机算法的C语言实现。全书分为四部分，共16章。包括基本算法分析原理，基本数据结构、抽象数据结构、递归和树等数据结构知识，...
算法：算法C语言实现 第1-4部分 基础知识、数据结构、排序及搜索
05-25
算法：C语言实现 （第1-4部分)基础知识、数据结构、排序及搜索（原书第3版） 本书是Sedgewick彻底修订和重写的C算法系列的第一本。全书分为四部分，共16章。第一部分“基础知识”（第1—2章）介绍基本算法分析原理。...
AtCoder Beginner Contest 354 C - AtCoder Magics
2302_79545206的博客
05-19 765
因此我们对所有的卡片进行按照cost从小到大排序，v表示前i-1张卡片中最强的力量，如果第i张卡片力量大于等于v，说明这种卡片可以保留。反之，如果第i张卡片比i弱，又因为它还贵,那么我们就不要这张卡片了。首先，要明白这道题要我们做什么，就是丢弃这些卡片，然后输出剩余卡片的编号，那么什么样的卡片要舍弃呢？如果这个卡片它又贵还又弱，那么我们就不要它。自己加一些感悟，用朴素的语言来解释这道题目。首先声明本篇博客代码取自。
从需求角度介绍PasteSpider(K8S平替部署工具适合于任何开发语言)
05-14 1702
Kubernetes的强大毋庸置疑，但是你有问自己这么个大杀器真的适合你么？这里推荐一款更加小巧的容器部署工具，集报表，发布，环境，通知于一身的PasteSpider! 支持git/svn发布，支持平滑升级，支持环境隔离，支持用户隔离，支持运行变量设定等，关键易上手！
嵌入式0基础开始学习 Ⅱ 数据结构（1）数据结构
最新发布
qq_63137715的博客
05-23 136
在计算机科学中是指所有能入到计算机中并被计算机程序处理的符号的总称。是性质相同的数据元素的集合，是数据的子集。结构是数据元素之间关系的不同性质成为结构。根据数据元素之间的关系的不同性质，通常是。组成，数据项是数据不可分割的最小单位。以熟知各个数据结构方便以后使用！因此又称为数据的逻辑结构。是对客观事物的符号表示。一个数据元素可以由若干个。数据结构是一个二元组。是数据元素的有限集合，数据元素之间的关系集合。
0基础学习c语言算法
10-10
学习C语言算法的前提是对C语言有一定的基础。如果你从零开始学习C语言，建议先学习C语言基础语法，再开始学习算法。 以下是一些建议： 1. 学习基础语法：了解C语言的基本语法，包括变量、数据类型、运算符、表达式、控制语句、函数、数组、指针等。 2. 学习算法：掌握一些基本的算法和数据结构，例如：排序算法、查找算法、链表、栈、队列等。可以通过参考书籍或者在线教程进行学习。 3. 练习编程：通过编写代码来巩固所学知识。可以从简单的例子开始，逐步提高难度。 4. 参考资料：可以参考一些经典的C语言书籍，例如《C程序设计语言》、《算法（第4版）》、《数据结构与算法分析》等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

怡晗★

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值