数据结构——队列篇（普通数据类型、类作为元素以及队列类模板的实现）

最新推荐文章于 2024-08-04 12:02:54 发布
最新推荐文章于 2024-08-04 12:02:54 发布
阅读量1.8k 收藏 2
点赞数 2
分类专栏： c++ 数据结构 文章标签： c++ 数据结构 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/feiyanjia/article/details/80988162
版权

一.理论部分不多叙述，具体可参考慕课网数据结构之队列篇（环形队列）。本篇博客住要从三个方面进行编写：

1.基础的队列，int元素作为队列的元素。

2.建立类，将类作为队列的元素。

3.建立队列模板类，该类可适应多种类型的队列元素。

（本博客主要作为自己学习以及复习所用，欢迎各位补充和指正！）

二.实现方法

1.首先最简单的队列方法：

Myqueue.h

#ifndef Myqueue_H_
#define Myqueue_H_
class Myqueue
{
public:
	Myqueue(int queueCapacity);
	virtual ~Myqueue();
	void ClearQueue();
	bool QueueEmpty() const;
	int QueueLength() const;
	bool EnQueue(int element);
	bool DeQueue(int &element);
	bool QueueFull() const;
	void QueueTraverse();
private:
	int *m_pQueue;
	int m_iQueueLen;
	int m_iQueueCapacity;
	int m_iTail;
	int m_iHead;
};


#endif

Myqueue.cpp文件

#include<iostream>
#include"Myqueue.h"
using namespace std;
Myqueue::Myqueue(int queueCapacity)
{
	m_iQueueCapacity = queueCapacity;
	m_pQueue = new int[m_iQueueCapacity];
	ClearQueue();
}
Myqueue:: ~Myqueue()
{
	delete m_pQueue;
	m_pQueue = NULL;
}
void Myqueue::ClearQueue()
{
    m_iTail = 0;
    m_iHead = 0;
	m_iQueueLen = 0;
}
bool Myqueue::QueueEmpty() const
{
	if (m_iQueueLen == 0)
		return true;
	else
		return false;

}
int Myqueue::QueueLength() const
{
	return m_iQueueLen;
}
bool Myqueue::EnQueue(int element)
{
	if (QueueFull())
	{
		return false;
	}
	else
	{
		m_pQueue[m_iTail] = element;
		m_iTail++;
		m_iTail = m_iTail%m_iQueueCapacity;
		m_iQueueLen++;
		return true;
	}

}
bool Myqueue::DeQueue(int &element)
{
	if (QueueEmpty())
	{
		return false;
	}
	else
	{
		element = m_pQueue[m_iHead];
		m_iHead++;
		m_iHead = m_iHead%m_iQueueCapacity;
		m_iQueueLen--;
		return true;

	}

}
bool Myqueue::QueueFull() const
{
	if (m_iQueueLen == m_iQueueCapacity)
	{
		return true;
	}
	else
	{
		return false;
	}
}
void Myqueue::QueueTraverse()
{
	for (int i = m_iHead; i < m_iHead + m_iQueueLen; i++)
	{
		cout<<m_pQueue[i] << endl;
	}
}

测试文件Queue_demo：

#include<iostream>
#include"Myqueue.h"
using namespace std;
int main()
{
	Myqueue *p = new Myqueue(4);
	p->EnQueue(1);
	p->EnQueue(2);
	p->EnQueue(3);
	p->EnQueue(4);
	p->EnQueue(5);
	p->QueueTraverse();
	cout << endl;
	int e = 0;
	p->DeQueue(e);
	cout << e << endl;
	cout << endl;
	p->QueueTraverse();
	system("pause");
	return 0;
}

2.此时使用customer类作为队列的元素，将原先的对象类型改为customer类

Myqueue.h:

#ifndef Myqueue_H_
#define Myqueue_H_
#include"Customer.h"
class Myqueue
{
public:
	Myqueue(int queueCapacity);
	virtual ~Myqueue();
	void ClearQueue();
	bool QueueEmpty() const;
	int QueueLength() const;
	bool EnQueue(Customer element);
	bool DeQueue(Customer &element);
	bool QueueFull() const;
	void QueueTraverse();
private:
	Customer *m_pQueue;//将其改为Customer类指针，其他不变
	int m_iQueueLen;
	int m_iQueueCapacity;
	int m_iTail;
	int m_iHead;
};

#endif

Myqueue.cpp

#include<iostream>
#include"Myqueue.h"
using namespace std;
Myqueue::Myqueue(int queueCapacity)
{
	m_iQueueCapacity = queueCapacity;
	m_pQueue = new Customer[m_iQueueCapacity];
	ClearQueue();
}
Myqueue:: ~Myqueue()
{
	delete m_pQueue;
	m_pQueue = NULL;
}
void Myqueue::ClearQueue()
{
	m_iTail = 0;
	m_iHead = 0;
	m_iQueueLen = 0;
}
bool Myqueue::QueueEmpty() const
{
	if (m_iQueueLen == 0)
		return true;
	else
		return false;

}
int Myqueue::QueueLength() const
{
	return m_iQueueLen;
}
bool Myqueue::EnQueue(Customer element)
{
	if (QueueFull())
	{
		return false;
	}
	else
	{
		m_pQueue[m_iTail] = element;
		m_iTail++;
		m_iTail = m_iTail%m_iQueueCapacity;
		m_iQueueLen++;
		return true;
	}

}
bool Myqueue::DeQueue(Customer &element)
{
	if (QueueEmpty())
	{
		return false;
	}
	else
	{
		element = m_pQueue[m_iHead];
		m_iHead++;
		m_iHead = m_iHead%m_iQueueCapacity;
		m_iQueueLen--;
		return true;

	}

}
bool Myqueue::QueueFull() const
{
	if (m_iQueueLen == m_iQueueCapacity)
	{
		return true;
	}
	else
	{
		return false;
	}
}
void Myqueue::QueueTraverse()
{
	for (int i = m_iHead; i < m_iHead + m_iQueueLen; i++)
	{
		cout << m_pQueue[i] << endl;
	}
}

Customer.h:

#ifndef CUSTOMER_H_
#define CUSTOMER_H_
#include<string>
#include<iostream>
using namespace std;
class Customer
{
public:
	Customer(string name="fei", int age=1);//默认构造函数，对应于m_pQueue指针内存的申请
	friend ostream & operator<<(ostream &os, const Customer &customer );//重载输出符号


private:
	int m_iage;
	string m_strname;


};
#endif

Customer.cpp

#include<iostream>
#include<string>
#include"Customer.h"
using namespace std;
Customer::Customer(string name, int age)
{
	m_strname = name;
	m_iage = age;
}
ostream & operator<<(ostream &os, const Customer &customer)
{
	os << "name:"<<customer.m_strname << endl;
	os << "age:"<<customer.m_iage << endl;
	return os;
}

queue_demo.cpp:

#include<iostream>
#include"Myqueue.h"
#include"Customer.h"
using namespace std;
int main()
{
	Myqueue *p = new Myqueue(5);
	Customer customer1("fei", 21);//实例化对象
	Customer customer2("yan", 21);
	Customer customer3("jia", 21);
	Customer customer4("good", 21);
	Customer customer5("boy", 21);
	p->EnQueue(customer1);
	p->EnQueue(customer2);
	p->EnQueue(customer3);
	p->EnQueue(customer4);
	p->EnQueue(customer5);
	cout << "遍历" << endl;
	p->QueueTraverse();
	cout << endl;
	cout << "出队列" << endl;
	Customer e;
	p->DeQueue(e);
	cout << e << endl;
	cout << endl;
	cout << "再次遍历" << endl;
	p->QueueTraverse();
	system("pause");
	return 0;
}

3.建立队列模板类，使得该类可适应多种类型的元素

customer类与上诉相同，在编译时将Myqueue.cpp文件放入Myqueue.h 文件中一同编译。

Myqueue.h：

#ifndef Myqueue_H_
#define Myqueue_H_
#include"Customer.h"
template <typename T>
class Myqueue
{
public:
	Myqueue(int queueCapacity);
	virtual ~Myqueue();
	void ClearQueue();
	bool QueueEmpty() const;
	int QueueLength() const;
	bool EnQueue(T element);
	bool DeQueue(T &element);
	bool QueueFull() const;
	void QueueTraverse();
private:
	T *m_pQueue;//将其改为Customer类指针，其他不变
	int m_iQueueLen;
	int m_iQueueCapacity;
	int m_iTail;
	int m_iHead;
};
template<typename T>
Myqueue<T>::Myqueue(int queueCapacity)
{
	m_iQueueCapacity = queueCapacity;
	m_pQueue = new T[m_iQueueCapacity];
	ClearQueue();
};
template<typename T>
Myqueue<T>:: ~Myqueue()
{
	delete m_pQueue;
	m_pQueue = NULL;
};
template<typename T>
void Myqueue<T>::ClearQueue()
{
	m_iTail = 0;
	m_iHead = 0;
	m_iQueueLen = 0;
};
template<typename T>
bool Myqueue<T>::QueueEmpty() const
{
	if (m_iQueueLen == 0)
		return true;
	else
		return false;

};
template<typename T>
int Myqueue<T>::QueueLength() const
{
	return m_iQueueLen;
};
template<typename T>
bool Myqueue<T>::EnQueue(T element)
{
	if (QueueFull())
	{
		return false;
	}
	else
	{
		m_pQueue[m_iTail] = element;
		m_iTail++;
		m_iTail = m_iTail%m_iQueueCapacity;
		m_iQueueLen++;
		return true;
	}

};
template<typename T>
bool Myqueue<T>::DeQueue(T &element)
{
	if (QueueEmpty())
	{
		return false;
	}
	else
	{
		element = m_pQueue[m_iHead];
		m_iHead++;
		m_iHead = m_iHead%m_iQueueCapacity;
		m_iQueueLen--;
		return true;

	}

};
template<typename T>
bool Myqueue<T>::QueueFull() const
{
	if (m_iQueueLen == m_iQueueCapacity)
	{
		return true;
	}
	else
	{
		return false;
	}
};
template<typename T>
void Myqueue<T>::QueueTraverse()
{
	for (int i = m_iHead; i < m_iHead + m_iQueueLen; i++)
	{
		cout << m_pQueue[i] << endl;
	}
};
#endif

queue_demo.cpp:

#include<iostream>
#include"Myqueue.h"
#include"Customer.h"
using namespace std;
int main()
{
	cout << "使用类实例化模板：" << endl;
	Myqueue<Customer> *p = new Myqueue<Customer>(5);
	Customer customer1("fei", 21);//实例化对象
	Customer customer2("yan", 21);
	Customer customer3("jia", 21);
	Customer customer4("good", 21);
	Customer customer5("boy", 21);
	p->EnQueue(customer1);
	p->EnQueue(customer2);
	p->EnQueue(customer3);
	p->EnQueue(customer4);
	p->EnQueue(customer5);
	cout << "遍历" << endl;
	p->QueueTraverse();
	cout << endl;
	cout << "出队列" << endl;
	Customer e;
	p->DeQueue(e);
	cout << e << endl;
	cout << endl;
	cout << "再次遍历" << endl;
	p->QueueTraverse();
	cout << "使用字符类型实例化" << endl;
	p->ClearQueue();
	

	Myqueue<char> *pp = new Myqueue<char>(5);

	pp->EnQueue('f');
	pp->EnQueue('y');
	pp->EnQueue('j');
	pp->EnQueue('g');
	pp->EnQueue('b');
	cout << "遍历" << endl;
	pp->QueueTraverse();
	cout << endl;
	cout << "出队列" << endl;
	char ee;
	pp->DeQueue(ee);
	cout << ee << endl;
	cout << endl;
	cout << "再次遍历" << endl;
	pp->QueueTraverse();
	system("pause");
	return 0;
}

实验结果如下：





                

        

        

    




    

      

        

            

              
                
                  佳佳费_
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    2
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    2
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
C++数据结构——队列

				
			

			

				

					GeekZW的博客
				

				

					06-26
					
					17万+
					
				

			

		

		

			
				
C++数据结构——队列参考博客：http://www.cnblogs.com/QG-whz/p/5171123.htmlhttp://www.169it.com/article/2718050585107790752.html1、队列（Queue）与栈一样，是一种线性存储结构，它具有如下特点：（1）队列中的数据元素遵循“先进先出”（First In First Out）的原则，简称FIFO结构；（...

			
		

	



                

              
                



	

		

			

				
					
【数据结构】数据结构大汇总 {数据结构的分类总结：定义和特性、实现方式、操作与复杂度、适用场景、相关算法、应用实例}

				
			

			

				

					芥末虾的博客
				

				

					05-15
					
					1245
					
				

			

		

		

			
				
【数据结构】数据结构大汇总 {数据结构的分类总结：定义和特性、实现方式、操作与复杂度、适用场景、相关算法、应用实例}

			
		

	



                


  
              

                


	

		

			

				
					
数据结构 —— 队列（超详细图解 & 接口函数实现）

				
			

			

				

					十里坡小白的博客
				

				

					08-14
					
					2065
					
				

			

		

		

			
				
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。数据结构是一种十分优秀的解决实际问题的模板，博主将会用代码结合大量图解，对数据结构进行深度剖析。......

			
		

	





	

		

			

				
					
数据结构  ——  队列

				
			

			

				

					林深不见鹿 的博客
				

				

					10-16
					
					2764
					
				

			

		

		

			
				
队列
1.队列的介绍
队列是一种先进先出的数据结构，这和栈有所不同，但又更容易理解。类似于食堂排队打饭，车站排队买票。
后来的人排在队伍最后边，先来的人先打饭或者买票走。如图

队列总是从队尾插入元素,而从队首移除元素，满足先进先出的规则。因此需要一个队首指针front指向队首元素的前一个位置，而使用一个队尾指针rear来指向队尾元素。
，需要一个队首指针front来指向队首元素的前一个位置，而使用一个队尾指针rear来指向队尾元素。和栈类似，当使用数组来实现队列时，队首指针front和队尾指针rear为i

			
		

	



		

			
		



	

		

			

				
					
数据结构——循环队列（C++实现）

				
			

			

				

					qq_67693066的博客
				

				

					04-22
					
					894
					
				

			

		

		

			
				
数据结构——循环队列（C++）

			
		

	





	

		

			

				
					
数据结构——队列 c++详解

				
			

			

				

					m0_54615144的博客
				

				

					07-28
					
					8674
					
				

			

		

		

			
				
1、队列（Queue）与栈一样，是一种线性存储结构，它具有如下特点：

（1）队列中的数据元素遵循“先进先出”（First In First Out）的原则，简称FIFO结构；

（2）在队尾添加元素，在队头删除元素。...

			
		

	





	

		

			

				
					
数据结构——队列的详解

				
			

			

				

					晴空๓
				

				

					04-21
					
					5213
					
				

			

		

		

			
				
队列和栈相反，队列(queue)是一种先进先出（FIFO:first in first out）的线性表。它只允许在表的一端进行插入，而在另一端删除元素。队列和我们日常生活中的排队是一致的，最早进入队列的元素最早离开。在队列中，允许插入的一端叫队尾（tear），允许删除的一端称为队头（front）

			
		

	





	

		

			

				
					
C++数据结构——队列queue

				
			

			

				

					我发布的博客，快来抄答案吧
				

				

					06-08
					
					589
					
				

			

		

		

			
				
C++数据结构：队列
详解

			
		

	





	

		

			

				
					
手把手教数据结构与算法：优先级队列（银行排队问题）

				
			

			

				

					weixin_73611714的博客
				

				

					05-01
					
					9766
					
				

			

		

		

			
				
本文是一篇关于模拟银行排队系统的编程实现的指南。它从队列的基本概念开始介绍，包括队列的定义、特点、常见基本操作以及优先级队列的概念。然后给出银行排队问题的描述和解题思路，队列和优先级队列的数据结构实现以及模拟银行排队系统的类实现。

			
		

	





	

		

			

				
					
数据结构——优先级队列及多服务台模拟系统的实现

				
			

			

				

					2301_79376014的博客
				

				

					03-27
					
					1296
					
				

			

		

		

			
				
基于普通线性表实现优先级队列，入队和出队中必有一个时间复杂度O(n),基于二叉树结构实现优先级队列，能够让入队和出队时间复杂度都为O(logn），这种基于树状结构的优先级队列也称为。

			
		

	





	

		

			

				
					
c++二维数组作为形参传递参数

					
热门推荐

				
			

			

				

					feiyanjia的博客
				

				

					07-20
					
					1万+
					
				

			

		

		

			
				
在写代码时，有时涉及到二维数组的形参传递，这个问题很小，但是当解决不好时可能会导致程序编写的复杂程度。因此有必要在这里重说一下：

1.《C++ Primer》中给出的方法：


void func1(int iArray[][10])  
{  
  
}  
  
  
  
int main()  
{  
    int array[10][10];  
    func1(array);...

			
		

	





	

		

			

				
					
二叉树遍历C++（前、中、后序遍历，层次遍历、深度遍历）

				
			

			

				

					feiyanjia的博客
				

				

					10-07
					
					7488
					
				

			

		

		

			
				
一.使用c++进行前中后遍历，层次和深度遍历（非递归）

二.代码


#include&lt;iostream&gt;
#include&lt;queue&gt;
#include&lt;vector&gt;
#include&lt;stack&gt;
using namespace std;
struct TreeNode {
	int val;
	struct TreeNode *left;...

			
		

	





	

		

			

				
					
几种常用的查找元素方法

				
			

			

				

					feiyanjia的博客
				

				

					07-20
					
					2426
					
				

			

		

		

			
				
几种常用查找方法，待更新：


#include&lt;iostream&gt;
using namespace std;
int Sequential_Search(int *Array, int Number, int N)
{

	for (int i = 0; i &lt; N; i++)
	{
		if (Number == Array[i])
			return i;
	}
	retu...

			
		

	





	

		

			

				
					
数据结构——二叉树的实现

				
			

			

				

					feiyanjia的博客
				

				

					07-17
					
					663
					
				

			

		

		

			
				
1.建立Node节点，利用Node节点来实现相关的方法：节点赋值、节点删除、节点搜索、节点遍历。利用递归来实现相关具体方法。

2.Tree类中，利用根节点指针m_pRoot来实现具体的从根节点进行的操作，例如：节点赋值、节点删除、节点搜索、节点遍历。

3.具体代码如下：

3.1Node节点代码：


#ifndef NODE_H_
#define NODE_H_
class Node
{
	...

			
		

	





	

		

			

				
					
反向输出链表——利用结构体作为链表元素，vector创建对象简单实现

				
			

			

				

					feiyanjia的博客
				

				

					07-22
					
					458
					
				

			

		

		

			
				

#include&lt;iostream&gt;
#include&lt;vector&gt;
using namespace std;

	struct ListNode {
		int val;
		ListNode *next;

	};
	ListNode head = {0,NULL};//申请全局变量，初始化头结点，这点很重要，读链表数据时也从此处读取。
	

void insert...

			
		

	





	

		

			

				
					
数据结构——链表的实现

				
			

			

				

					feiyanjia的博客
				

				

					07-15
					
					329
					
				

			

		

		

			
				
本篇博客主要编写了链表的相关程序，主要内容如下：一.相关叙述1.将数据节点用Node来表示，Node类中包含数据部分data，指针部分*Next（用于指向下一个节点）。2.整个链表的头节点*plist用于方便插入和链表的描述，不用于存储数据和链表的输出，整个链表从头结点的下一个节点开始，表示为0。3.在链表的相关操作中，例如：增加元素，遍历等，均是从头结点往下（头节点元素插入时，从头结点下一个元素...

			
		

	





	

		

			

				
					
几种常用的排序方法——c++实现

				
			

			

				

					feiyanjia的博客
				

				

					07-20
					
					309
					
				

			

		

		

			
				
实现几种常用的排序方法，后续补充： 


#include&lt;iostream&gt;
using namespace std;
 //1.BubbleSort
int* BubbleSort(int  array[],int const N) 
{
	int *Arr = new int[N];
	for (int i = 0; i &lt; N; i++)
	{
		Arr[i] = ar...

			
		

	





	

		

			

				
					
C++ STL copy_backward, move_backward 用法

					
最新发布

				
			

			

				

					
				

				

					08-04
					
					173
					
				

			

		

		

			
				
此处需要解释一下：从后向前并不是逆序，它的意思是: 源容器和目标容器都从尾部开始，然后向前迭代，执行拷贝/移动操作。反向（从后向前的顺序）拷贝/移动操作，将一个容器元素拷贝/移动到另一容器中。

			
		

	





	

		

			

				
					
C++实现数据结构：特殊线性表——栈、队列与串

				
			

			

				

					
				

			

		

		

			
				
"这是一份关于数据结构的C++版电子笔记，主要讲解了特殊线性表中的栈、队列和串的概念与实现。笔记详细介绍了栈的逻辑结构、抽象数据类型定义以及顺序存储结构，同时也探讨了两栈共享空间的问题及其解决方案。"  在...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值