《大话数据结构》—— 队列的链式存储结构 —— C++、C# 代码实现

目录

链队列

循环队列和链式队列的比较


链队列


 实现队列的最好的方式就是使用单链表来实现,队列的链式存储结构,其实就是线性表的单链表,只不过它只能尾进头出而已——称为链队列。

那为了操作方便,头指针指向头结点,队尾指针指向终端节点,即最后一个结点元素。

设队首、队尾指针front和rear,front指向头结点,rear指向队尾

队列为空时,front 和 real 都指向头结点:

这种实现出队和入队就十分方便,出队只需要将头结点指向的位置进行改变,入队只需要将rear的指向进行改变。

下面看我写的代码:

LinkQueue.h 头文件

#include
#include
using namespace std;
#ifndef TT_LINK_QUEUE_H
#define TT_LINK_QUEUE_H
namespace tt
{
	class LinkQueue  //队列的链表结构
	{
	public:
		using ElemType = int;
		using Status = void;
	public:
		struct QNode  //队列的结点结构
		{
			ElemType m_data; //链队列的数据域
			QNode *m_next; //链队列的指针域
		};
		enum State
		{
			TT_ERROR = 0,
			TT_OK = 1
		};
	public:
		LinkQueue();
		~LinkQueue();
		ElemType isEmpty()const;   //判断队列是否为空
		ElemType clear();      //清空队列
		ElemType insert(ElemType elem);  //插入元素致链队列尾部
		ElemType remove(ElemType &elemOut);  //删除链队列的对头元素
		ElemType destroy();      //销毁队列
		ElemType getHead(ElemType &eleOut);  //获取对头元素
		Status createTail(ElemType *datas, size_t length);//创建长度为length的链队列,数据通过数组指定,这里采用尾插法
		Status createHead(ElemType *datas, size_t length);  //头插法
		Status getlength()const;  //链队列的当前个数
		Status traverseElem();   //遍历显示链队列中的所有元素
	private:
		QNode *m_front;  //链队列的对头指针,队头不保存元素,只起头结点作用,当front==rear时,队列为空
		QNode *m_rear;  //链队列的队尾指针
		ElemType m_queLength;  //链队列的当前长度
	};
	inline LinkQueue::ElemType LinkQueue::isEmpty()const
	{
		return (m_front == m_rear);
	}
	inline LinkQueue::Status LinkQueue::getlength()const
	{
		cout << "链队列的当前的元素个数为:" << m_queLength << "\n" << endl;
	}
}
#endif //TT_LINK_QUEUE_H

testLinkQueue.cpp 源文件

#include"LinkQueue.h"

namespace tt
{
	LinkQueue::LinkQueue()
	{
		m_front = new QNode;  
		assert(m_front != nullptr);
		m_rear = m_front; //链队列为空时,对头就是队尾
		m_front->m_next = nullptr;  //队头指针指向空
		m_queLength = 0;
		cout << "*******************链队列初始化成功************************" << endl;
	}
	LinkQueue::~LinkQueue()
	{
		this->destroy();
	}
	LinkQueue::Status LinkQueue::createTail(ElemType *datas, size_t length)//创建长度为length的链队列,数据通过数组指定,这里采用尾插法
	{
		for (size_t i = 0; i < length; ++i)
		{
			this->insert(datas[i]);
		}
	}
	LinkQueue::Status LinkQueue::createHead(ElemType *datas, size_t length)  //头插法
	{
		
		if (m_rear == m_front)
		{

			this->insert(datas[0]);  //创建第一个元素
		}
		QNode *s = m_front->m_next; //指针s指向第一个元素
		for (int i = 1; i < length; ++i)
		{
			QNode *p = new QNode;
			p->m_data = datas[i];
			p->m_next = s; // 新插入的结点的后继是s,该结点暂时成为第一个元素
			m_front->m_next = p; //头结点后继是p
			s = p; // 指针s也指向p指针指向的位置
			++m_queLength;
		}
	}
	LinkQueue::ElemType LinkQueue::insert(ElemType elem)
	{
		QNode *p = new QNode;  //给一个新节点分配内存
		assert(p != nullptr);
		p->m_data = elem;  //首先把要把新元素添进数据域
		p->m_next = nullptr;  //新结点的后继指向空
		m_rear->m_next = p;  //然后在把p变成原队尾指针指向的后继结点
		m_rear = p; //最后再把p设置为队尾结点,此时m_rear指针指向最后一个元素
		++m_queLength;  //队列的长度加1
		return TT_OK;
	}
	LinkQueue::ElemType LinkQueue::remove(ElemType &elemOut)
	{
		if (m_front == m_rear)  //先判断链队列是否为空,空就错误,
		{
			return TT_ERROR;
		}
		QNode *p = m_front->m_next; //声明一个新结点,该结点等于要删除的第一个元素
		elemOut = p->m_data;  //在把要删除的元素用eleOut返回
		m_front->m_next = p->m_next;  //在把要队头结点的后继结点,即第二个元素,m_front指针指向它,就变成头结点的后继
		if (m_rear == p)  //如果要删除的元素刚好就是最后一个元素,  此时就一个元素
		{
			m_rear = m_front;  //删除后,m_rear指针指向头结点
		}
		delete p;  //释放要删除的结点的内存
		--m_queLength;  //链队列的的长度减一
		return TT_OK;
	}
	LinkQueue::ElemType LinkQueue::getHead(ElemType &eleOut)
	{
		if (m_front == m_rear)  //先判断链队列是否为空,空就错误,
		{
			return TT_ERROR;
		}
		//QNode *q=m_front->m_next; eleOut=q->m_data;
		eleOut = m_front->m_next->m_data;  //把m_front指针指向的后继结点的指针域中的数据用eleOut返回
		return TT_OK;
	}
	LinkQueue::ElemType LinkQueue::clear()  //清空链队列,不包括头结点
	{
		QNode *m = m_front->m_next;  //首先声明一个临时结点m,变成队头元素
		//m_front->m_next = nullptr; //然后m_front指针指向nullptr
		m_rear = m_front;  //m_rear指针指向头结点
		while (m)  //当m不为空时,循环继续
		{
			QNode *s = m->m_next;   //先把m结点的后继结点变成s,即第二个元素
			delete m;  //释放m结点
			m = s;  //然后在把s 结点变成m结点,m结点永远都是第一个元素
		}
		m_queLength = 0;
		return TT_OK;
	}
	LinkQueue::ElemType LinkQueue::destroy()  //销毁队列,包括头结点
	{
		this->clear();
		delete m_front;
		m_front = m_rear = nullptr;
		return TT_OK;
	}
	LinkQueue::Status LinkQueue::traverseElem()   //遍历显示链队列中的所有元素
	{
		if (m_front == m_rear)  //先判断链队列是否为空,空就错误,
		{
			cout << "此队列中没有数据或者队列没有建立,无法显示!" << "\n" << endl;
		}
		else
		{
			cout << "队列从队头至队尾内容依次为:";
			QNode *q = m_front->m_next;  //首先把第一个元素变成临时变量q
			while (q)  //只要q不为NULL,就继续
			{
				cout << q->m_data << " ";  //显示出q指针指向的节点的元素
				q = q->m_next;  //q指针每循环一次往后移动一次
			}
			cout << endl;
		}
	}
}

//测试链式队列
void testLinkQueue()
{
	tt::LinkQueue mylinkQueue; //初始化一个队列

	int myLength(0);    //链队列的整表创建
	cout << "想创建多少数据的链表?";
	cin >> myLength;
	int *myDatas = new int[myLength];
	cout << "请依次输入这" << myLength << "个数据,中间以回车符隔开:" << endl;

	for (int i = 0; i < myLength; ++i)
	{

		cin >> myDatas[i];  //输入要存储的数据的值
	}
	mylinkQueue.createTail(myDatas, myLength);   //调用createTail函数 建立单链表
	mylinkQueue.traverseElem();
	while (true)
	{
		{
			cout << ("\n*********************************************************") << endl
				<< "***************     链队列的基本功能展示    ******************" << endl
				<< "*******************************************************" << endl
				<< "**************      选择1—— 数据进队列尾.       ************" << endl
				<< "**************      选择2—— 删除队列头元素.     ************" << endl
				<< "***************     选择3—— 显示队列头元素.     ************" << endl
				<< "***************     选择4—— 判断队列是否为空.   ************" << endl
				<< "***************************************************************" << endl
				<< "***************     选择5—— 显示队列的元素个数. *************" << endl
				<< "***************     选择6—— 清空队列.           *************" << endl
				<< "****************    选择7—— 销毁队列.           *************" << endl
				<< "****************    选择8—— 显示队列中的所有元素. ***********" << endl
				<< "****************    选择9—— 清屏.              *************" << endl
				<< "****************    选择0—— 退出程序!         *************" << endl
				<< "***************************************************************" << endl
				<< "***************************************************************" << endl;
		}
		cout << "\n*************请输入你想要使用的链队列功能的序号***************" << endl;
		cout << "请输入相应的序号:";
		int userChoice(0);
		cin >> userChoice;
		if (userChoice == 0)
		{
			cout << "程序已退出,感谢您的使用!" << "\n" << endl;
			break;
		}
		switch (userChoice)
		{
		case 1:
		{
			cout << "请输入你想添加的数据:";
			int pushDatas(0);
			cin >> pushDatas;
			if (mylinkQueue.insert(pushDatas))  //添加数据进队尾
			{
				cout << "数据" << pushDatas << "进队列成功!" << endl;
				mylinkQueue.getlength();
				mylinkQueue.traverseElem();
			}
			else
				cout << "内存分配失败,数据" << pushDatas << "进队列失败!" << "\n" << endl;
			break;
		}
		case 2:
		{
			int popHead(0);
			if (mylinkQueue.remove(popHead))  //删除队头元素
			{
				cout << "数据" << popHead << "删除成功!" << "\n" << endl;
				mylinkQueue.getlength();
				mylinkQueue.traverseElem();
			}
			else
			{
				cout << "目前队列为空,数据" << popHead << "删除失败!" << "\n" << endl;
				mylinkQueue.getlength();
			}
			break;
		}
		case 3:
		{
			int showHead(0);
			if (mylinkQueue.getHead(showHead))  //显示队头元素
			{
				cout << "链队列的头元素为:" << showHead << "\n" << endl;
				mylinkQueue.getlength();
				mylinkQueue.traverseElem();
			}
			else
			{
				cout << "目前队列为空,无法显示元素!" << "\n" << endl;
				mylinkQueue.getlength();
			}
			break;
		}
		case 4:
			if (mylinkQueue.isEmpty())  //判断链队列是否为空
			{
				cout << "此队列为空!" << "\n" << endl;
				mylinkQueue.getlength();
			}
			else
			{
				cout << "队列不为空" << "\n" << endl;
				mylinkQueue.getlength();
				mylinkQueue.traverseElem();
			}
			break;
		case 5:                          //显示链队列当前的元素个数
			mylinkQueue.getlength();
			mylinkQueue.traverseElem();
			break;
		case 6:
			if (mylinkQueue.clear())  //清空队列
			{
				cout << "队列已被清空!" << "\n" << endl;
				mylinkQueue.getlength();
			}
			else
			{
				cout << "队列清空失败!" << "\n" << endl;
				mylinkQueue.getlength();
				mylinkQueue.traverseElem();
			}
			break;
		case 7:
		{
			cout << "你确定要销毁此队列吗?如若销毁,就无法恢复,请谨慎操作.(若销毁请输入Y或y,表示确定)";
			char yesOrNo;
			cin >> yesOrNo;
			if ((yesOrNo == 'y') || (yesOrNo == 'y'))
			{
				if (mylinkQueue.destroy())
				{
					cout << "队列已被销毁!" << "\n" << endl;
				}
				else
					cout << "队列销毁失败!" << "\n" << endl;
			}
			break;
		}
		case 8:                          //显示队列中的所有元素
			mylinkQueue.getlength();
			mylinkQueue.traverseElem();
			break;
		case 9:
			system("cls");
			cout << "屏幕已经清屏,可以重新输入!" << "\n" << endl;
			break;
		default:
			cout << "输入的序号不正确,请重新输入!" << "\n" << endl;
		}
	}
	delete[]myDatas;
	myDatas = nullptr;
}
int main()
{
	testLinkQueue();
	system("pause");
	return 0;
}

C# 代码实现的链队列:

namespace DateStructure
{
    interface IQueue
    {
        void CreateLinkQueueTail(params int[] arrElem);
        void clear();
        bool isEmpty();
        void EnQueue(int insertElem);
        int DeQueue();
        int getLength();
        void show();
        int getHeadElem(); 
    }
    class Node
    {
        public int m_Data { get; set; } = 0;
        public Node m_Next { get; set; } = null;
    }
    class LinkQueue : IQueue
    {
        private Node m_queueHead;
        private Node m_queueRear;
        private int m_data;
        public LinkQueue()
        {
            m_queueHead = new Node();
            Debug.Assert(m_queueHead != null, "头结点创建失败!");
            m_queueRear = m_queueHead;
        }
     

        public void CreateLinkQueueTail(params int[] arrElem) // 尾插法
        {
            if (arrElem.Length != 0 && arrElem != null)
            {              
                for (int i = 0; i != arrElem.Length; ++i)
                {
                    EnQueue(arrElem[i]);
                }
            }
            else
            {
                throw new ArgumentException("链队列整表创建失败!");
            }
        }
       public int getHeadElem()
        {
            if (m_queueHead.m_Data == 0)
            {
                return -1;
            }
            return m_queueHead.m_Next.m_Data;
        }
        public int DeQueue()
        {
            if (m_queueHead.m_Data == 0)
            {
                return -1;
            }
            int removeElem = m_queueHead.m_Next.m_Data;
          if(m_queueHead.m_Next == m_queueRear)
            {
                m_queueRear = m_queueHead;
            }
          else
            {
                m_queueHead.m_Next = m_queueHead.m_Next.m_Next;
            }
            --m_queueHead.m_Data;
            return removeElem;
        }

        public void EnQueue(int insertElem)
        {
            Node newNode = new Node();
            Debug.Assert(newNode != null, "添加元素时,创建新结点失败!");
            newNode.m_Data = insertElem;
            m_queueRear.m_Next = newNode;
            m_queueRear = newNode;
            ++m_queueHead.m_Data;
        }

        public void clear()
        {
            m_queueHead.m_Data = 0;
            m_queueRear = m_queueHead;
        }

        public int getLength()
        {
            return m_queueHead.m_Data;
        }

        public bool isEmpty()
        {
            return (m_queueHead.m_Data == 0 && m_queueRear == m_queueHead);
        }

        public void show()
        {
            if (m_queueHead.m_Data == 0)
            {
                WriteLine("该链队列中没有数据,无法显示!");
                return;
            }
            else
            {
                Node temp = m_queueHead;
                Write("输出此时链队列中所有的元素:");
                for (int i = 0; i != m_queueHead.m_Data; ++i)
                {
                    temp = temp.m_Next;
                    Write($"{temp.m_Data},");
                }
                WriteLine();
            }
        }

    }
    class Program
    {
        static void Main(string[] args)
        {
            LinkQueue myQueue = new LinkQueue();

            const int arraySize = 1;
            int[] myIntArray = new int[arraySize] {  55 };
            myQueue.CreateLinkQueueTail(myIntArray);
            myQueue.show();

            int removeElem = myQueue.DeQueue();
            if (removeElem >= 0)
            {
                WriteLine($"被删除的元素为:{removeElem}");

            }
            else
            {
                WriteLine("当前链队列是空的,没有元素可以删除!");
            }

            WriteLine("请输入你想插入的元素值:");
            int pushElem = Convert.ToInt32(Console.ReadLine());
            myQueue.EnQueue(pushElem);
            myQueue.show();

            int getHeadElem = myQueue.getHeadElem();
            if(0<=getHeadElem)
            {
                WriteLine($"获取队头元素为:{getHeadElem}");
            }
            else
            {
                WriteLine("当前链队列是空的,没有元素可以获取!");

            }

            if (myQueue.isEmpty())
            {
                WriteLine("当前的链队列为空!");
            }
            else
                WriteLine("当前的链队列非空!");
            WriteLine($"\n获取当前链队列的总个数:{myQueue.getLength()}");
            myQueue.clear();
            WriteLine($"获取当前链队列的总个数:{myQueue.getLength()}");

          

        }

    }
}


 


循环队列和链式队列的比较


(1)从时间上看,它们的基本操作都是常数时间,即O(1)的。不过循环队列是事先申请好空间,使用期间不释放;而链式队列,每次申请和释放结点也会存在一定的时间开销,如果入队和出队比较频繁,则两者还是有细微的差别。

(2)从空间上看,循环队列必须有一个固定的长度,所以就有了存储元素个数和空间浪费的问题。而链式队列不存在这个问题,尽管它需要一个指针域,会产生一些空间上的开销,但也可以接受。所以在空间上,链式队列更加灵活。

总结:总的来说,在可以确定队列长度的最大值的情况下,建议用循环队列,如果你无法估计队列的长度,那就用链式队列。

 

你可能感兴趣的:(数据结构)