AI 助理
文档备案控制台
开发者社区 人工智能 文章 正文

【数据结构与算法】用队列实现栈&&用栈实现队列&&设计循环队列

2023-02-08 149
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【数据结构与算法】用队列实现栈&&用栈实现队列&&设计循环队列

👉用队列实现栈👈


请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。


实现 MyStack 类：

void push(int x) 将元素 x 压入栈顶。

int pop() 移除并返回栈顶元素。

int top() 返回栈顶元素。

boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。


注意：


你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty

这些操作。

你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 ,只要是标准的队列操作即可。


示例：


输入：

["MyStack", "push", "push", "top", "pop", "empty"]

[[], [1], [2],[], [], []]

输出：

[null, null, null, 2, 2, false]


解释：

MyStack myStack = new MyStack();

myStack.push(1);

myStack.push(2);

myStack.top(); // 返回 2

myStack.pop(); // 返回 2

myStack.empty(); // 返回False



提示：


1 <= x <= 9

最多调用100 次 push、pop、top 和 empty

每次调用 pop 和 top 都保证栈不为空


进阶：你能否仅用一个队列来实现栈。


用两个队列实现栈


因为队列是先进先出的结构，而栈是后进先出的结构，那我们用两个队列实现一个栈呢？其实可以这样子实现：当入数据的时候，往不为空的队列入，保持另一个队列为空；当出数据的时候，依次出队头的数据，转移到另一个队列中保存，只剩一个数据的时候，pop 掉。如下图所示：

468adc2f29af4c1f9d606584aed72e70.png


将这篇博客实现的队列拷贝过来，然后将要求的函数接口就行了。具体代码见下方：


typedef int QDataType;
typedef struct QueueNode
{
  QDataType data;
  struct QueueNode* next;
}QNode;
typedef struct Queue
{
  QNode* head; // 头指针
  QNode* tail; // 尾指针
  int size;    // 节点的个数
}Queue;
void QueueInit(Queue* pq);
void QueueDestroy(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
bool QueueEmpty(Queue* pq);
int QueueSize(Queue* pq);
void QueueInit(Queue* pq)
{
  assert(pq);
  pq->head = pq->tail = NULL;
  pq->size = 0;
}
void QueueDestroy(Queue* pq)
{
  assert(pq);
  QNode* cur = pq->head;
  while (cur)
  {
    QNode* del = cur;
    cur = cur->next;
    free(del);
  }
  pq->head = pq->tail = NULL;
}
void QueuePush(Queue* pq, QDataType x)
{
  assert(pq);
  QNode* newnode = (QNode*)malloc(sizeof(QNode));
  if (newnode == NULL)
  {
    perror("malloc fail");
    exit(-1);
  }
  else
  {
    newnode->data = x;
    newnode->next = NULL;
  }
  // 队列中没有节点
  if (pq->tail == NULL)
  {
    pq->head = pq->tail = newnode;
  }
  else
  {
    pq->tail->next = newnode;
    pq->tail = newnode;
  }
  pq->size++;
}
void QueuePop(Queue* pq)
{
  assert(pq);
  assert(!QueueEmpty(pq));
  // 队列中只有一个节点
  if (pq->head->next == NULL)
  {
    free(pq->head);
    pq->head = pq->tail = NULL;
  }
  else
  {
    QNode* del = pq->head;
    pq->head = pq->head->next;
    free(del);
    //del = NULL;
  }
  pq->size--;
}
QDataType QueueFront(Queue* pq)
{
  assert(pq);
  assert(!QueueEmpty(pq));
  return pq->head->data;
}
QDataType QueueBack(Queue* pq)
{
  assert(pq);
  assert(!QueueEmpty(pq));
  return pq->tail->data;
}
bool QueueEmpty(Queue* pq)
{
  assert(pq);
  return pq->size == 0;
  //return pq->head == NULL && pq->tail == NULL;
}
int QueueSize(Queue* pq)
{
  assert(pq);
  return pq->size;
}
//核心思路：
//1.入数据，往不为空的队列入，保持另一个队列为空
//2.出数据的时候，依次出队头的数据，转移到另一个队列中保存
//只剩一个数据时，pop掉
//不能改变队列的结构，只能调用提供的函数接口
typedef struct 
{
    Queue q1;
    Queue q2;
} MyStack;
MyStack* myStackCreate() 
{
    // 注意局部变量，出了作用域会销毁
    MyStack* st = (MyStack*)malloc(sizeof(MyStack));
    //初始化队列
    QueueInit(&st->q1);
    QueueInit(&st->q2);
    return st;
}
void myStackPush(MyStack* obj, int x) 
{
    // 往不为空的队列中入数据
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1, x);
    }
    else
    {
        QueuePush(&obj->q2, x);
    }
}
int myStackPop(MyStack* obj) 
{
    // 找出谁是空队列
    Queue* empty = &obj->q1;
    Queue* nonEmpty = &obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        empty = &obj->q2;
        nonEmpty = &obj->q1;
    }
    // 非空队列前N-1个数据导入空队列，剩下的一个数据就是栈顶元素
    while(QueueSize(nonEmpty) > 1)
    {
        QueuePush(empty, QueueFront(nonEmpty));
        QueuePop(nonEmpty);
    }
    int top = QueueFront(nonEmpty);
    QueuePop(nonEmpty);
    return top;
}
int myStackTop(MyStack* obj) 
{
    if(!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}
bool myStackEmpty(MyStack* obj) 
{
    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}
void myStackFree(MyStack* obj) 
{
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
}


4fcedf69f3504090859c0a9371dd9a1d.png


用一个栈实现队列


用一个栈如何实现队列呢？其实也很简单，当一个数据入队时，先将该数据入队，然后再将在该数据前面的数据依次 pop 掉，然后又依次入队，就能实现后进先出的栈结构了。如下图所示：

c8d6da9e6bb449ddb3aea50fe8a38a81.png

typedef int QDataType;
typedef struct QueueNode
{
  QDataType data;
  struct QueueNode* next;
}QNode;
typedef struct Queue
{
  QNode* head; // 头指针
  QNode* tail; // 尾指针
  int size;    // 节点的个数
}Queue;
void QueueInit(Queue* pq);
void QueueDestroy(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
bool QueueEmpty(Queue* pq);
int QueueSize(Queue* pq);
void QueueInit(Queue* pq)
{
  assert(pq);
  pq->head = pq->tail = NULL;
  pq->size = 0;
}
void QueueDestroy(Queue* pq)
{
  assert(pq);
  QNode* cur = pq->head;
  while (cur)
  {
    QNode* del = cur;
    cur = cur->next;
    free(del);
  }
  pq->head = pq->tail = NULL;
}
void QueuePush(Queue* pq, QDataType x)
{
  assert(pq);
  QNode* newnode = (QNode*)malloc(sizeof(QNode));
  if (newnode == NULL)
  {
    perror("malloc fail");
    exit(-1);
  }
  else
  {
    newnode->data = x;
    newnode->next = NULL;
  }
  // 队列中没有节点
  if (pq->tail == NULL)
  {
    pq->head = pq->tail = newnode;
  }
  else
  {
    pq->tail->next = newnode;
    pq->tail = newnode;
  }
  pq->size++;
}
void QueuePop(Queue* pq)
{
  assert(pq);
  assert(!QueueEmpty(pq));
  // 队列中只有一个节点
  if (pq->head->next == NULL)
  {
    free(pq->head);
    pq->head = pq->tail = NULL;
  }
  else
  {
    QNode* del = pq->head;
    pq->head = pq->head->next;
    free(del);
    //del = NULL;
  }
  pq->size--;
}
QDataType QueueFront(Queue* pq)
{
  assert(pq);
  assert(!QueueEmpty(pq));
  return pq->head->data;
}
QDataType QueueBack(Queue* pq)
{
  assert(pq);
  assert(!QueueEmpty(pq));
  return pq->tail->data;
}
bool QueueEmpty(Queue* pq)
{
  assert(pq);
  return pq->size == 0;
  //return pq->head == NULL && pq->tail == NULL;
}
int QueueSize(Queue* pq)
{
  assert(pq);
  return pq->size;
}
typedef struct 
{
    Queue q;
} MyStack;
MyStack* myStackCreate() 
{
    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&obj->q);
    return obj;
}
void myStackPush(MyStack* obj, int x) 
{
    // 数据先入队
    QueuePush(&obj->q, x);
    // 前面的数据依次出队，再依次入队
    int i = 0;
    while(i < QueueSize(&obj->q) - 1)
    {
        int front = QueueFront(&obj->q);
        QueuePop(&obj->q);
        QueuePush(&obj->q, front);
        i++;
    }
}
int myStackPop(MyStack* obj) 
{
    int top = QueueFront(&obj->q);
    QueuePop(&obj->q);
    return top;
}
int myStackTop(MyStack* obj) 
{
    int top = QueueFront(&obj->q);
    return top;
}
bool myStackEmpty(MyStack* obj) 
{
    return QueueEmpty(&obj->q);
}
void myStackFree(MyStack* obj) 
{
    QueueDestroy(&obj->q);
    free(obj);
}


2fe216333d9043a9ac9a2ef39dd7ec53.png



👉用栈实现队列👈


请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（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（双端队列）来模拟一个栈，只要是标准的栈操作即可。



示例 1：


输入：

["MyQueue", "push", "push", "peek", "pop", "empty"]

[[], [1], [2],[], [], []]

输出：

[null, null, null, 1, 1, false]



解释：

MyQueue myQueue = new MyQueue();

myQueue.push(1); // queue is: [1]

myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)

myQueue.peek(); // return 1

myQueue.pop(); // return 1, queue is [2]

myQueue.empty(); // return false



提示：


1 <= x <= 9

最多调用 100 次 push、pop、peek 和 empty

假设所有操作都是有效的（例如，一个空的队列不会调用 pop 或者 peek 操作）


用两个栈实现队列的这道题和用两个队列实现栈的思路差不多。先在队列中定义两个栈，分别是入数据的栈pushST和出数据的栈popST。当入数据的时候，直接向栈pushST入数据。当出数据时，需要考虑两种情况：如果栈popST中没有数据，就将pushST中的数据导过去，再将栈pushST栈顶的数据 pop 掉；如果popST中有数据，直接 pop 掉栈顶的数据就行了。

c76d1f3fe7c64d589dc7afdb07da1c4a.png

typedef int STDataType;
typedef struct Stack
{
  STDataType* a;
  int top;
  int capacity;
}ST;
void StackInit(ST* ps);
void StackDestroy(ST* ps);
void StackPush(ST* ps, STDataType x);
void StackPop(ST* ps);
STDataType StackTop(ST* ps);
bool StackEmpty(ST* ps);
int StackSize(ST* ps);
void StackInit(ST* ps)
{
  assert(ps);
  ps->a = NULL;
  ps->capacity = ps->top = 0;
}
void StackDestroy(ST* ps)
{
  assert(ps);
  free(ps->a);
  ps->a = NULL;
  ps->capacity = ps->top = 0;
}
void StackPush(ST* ps, STDataType x)
{
  assert(ps);
  if (ps->capacity == ps->top)
  {
    int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
    STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
    if (tmp == NULL)
    {
      perror("relloc fail");
      exit(-1);
    }
    ps->a = tmp;
    ps->capacity = newcapacity;
  }
  ps->a[ps->top] = x;
  ps->top++;
}
void StackPop(ST* ps)
{
  assert(ps);
  assert(!StackEmpty(ps));
  ps->top--;
}
STDataType StackTop(ST* ps)
{
  assert(ps);
  assert(!StackEmpty(ps));
  return ps->a[ps->top - 1];
}
bool StackEmpty(ST* ps)
{
  assert(ps);
  return ps->top == 0;
}
int StackSize(ST* ps)
{
  assert(ps);
  return ps->top;
}
//匿名结构体
typedef struct 
{
    ST pushST;
    ST popST;
} MyQueue;
MyQueue* myQueueCreate() 
{
    MyQueue* q = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&q->pushST);
    StackInit(&q->popST);
    return q;
}
void myQueuePush(MyQueue* obj, int x) 
{
    StackPush(&obj->pushST, x);
}
int myQueuePop(MyQueue* obj) 
{
    //如果popST中没有数据，将pushST中的数据导过去
    //popST中的数据就符号先进先出的顺序了
    //如果popST中有数据，那么就直接pop popST中的数据
    if(StackEmpty(&obj->popST))
    {
        while(!StackEmpty(&obj->pushST))
        {
            StackPush(&obj->popST, StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    int front = StackTop(&obj->popST);
    StackPop(&obj->popST);
    return front;
}
int myQueuePeek(MyQueue* obj) 
{
    if(StackEmpty(&obj->popST))
    {
        while(!StackEmpty(&obj->pushST))
        {
            int top = StackTop(&obj->pushST);
            StackPop(&obj->pushST);
            StackPush(&obj->popST, top);
        }
    }
    return StackTop(&obj->popST);
}
bool myQueueEmpty(MyQueue* obj) 
{
    return StackEmpty(&obj->pushST) && StackEmpty(&obj->popST);
}
void myQueueFree(MyQueue* obj) 
{
    StackDestroy(&obj->pushST);
    StackDestroy(&obj->popST);
    free(obj);
}

6eccead9b9d94ff68506e300ea14b686.png


👉设计循环队列👈


设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。



你的实现应该支持如下操作：


MyCircularQueue(k): 构造器，设置队列长度为 k。

Front: 从队首获取元素。如果队列为空，返回 -1 。

Rear: 获取队尾元素。如果队列为空，返回 -1 。

enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。

deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。

isEmpty(): 检查循环队列是否为空。

isFull():检查循环队列是否已满。


示例：


MyCircularQueue circularQueue = newMyCircularQueue(3); // 设置长度为 3

circularQueue.enQueue(1); // 返回 true circularQueue.enQueue(2); // 返回true circularQueue.enQueue(3); // 返回 true circularQueue.enQueue(4); // 返回 false，队列已满

circularQueue.Rear(); // 返回 3

circularQueue.isFull(); // 返回 true circularQueue.deQueue(); // 返回true circularQueue.enQueue(4); // 返回 true circularQueue.Rear(); //返回 4



提示：


所有的值都在 0 至 1000 的范围内；

操作数将在 1 至 1000 的范围内；

请不要使用内置的队列库。


本道题需要实现的函数接口有：创建循环链表、判断循环链表是否为空、判断循环链表是否为满、数据入队、数据出队、返回队头数据、返回队尾数据以及销毁循环队列。循环队列可以采用数组或者链表的形式实现，但不管使用数组还是链表来实现循环队列，需要多开一个空间或者加个size记录循环队列中数据的个数，否则无法将队列为空和队列为满两种情况区分开。


//重点：循环队列，无论使用数组实现还是链表实现，都要
//多开一个空间，也就意味着，要是一个存k个数据的循环队列
//要开k+1个空间，否则无法实现判空和判满。
//数组实现：空：front == tail  满：(tail+1)%(k+1) == front
//链表实现：空：tail == tail 满：tail->next == front
typedef struct 
{
    int* a;
    int front;
    int back;
    int N;
} MyCircularQueue;
MyCircularQueue* myCircularQueueCreate(int k) 
{
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a = (int*)malloc(sizeof(int)*(k+1));
    obj->front = obj->back = 0;
    obj->N = k + 1;
    return obj;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
{
    return obj->front == obj->back;
}
bool myCircularQueueIsFull(MyCircularQueue* obj) 
{
    return (obj->back + 1) % obj->N == obj->front;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
    if(myCircularQueueIsFull(obj))
        return false;
    obj->a[obj->back] = value;
    obj->back++;
    // 当back在最后一个位置时，让back回到下标为0的位置
    obj->back %= obj->N;
    return true;
}
bool myCircularQueueDeQueue(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))
        return false;
    obj->front++;
    // 当front在最后一个位置时，让front回到下标为0的位置
    obj->front %= obj->N;
    return true;
}
int myCircularQueueFront(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))
        return -1;
    else
        return obj->a[obj->front];
}
int myCircularQueueRear(MyCircularQueue* obj) 
{
    // if(myCircularQueueIsEmpty(obj))
    //     return -1;
    // else if(obj->back == 0)
    //     return obj->a[obj->N -1];
    // else    
    //     return obj->a[obj->back - 1];
    if(myCircularQueueIsEmpty(obj))
        return -1;
    else
        return obj->a[(obj->back - 1 + obj->N) % obj->N];
}
void myCircularQueueFree(MyCircularQueue* obj) 
{
    free(obj->a);
    free(obj);
}

17fa72b4edcc4789a65cb9062d8ae1b0.png


自定义循环队列


a：整型指针，指向申请的空间

front：队头的位置

back：队尾位置的下一个位置

N：数组的长度 = k + 1


typedef struct 
{
    int* a;
    int front;
    int back;
    int N;
} MyCircularQueue;


创建循环链表


需要注意的是，要给队列循环申请 k + 1个空间，来区分队列是空还是满

MyCircularQueue* myCircularQueueCreate(int k) 
{
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a = (int*)malloc(sizeof(int)*(k+1));
    obj->front = obj->back = 0;
    obj->N = k + 1;
    return obj;
}


判断循环队列是否为空


当obj->front == obj->back时，循环队列为空

bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
{
    return obj->front == obj->back;
}


判断循环队列是否为满


当(obj->back + 1) % obj->N == obj->front时，循环队列为满

b4a516f303304d65badd530bb8825d34.png


bool myCircularQueueIsFull(MyCircularQueue* obj) 
{
    return (obj->back + 1) % obj->N == obj->front;
}


数据入队


1.当循环队列为满时，返回 false

2.当循环队列不为满时，数据入队obj->a[obj->back] = value, obj->back++

3.当back在最后一个位置时，让back回到下标为 0 的位置obj->back %= obj->N


bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
    if(myCircularQueueIsFull(obj))
        return false;
    obj->a[obj->back] = value;
    obj->back++;
    // 当back在最后一个位置时，让back回到下标为0的位置
    obj->back %= obj->N;
    return true;
}


数据出队


1.当循环队列为空时，返回 false

2.当循环队列不为空时，数据出队obj->front++

3.当front在最后一个位置时，让front回到下标为 0的位置obj->front %= obj->N


bool myCircularQueueDeQueue(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))
        return false;
    obj->front++;
    // 当front在最后一个位置时，让front回到下标为0的位置
    obj->front %= obj->N;
    return true;
}


返回队头数据


1.当循环队列为空时，返回 false

2.当循环队列不为空时，返回队头数据return obj->a[obj->front]


int myCircularQueueFront(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))
        return -1;
    else
        return obj->a[obj->front];
}


返回队尾数据


1.当循环队列为空时，返回 false

2.当循环队列不为空时，返回队尾数据return obj->a[(obj->back - 1 + obj->N) % obj->N]

63b2b0bb49aa42b4befa15ed53a31719.png

int myCircularQueueRear(MyCircularQueue* obj) 
{
    // if(myCircularQueueIsEmpty(obj))
    //     return -1;
    // else if(obj->back == 0)
    //     return obj->a[obj->N -1];
    // else    
    //     return obj->a[obj->back - 1];
    if(myCircularQueueIsEmpty(obj))
        return -1;
    else
        return obj->a[(obj->back - 1 + obj->N) % obj->N];
}


销毁循环队列


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


👉一道小小的选择题👈


现有一循环队列，其队头为front，队尾为rear，循环队列长度为N,最多存储N-1个数据。其队内有效长度为（ ）

A.(rear - front + N) % N + 1

B.(rear - front + N) % N

C.(rear - front) % (N + 1)

D.(rear - front + N) % (N - 1)



答案：B

解析：有效长度一般是rear-front，但是循环队列中rear有可能小于front，减完之后可能是负数，所以需要+N，此时结果刚好是队列中有效元素个数，但如果rear大于front，减完之后就是有效元素个数了，再加N后有效长度会超过N，故需要%N。


👉总结👈


本篇博客主要讲解三道 OJ 题，主要考察的是大家对栈和队列性质的理解。以上就是本篇博客的全部内容了，如果大家觉得有收获的话，可以点个三连支持一下！谢谢大家啦！💖💝❣️


文章标签：
机器学习/深度学习
算法
存储
关键词：
数据结构栈
数据结构队列
算法栈
算法队列
数据结构与算法队列
游客mpbbpgnnu5sxe
目录
相关文章
大数据文摘
|
11月前
|
前端开发 Java
java实现队列数据结构代码详解
本文详细解析了Java中队列数据结构的实现，包括队列的基本概念、应用场景及代码实现。队列是一种遵循“先进先出”原则的线性结构，支持在队尾插入和队头删除操作。文章介绍了顺序队列与链式队列，并重点分析了循环队列的实现方式以解决溢出问题。通过具体代码示例（如`enqueue`入队和`dequeue`出队），展示了队列的操作逻辑，帮助读者深入理解其工作机制。
大数据文摘
404 1
hahaha无
|
9月前
|
编译器 C语言 C++
栈区的非法访问导致的死循环(x64)
这段内容主要分析了一段C语言代码在VS2022中形成死循环的原因，涉及栈区内存布局和数组越界问题。代码中`arr[15]`越界访问，修改了变量`i`的值，导致`for`循环条件始终为真，形成死循环。原因是VS2022栈区从低地址到高地址分配内存，`arr`数组与`i`相邻，`arr[15]`恰好覆盖`i`的地址。而在VS2019中，栈区先分配高地址再分配低地址，因此相同代码表现不同。这说明编译器对栈区内存分配顺序的实现差异会导致程序行为不一致，需避免数组越界以确保代码健壮性。
hahaha无
192 0
栈区的非法访问导致的死循环(x64)
游客beejssedmb2sq
|
9月前
232.用栈实现队列，225. 用队列实现栈
在232题中，通过两个栈（`stIn`和`stOut`）模拟队列的先入先出（FIFO）行为。`push`操作将元素压入`stIn`，`pop`和`peek`操作则通过将`stIn`的元素转移到`stOut`来实现队列的顺序访问。 225题则是利用单个队列（`que`）模拟栈的后入先出（LIFO）特性。通过多次调整队列头部元素的位置，确保弹出顺序符合栈的要求。`top`操作直接返回队列尾部元素，`empty`判断队列是否为空。 两题均仅使用基础数据结构操作，展示了栈与队列之间的转换逻辑。
游客beejssedmb2sq
209 0
蓝易云
|
算法 调度 C++
STL——栈和队列和优先队列
通过以上对栈、队列和优先队列的详细解释和示例，希望能帮助读者更好地理解和应用这些重要的数据结构。
蓝易云
302 11
羑悻的小杀马特
|
DataX
☀☀☀☀☀☀☀有关栈和队列应用的oj题讲解☼☼☼☼☼☼☼
### 简介 本文介绍了三种数据结构的实现方法：用两个队列实现栈、用两个栈实现队列以及设计循环队列。具体思路如下： 1. **用两个队列实现栈**： - 插入元素时，选择非空队列进行插入。 - 移除栈顶元素时，将非空队列中的元素依次转移到另一个队列，直到只剩下一个元素，然后弹出该元素。 - 判空条件为两个队列均为空。 2. **用两个栈实现队列**： - 插入元素时，选择非空栈进行插入。 - 移除队首元素时，将非空栈中的元素依次转移到另一个栈，再将这些元素重新放回原栈以保持顺序。 - 判空条件为两个栈均为空。
羑悻的小杀马特
268 14
陌陌谣
|
缓存 监控 算法
内网监控管理软件：PHP 语言队列算法揭秘
在数字化办公环境中，内网监控管理软件对企业的稳定运行和信息安全至关重要。本文深入介绍PHP中的队列算法及其在内网监控软件中的应用，包括监控数据收集、任务调度和日志记录等场景，通过代码示例展示其实现方法。队列算法可提高性能、保证数据顺序并实现异步处理，为企业提供高效的安全保障。
陌陌谣
217 1
ephemerals__
|
C语言
【数据结构】栈和队列（c语言实现）（附源码）
本文介绍了栈和队列两种数据结构。栈是一种只能在一端进行插入和删除操作的线性表，遵循“先进后出”原则；队列则在一端插入、另一端删除，遵循“先进先出”原则。文章详细讲解了栈和队列的结构定义、方法声明及实现，并提供了完整的代码示例。栈和队列在实际应用中非常广泛，如二叉树的层序遍历和快速排序的非递归实现等。
ephemerals__
1151 10
那年春天
|
存储 算法
非递归实现后序遍历时，如何避免栈溢出？
后序遍历的递归实现和非递归实现各有优缺点，在实际应用中需要根据具体的问题需求、二叉树的特点以及性能和空间的限制等因素来选择合适的实现方式。
那年春天
361 59
RossyYan
|
存储 C语言 C++
【C++数据结构——栈与队列】顺序栈的基本运算（头歌实践教学平台习题）【合集】
本关任务：编写一个程序实现顺序栈的基本运算。开始你的任务吧，祝你成功！​ 相关知识 初始化栈 销毁栈 判断栈是否为空 进栈 出栈 取栈顶元素 1.初始化栈 概念：初始化栈是为栈的使用做准备，包括分配内存空间（如果是动态分配）和设置栈的初始状态。栈有顺序栈和链式栈两种常见形式。对于顺序栈，通常需要定义一个数组来存储栈元素，并设置一个变量来记录栈顶位置；对于链式栈，需要定义节点结构，包含数据域和指针域，同时初始化栈顶指针。 示例（顺序栈）： 以下是一个简单的顺序栈初始化示例，假设用C语言实现，栈中存储
RossyYan
692 77
RossyYan
|
存储 C++ 索引
【C++数据结构——栈与队列】环形队列的基本运算（头歌实践教学平台习题）【合集】
【数据结构——栈与队列】环形队列的基本运算（头歌实践教学平台习题）【合集】初始化队列、销毁队列、判断队列是否为空、进队列、出队列等。本关任务：编写一个程序实现环形队列的基本运算。(6)出队列序列:yzopq2*(5)依次进队列元素:opq2*(6)出队列序列:bcdef。(2)依次进队列元素:abc。(5)依次进队列元素:def。(2)依次进队列元素:xyz。开始你的任务吧，祝你成功！(4)出队一个元素a。(4)出队一个元素x。
RossyYan
495 13
【C++数据结构——栈与队列】环形队列的基本运算（头歌实践教学平台习题）【合集】

热门文章

最新文章

  • 1
    OpenJudge计算概论-扩号匹配问题【这个用到了栈的思想】
  • 2
    数据结构 | 使用Kotlin实现栈与队列
  • 3
    【数据结构入门精讲 | 第二篇】考研408、企业面试基础概念习题
  • 4
    归并排序【参考数据结构教材】
  • 5
    数据结构学习笔记——链表的相关知识（单链表带头结点和不带头结点的基本操作）（下）
  • 6
    shu_1016 栈
  • 7
    并发数据结构- 1.1.1 性能
  • 8
    运行时栈帧结构
  • 9
    careercup-栈与队列 3.3
  • 10
    解析 Java 数据结构：深入了解映射（Map）的特点与应用
  • 1
    当“爆款书”遇上大数据：出版业的老路，正在被算法改写
    476
  • 2
    当AI成为航天员的“大脑外设”：智能算法如何优化人类的长期太空旅行
    254
  • 3
    电脑监控管理中的 C# 哈希表进程资源索引算法
    259
  • 4
    HNSW算法实战：用分层图索引替换k-NN暴力搜索
    458
  • 5
    基于python智能推荐算法的全屋定制系统
    312
  • 6
    使用哈里斯角Harris和SIFT算法来实现局部特征匹配（Matlab代码实现）
    256
  • 7
    基于导向滤波的暗通道去雾算法在灰度与彩色图像可见度复原中的研究（Matlab代码实现）
    289
  • 8
    【水下图像增强融合算法】基于融合的水下图像与视频增强研究（Matlab代码实现）
    496
  • 9
    结合多种启发式解码方法的混合多目标进化算法，用于解决带工人约束的混合流水车间调度问题（Matlab代码实现）
    264
  • 10
    【基于TTNRBO优化DBN回归预测】基于瞬态三角牛顿-拉夫逊优化算法（TTNRBO）优化深度信念网络（DBN）数据回归预测研究（Matlab代码实现）
    234

    • 相关课程

    更多
  • 智能运维赛（复赛）：利用数据和算法，快速定位系统异常并进行根因分析
  • 智能创作赛（复赛）：相册应用中的视频故事生成算法介绍
  • 智能创作赛（初赛）：相册应用中的故事生成算法介绍
  • 相册服务中的故事生成算法介绍
  • Go语言核心编程 - 数据结构和算法
  • 神经网络概览及算法详解

    • 相关电子书

    更多
  • 数据+算法定义新世界
  • 袋鼠云基于实时计算的反黄牛算法
  • Alink：基于Apache Flink的算法平台
    • 下一篇
    ECS账号安全防护最佳实践