数据结构与算法.栈队列

Posted 2021-07-18 qq_51102350

栈、队列

• 一，栈
• 二、队列

一，栈

定义：一种操作受限的线性结构

特点：
①栈中数据遵从’先进先出‘原则
②只能在栈顶对数据进行操作（出栈pop和入栈push）

基于数组的栈：顺序栈
基于链表的栈：链式栈

栈中的常用操作：

stack.getTop//返回栈顶的元素，但不删除该元素
stack.push//向栈中加入元素
stack.pop//弹出栈顶的元素，不返回该元素
stack.isEmpty//判断栈中是否为空
stack.isFull//判断栈中是否已满
stack.getSize//返回栈的大小

栈的实现：
一个简单的基于c++的储存int型数据的栈的实现：

#include <iostream>
#include <stack> //借助于<stack>stl库实现

using namespace std;

int main()
{
	stack<int> myStack;

	if (myStack.empty())
		cout << "myStack is empty" << endl;

	for (int i = 0; i < 10; i++)
		myStack.push(i);

	cout << myStack.top() << " " << myStack.size() << endl;

	myStack.pop();

	cout << myStack.top() << " " << myStack.size() << endl;
}

补充知识：

C++ 对模板（Template）支持得很好，STL 就是借助模板把常用的数据结构及其算法都实现了一遍，并且做到了数据结构和算法的分离。STL的代码从广义上讲分为三类：algorithm（算法）、container（容器）和iterator（迭代器），几乎所有的代码都采用了模板类和模版函数的方式，这相比于传统的由函数和类组成的库来说提供了更好的代码重用机会。在C++标准中，STL被组织为下面的13个头文件：

<algorithm >、<deque >、<functional>、<iterator>、
<vector>、<list>、<map>、<memory>、<numeric>、<queue>、
<set>、<stack>和<utility>

二、队列

定义：一种操作受限的线性表

特点：
先进先出
只允许在一端插入，在另一端删除

循环队列：
原理：

将队列从逻辑上造成一个环状，通过取余实现

实现：
（循环队列会浪费数组的一个储存空间）

#include <iostream>
using namespace std;

template <typename T>
class myQueue {
public:

    myQueue(int c = 0)
    {
        capacity = c;
        if (capacity != 0)
            queue = new T[capacity];
        else
            queue = nullptr;
        start = 0;
        end = 0;
    }

    ~myQueue()
    {
        delete[] queue;
    }

    bool isEmpty()
    {
        if (start == end)
            return true;
        else
            return false;
    }

    bool isFull()
    {
        if ((end+1)%capacity == start)
            return true;
        else
            return false;
    }


    template<typename T>
    bool enqueue(T t)
    {
        if (isFull())
            return false;
        else
        {
            queue[end] = t;
            end = (end + 1) % capacity;
            return true;
        }
    }

    bool dequeue()
    {
        if (isEmpty())
            return false;
        else
        {
            start = (start + 1) % capacity;
            return true;
        }
    }

    T getFront()
    {

        if (end == start)
        {
            exit(0);
        }
        return queue[start];
    }

    int getSize()
    {
        return (end - start + capacity) % capacity;
    }
    

private:
    int start;
    int end;
    int capacity;
    T* queue;
};

int main()
{
    myQueue<string> queue(6);
    queue.enqueue("one");
    queue.enqueue("two");
    queue.enqueue("three");
    queue.enqueue("four");
    queue.enqueue("five");

    if (queue.isFull())
        cout << "queue is full" << endl;

    cout << queue.getSize();

    while (!queue.isEmpty()) {
        cout << queue.getFront() << endl;
        queue.dequeue();
    }
    
    if (queue.isEmpty())
        cout << "queue is empty" << endl;
    return 0;
}