「队列」实现FIFO队列（先进先出队列|queue）的功能 / 手撕数据结构（C++）

Daking-

已于 2024-08-05 21:41:39 修改

阅读量502

点赞数 21

分类专栏：「队列」文章标签：数据结构 c++ java

于 2024-08-05 21:09:12 首次发布

本文链接：https://blog.csdn.net/dakingffo/article/details/140878051

版权

「队列」专栏收录该内容

1 篇文章 0 订阅

订阅专栏

概述

队列，是一种基本的数据结构，也是一种数据适配器。它在底层上以链表方法实现。

队列的显著特点是他的添加元素与删除元素操作：先加入的元素总是被先弹出。

一个队列应该应该是这样的：

          --------------QUEUE-------------
          ————     ————     ————     ————
pop() ←--  T1  ←--  T2  ←--  T3  ←--  T4  ←-- push()
          ————     ————     ————     ————     
          --------------------------------
         front()                     back()


                        *注意*
          -------------------------------→
         队列的内部是一张由front指向back的链表

Tn代表该元素被加入到队列的次序。

一个队列有以下四种基本行为：

front()表示对队列头元素的访问操作。如得到元素T1。

pop()表示对队列头元素的弹出操作。我们弹出T1

               ---------QUEUE---------
               ————     ————     ————
     pop() ←--  T2  ←--  T3  ←--  T4  ←-- push()
               ————     ————     ————     
               -----------------------
              front()           back()

现在T2成为队头元素。

back()表示对队列尾元素的访问操作。如当前会得到T4。

push()表示对队列尾部压入新元素。我们压入T5

          --------------QUEUE-------------
          ————     ————     ————     ————
pop() ←--  T2  ←--  T3  ←--  T4  ←--  T5  ←-- push()
          ————     ————     ————     ————     
          --------------------------------
         front()                     back()

现在T5成为尾元素。

接下来我们通过封装queue类,实现队列的一些基本功能。（Code和测试案例附后）

命名空间

C++有自己的std命名空间下的queue，为了进行区分，封装一个自己的动态数组命名空间custom_queue。

使用namespace关键字封装，使用时可以声明using namespace custom_queu;在作用域内声明，或custom_queue::局部声明。

namespace custom_queue{
    ...
}

//作用域内声明
using namespace custom_queue;

//局部声明
custom_queue::...

成员变量

template <typename T>是泛型，作为数据适配器，他的数据单位应该是任意一种类型，此时暂用T表示，至于T为何物将在实例化时以<>告知。

定义class类queue，封装三个成员变量：queue_node<T>* val_front; queue_node<T>* val_back; size_t val_size;

（size_t 是C/C++标准在stddef.h中定义的（这个头文件通常不需要#include），size_t 类型专门用于表示长度，它是无符号整数。）

我们还要额外定义嵌套类queue_node，它只能被queue类使用，这就实现了结构功能的封装。

queue_node<T>* val_front是队头处的指针。

queue_node<T>* val_back是队尾处的指针。

size_t val_size用于记录当前队列的长度。


template<typename T>
class queue {
private:
    template<typename T>
    class queue_node {
    private:
        ...
    };
	queue_node<T>* val_front;
	queue_node<T>* val_back;
	size_t val_size;
public:
    ...
}

定义class类queue_node，封装两个成员变量：T val; queue_node*next

声明友员类friend class queu（queue为模版类，模版友员类前加泛型声明），这使得queue可以操控queue_node的私有成员，将queue_node的构造函数和析构函数定为私有，这样就只用queue能管理queue_node了。

T val当前节点值。

queue_node*next指向下一个节点

另有构造函数接受一个T elem，创建新节点。

析构函数无须函数体，完全由trie类代管，略去不表。

禁用拷贝构造和重载等于号：默认拷贝构造和等于号进行，指针变量赋值，这存在极大问题（两指针争抢堆上的数据同一块数据），另有深层拷贝解决，略去不表。

template<typename T>
class queue_node {
private:
	template<typename T>
	friend class queue;
	T val;
	queue_node* next;
	queue_node(T elem) :val(elem), next(nullptr) {};
    ~queue_node(){};
    queue_node(const queue_node& another)=delete;
	queue_node& operator=(const queue_node& another) = delete;
};

创建销毁

提供四种构造。

无参构造：创建空队列。

复制构造：用另一个队列进行深度拷贝。所谓深度拷贝就是以another指针指向的值作为参数创建新指针而不是让两指针指向同一值。让队头获得创新得到的第一个节点，然后以两个临时指针another_val与this_val进行同步，this_val时时构造与another_val指向的值相同的新节点。

最后队尾获得创建得到的最后一个节点。

析构函数：当队列非空，循环进行头结点弹出。后面实现判断空队列行为和弹出行为。

另有重载等于号：作用于复制构造相同。

queue() :val_front(nullptr), val_back(nullptr), val_size(0) {};
queue(const queue& another) :queue() {
	int len = another.val_size;
	val_size = len;
	if (len) {
		queue_node<T>* this_val=new queue_node<T>(another.val_front->val);
		const queue_node<T>* another_val = another.val_front->next;
		val_front = this_val;
		while (--len) {
			this_val->next= new queue_node<T>(another_val->val);
			this_val = this_val->next;
			another_val = another_val->next;
		}
		val_back = this_val;
	}
}
~queue() {
	while (!empty())pop();
}
queue& operator=(const queue& another){
	val_front = val_back = nullptr;
	int len = another.val_size;
	val_size = len;
	if (len) {
		queue_node<T>* this_val = new queue_node<T>(another.val_front->val);
		const queue_node<T>* another_val = another.val_front->next;
		val_front = this_val;
		while (--len) {
			this_val->next = new queue_node<T>(another_val->val);
			this_val = this_val->next;
			another_val = another_val->next;
		}
		val_back = this_val;
	}
	return *this;
}

数据控制

获取长度：返回val_size。

判断为空：返回val_size ? false : true。

队尾压入：如果是空队列，队头申请新节点node后，令队尾等于队头。否则在队尾后面申请新节点。

队头弹出：如果是空队列，抛出异常。否则获取当前头结点的next，删除头节点后将next作为头结点。如果队列大小为1，那么删除后应将头尾全部置为nullptr空节点。

size_t size() {
	return val_size;
}
bool empty() {
	return val_size ? false : true;
}
void push(const T elem) {
	if (val_size == 0) {
		val_front = new queue_node<T>(elem);
		val_back = val_front;
	}
	else {
		val_back->next = new queue_node<T>(elem);
		val_back = val_back->next;
	}
	val_size++;
}
void pop(){
	assert(val_size > 0);
	queue_node<T>* temp = val_front->next;
	delete val_front;
	val_front = temp;
	val_size--;
	if (!val_size)val_front = val_back= nullptr;
}

数据访问

访问队头：判断无异常后返回队头的常量引用。

访问队尾：判断无异常后返回队尾的常量引用。

我们的queue访问操作不支持接受方进行数据更改。

const T& front() {
	assert(val_size > 0);
	return (val_front->val);
}
const T& back() {
	assert(val_size > 0);
	return (val_back->val);
}

Code

#pragma once
#include <cassert>
namespace custom_queue {
	template<typename T>
    class queue {
	private:
		template<typename T>
		class queue_node {
		private:
			template<typename T>
			friend class queue;
			T val;
			queue_node* next;
			queue_node(T elem) :val(elem), next(nullptr) {};
            ~queue_node(){};
            queue_node(const queue_node& another)=delete;
			queue_node& operator=(const queue_node& another) = delete;
		};
		queue_node<T>* val_front;
		queue_node<T>* val_back;
		size_t val_size;
	public:
		queue() :val_front(nullptr), val_back(nullptr), val_size(0) {};
		queue(const queue& another) :queue() {
			int len = another.val_size;
			val_size = len;
			if (len) {
				queue_node<T>* this_val=new queue_node<T>(another.val_front->val);
				const queue_node<T>* another_val = another.val_front->next;
				val_front = this_val;
				while (--len) {
					this_val->next= new queue_node<T>(another_val->val);
					this_val = this_val->next;
					another_val = another_val->next;
				}
				val_back = this_val;
			}
		}
		~queue() {
			while (!empty())pop();
		}
		queue& operator=(const queue& another){
			val_front = val_back = nullptr;
			int len = another.val_size;
			val_size = len;
			if (len) {
				queue_node<T>* this_val = new queue_node<T>(another.val_front->val);
				const queue_node<T>* another_val = another.val_front->next;
				val_front = this_val;
				while (--len) {
					this_val->next = new queue_node<T>(another_val->val);
					this_val = this_val->next;
					another_val = another_val->next;
				}
				val_back = this_val;
			}
			return *this;
		}
		int size() {
			return val_size;
		}
		bool empty() {
			return val_size ? false : true;
		}
		void push(const T elem) {
			if (val_size == 0) {
				val_front = new queue_node<T>(elem);
				val_back = val_front;
			}
			else {
				val_back->next = new queue_node<T>(elem);
				val_back = val_back->next;
			}
			val_size++;
		}
		void pop(){
			assert(val_size > 0);
			queue_node<T>* temp = val_front->next;
			delete val_front;
			val_front = temp;
			val_size--;
			if (!val_size)val_front = val_back= nullptr;
		}
		const T& front() {
			assert(val_size > 0);
			return (val_front->val);
		}
		const T& back() {
			assert(val_size > 0);
			return (val_back->val);
		}
	};
}

测试

#include <iostream>
#include "queue.h"
using namespace std;
int main()
{
    custom_queue::queue<char>que1;
    que1.push('a'); que1.push('b'); que1.push('c');
    custom_queue::queue<char>que2(que1);
    while (!que1.empty()) {
        cout << que1.front();
        que1.pop();
    }
   cout << endl;

    while (!que2.empty()) {
        cout << que2.front();
         que2.pop();
     }
    cout << endl;

    que2.push('x');
    cout <<que2.front()<<' '<< que2.back();
    cout << endl;

    return 0;
}