C++算法系列-栈与队列

简介: 笔记

在学完链表后,接下来我们就开始学习栈和队列了,因为栈与队列的实现是基于链表的(也可以是数组),所以要先学链表,然后紧接着学栈与队列。


一. 栈(链表实现)


1. 栈的简介

在生活中,我们会碰到这样一种情况,在往球桶里面放球的时候,最先放进去的球,只能在最后取出。

为了模拟上述的情况,于是就出现了栈这种数据结构。

一般栈可以就行如下操作

入栈push,往栈里面存放元素。

出栈pop,取出栈的顶部元素。

清空栈pop_all,将栈里面的全部元素都出栈。

判断栈是否为空。

返回栈的顶部元素,但不出栈。

2. 栈的实现

1.入栈

void push(int i)
  {
    Node* q = new Node;
    q->data = i;
    if (tail != NULL)
    {
      q->next = tail;
      tail = q;
    }
    else
    {
      tail = q;
      q->next = NULL;
    }
  }

2.出栈

bool pop()
  {
    if (tail != NULL)
    {
      Node*q = tail;
      tail = tail->next;
      delete q;
      return true;
    }
    else
      return false;
  }

判断栈是否为空

bool empty()
  {
  if (tail != NULL)
    return false;
  else
    return true;
  }


返回顶部元素

int top()
  {
  if (tail != NULL)
    return tail->data;
  else
    return 0;
  }


清空栈

void pop_all()
  {
  Node * p = tail, *q;
  while (p->next)
  {
    q = p->next;
    delete p;
    p = q;
  }
  delete p;
  tail = NULL;
  }


完整实现

#include<iostream>
using namespace std;
class Node
{
public:
  int data;
  Node *next;
};
class Stack {
private:
  Node  *tail;
public:
  Stack()
  {
  tail = NULL;
  }
  Stack(int i)
  {
  Node *q = new Node;
  q->data = i;
  tail = q;
  q->next = NULL;
  }
  ~Stack()
  {
  Node * p = tail, *q;
  while (p)
  {
    q = p->next;
    delete p;
    p = q;
  }
  delete p;
  }
  //入栈
  void push(int i)
  {
  Node* q = new Node;
  q->data = i;
  if (tail != NULL)
  {
    q->next = tail;
    tail = q;
  }
  else
  {
    tail = q;
    q->next = NULL;
  }
  }
  //出栈
  bool pop()
  {
  if (tail != NULL)
  {
    Node*q = tail;
    tail = tail->next;
    delete q;
    return true;
  }
  else
    return false;
  }
  //返回顶部元素
  int top()
  {
  if (tail != NULL)
    return tail->data;
  else
    return 0;
  }
  //判断栈是否为空
  bool empty()
  {
  if (tail != NULL)
    return false;
  else
    return true;
  }
  //清空栈
  void pop_all()
  {
  Node * p = tail, *q;
  while (p->next)
  {
    q = p->next;
    delete p;
    p = q;
  }
  delete p;
  tail = NULL;
  }
};


二. 队列


1. 队列简介

在日常中,我们又会遇到另外一种非常常见的情况,那就是排队。在排队的时候,最先来的,业务就可以就先处理完。

在这种情况下,我们就使用队列这种数据结构来模拟这种情况。

队列一般可以进行的操作。

clear清空队列

isEmpty判断队列是否为空

enqueue在队列尾部加入元素

dequeue取出队列的第一个元素

firstE返回队列的第一个元素,但不删除

2. 队列的实现

完整代码,基于库中的列表

#include<list>
template<class T>
class Queue {
private:
  list<T> lst;
public:
  Queue()
  {
  }
  void clear()
  {
  lst.clear();
  }
  bool isEmpty() const {
  return lst.empty();
  }
  T& front()
  {
  return lst.front();
  }
  T dequeue()
  {
  T e1 = lst.front();
  lst.pop_front();
  return e1;
  }
  void enqueue(const T& e1)
  {
  lst.push_back(e1);
  }
};



三. 课后习题


将栈S中的元素的顺序倒过来

1-a 使用两个额外的栈

int main()
{
  stack<int > q1;
  stack<int > q2;
  stack<int > q3;
  q1.push(1);
  q1.push(2);
  q1.push(3);
  q2.push(q1.top());
  q1.pop();
  q2.push(q1.top());
  q1.pop();
  q2.push(q1.top());
  q1.pop();
  q3.push(q2.top());
  q2.pop();
  q3.push(q2.top());
  q2.pop();
  q3.push(q2.top());
  q2.pop();
  q1.push(q3.top());
  q3.pop();
  q1.push(q3.top());
  q3.pop();
  q1.push(q3.top());
  q3.pop();
  while (!q1.empty())
  {
  cout << q1.top();
  q1.pop();
  }
  return 0;
}

1-b 使用额外的一个队列


int main()
{
  stack<int> q;
  list<int> m;
  q.push(1);
  q.push(2);
  q.push(3);
  while (!q.empty())
  {
  m.push_back(q.top());
  q.pop();
  }
  while (!m.empty())
  {
  q.push(m.front());
  m.pop_front();
  }
  while (!q.empty())
  {
  cout << q.top();
  q.pop();
  }
  return 0;
}


1-c 使用额外的一个栈和几个额外的非数组变量

int main()
{
  stack<int> q;
  stack<int> q2;
  q.push(1);
  q.push(2);
  q.push(3);
  while (!q.empty())
  {
  q2.push(q.top());
  q.pop();
  }
  q.swap(q2);
  while (!q.empty())
  {
  cout << q.top();
  q.pop();
  }
}

使用一个额外的栈和几个额外的非数组变量,将栈S中的元素按升序排列

int main()
{
  stack<int> q;
  stack<int> q2;
  int a=0, b=0,c = -10, min = 9999;
  q.push(2), q.push(5), q.push(1),q.push(4),q.push(7),q.push(10),q.push(8),q.push(3);
  for (int i = 0; i < 7; i++)
  {
  min = 999;
  while (!q.empty())
  {
    if (q.top() == c)
    break;
    if (q.top() < min)
    min = q.top();
    q2.push(q.top());
    q.pop();
  }
  c =min;
  q.push(min);
  while (!q2.empty())
  {
    if (q2.top() == min)
    {
    q2.pop();
    continue;
    }
    q.push(q2.top());
    q2.pop();
  }
  b = 0;
  }
  while (!q.empty())
  {
  cout << q.top()<<" ";
  q.pop();
  }
  return 0;
}

将栈S1中的元素转换到栈S2中,使S2中元素的顺序与S1中元素的顺序相同

3-a 使用一个额外的栈

int main()
{
  stack<int> S1;
  stack<int> S2;
  stack<int> q;
  S1.push(2), S1.push(3), S1.push(4), S1.push(5);
  while (!S1.empty())
  {
  q.push(S1.top());
  S1.pop();
  }
  while (!q.empty())
  {
  S2.push(q.top());
  q.pop();
  }
  while (!S2.empty())
  {
  cout << S2.top() << " ";
  S2.pop();
  }
  return 0;
}


3-b 不使用额外的栈,只使用几个额外的非数组变量


int main()
{
  stack<int> S1, S2;
  int a, b=0, c = 1, d;
  S1.push(1);
  S1.push(2);
  S1.push(3);
  S1.push(4);
  a = S1.size();
  while (a)
  {
  // 写出 i<S1.size() - 1 会出现错误
  for (int i = 0; i <a - c; i++)
  {
    S2.push(S1.top());
    S1.pop();
  }
  d = S1.top();
  S1.pop();
  for (int i = 0; i < 3-b; i++)
  {
    S1.push(S2.top());
    S2.pop();
  }
  S2.push(d);
  b++;
  a--;  
  }
  while (!S2.empty())
  {
  cout << S2.top() << " ";
  S2.pop();
  }
  return 0;
}

使用额外的非数组变量及下面的条件,将队列中的所有元素排序

5-a 两个额外的队列

int main()
{
  queue<int> q1 , q2, q3;
  q1.push(4), q1.push(1), q1.push(7), q1.push(10), q1.push(2), q1.push(6), q1.push(8);
  int min;
  int a = q1.size();
  for (int i = 0; i < a; i++)
  {
  min = 999;
  while (!q1.empty())
  {
    if (q1.front() < min)
    {
    min = q1.front();
    }
    q2.push(q1.front());
    q1.pop();
  }
  while (!q2.empty())
  {
    if (q2.front() == min)
    {
    q2.pop();
    continue;
    }
    q1.push(q2.front());
    q2.pop();
  } 
  q3.push(min);
  }
  while (!q3.empty())
  {
  cout << q3.front()<<" " ;
  q3.pop();
  }
  return 0;
}

以上就是栈和队列的大部分内容。

ps:以上知识学习于《C++数据结构与算法》Adam Drozdek 著, 徐丹,吴伟敏 译。

Thank for your reading !!!


公众号:FPGA之旅




目录
相关文章
|
2月前
|
缓存 算法 Java
JVM知识体系学习六:JVM垃圾是什么、GC常用垃圾清除算法、堆内存逻辑分区、栈上分配、对象何时进入老年代、有关老年代新生代的两个问题、常见的垃圾回收器、CMS
这篇文章详细介绍了Java虚拟机(JVM)中的垃圾回收机制,包括垃圾的定义、垃圾回收算法、堆内存的逻辑分区、对象的内存分配和回收过程,以及不同垃圾回收器的工作原理和参数设置。
79 4
JVM知识体系学习六:JVM垃圾是什么、GC常用垃圾清除算法、堆内存逻辑分区、栈上分配、对象何时进入老年代、有关老年代新生代的两个问题、常见的垃圾回收器、CMS
|
1月前
|
缓存 安全 C++
C++无锁队列:解锁多线程编程新境界
【10月更文挑战第27天】
49 7
|
1月前
|
消息中间件 存储 安全
|
2月前
|
算法 程序员 索引
数据结构与算法学习七:栈、数组模拟栈、单链表模拟栈、栈应用实例 实现 综合计算器
栈的基本概念、应用场景以及如何使用数组和单链表模拟栈,并展示了如何利用栈和中缀表达式实现一个综合计算器。
47 1
数据结构与算法学习七:栈、数组模拟栈、单链表模拟栈、栈应用实例 实现 综合计算器
|
1月前
|
算法 安全 NoSQL
2024重生之回溯数据结构与算法系列学习之栈和队列精题汇总(10)【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丢脸好嘛?】
数据结构王道第3章之IKUN和I原达人之数据结构与算法系列学习栈与队列精题详解、数据结构、C++、排序算法、java、动态规划你个小黑子;这都学不会;能不能不要给我家鸽鸽丢脸啊~除了会黑我家鸽鸽还会干嘛?!!!
|
27天前
|
存储 设计模式 C++
【C++】优先级队列(容器适配器)
本文介绍了C++ STL中的线性容器及其适配器,包括栈、队列和优先队列的设计与实现。详细解析了`deque`的特点和存储结构,以及如何利用`deque`实现栈、队列和优先队列。通过自定义命名空间和类模板,展示了如何模拟实现这些容器适配器,重点讲解了优先队列的内部机制,如堆的构建与维护方法。
32 0
|
2月前
|
算法
数据结构与算法二:栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式
这篇文章讲解了栈的基本概念及其应用,并详细介绍了中缀表达式转换为后缀表达式的算法和实现步骤。
64 3
|
2月前
|
存储 算法 C++
高精度算法(加、减、乘、除,使用c++实现)
高精度算法(加、减、乘、除,使用c++实现)
666 0
高精度算法(加、减、乘、除,使用c++实现)
|
2月前
|
存储 算法 定位技术
数据结构与算法学习二、稀疏数组与队列,数组模拟队列,模拟环形队列
这篇文章主要介绍了稀疏数组和队列的概念、应用实例以及如何使用数组模拟队列和环形队列的实现方法。
26 0
数据结构与算法学习二、稀疏数组与队列,数组模拟队列,模拟环形队列
|
2月前
|
算法 数据处理 C++
c++ STL划分算法;partition()、partition_copy()、stable_partition()、partition_point()详解
这些算法是C++ STL中处理和组织数据的强大工具,能够高效地实现复杂的数据处理逻辑。理解它们的差异和应用场景,将有助于编写更加高效和清晰的C++代码。
43 0
下一篇
DataWorks