数据结构热身--队列的C++实现

单链表实现队列

//SinglyLinkedList.h

#pragma once
#include <windows.h>
#include <iostream>
using namespace std;

// 数据结构体
struct STDataInfo
{
	char name[20]; // 姓名
	char club[20]; // 俱乐部
	char nation[20];// 国家
	int price; // 身价
	int num; // 号码
};

// 链表节点
struct stuLink
{
	STDataInfo data;  // 信息域
	stuLink * next; // 指向下一节点的指针
};

class SinglyLinkedList
{
public:
	SinglyLinkedList();

	~SinglyLinkedList();

public:

	// 创建新的节点
	static stuLink* createNewNode(STDataInfo stData);

	// 后向插入
	static void insertAfter( stuLink* head, STDataInfo data);
 
 	//按照num查看前一个节点
 	stuLink* selectPreNodeByNum( stuLink* head, int num);
 
	 // 按照num查看当前节点
	 stuLink *selectNowNodeByNum(stuLink* head, int num);

	 // 按照名字查询前面一个节点
	 static stuLink *selectPreNodeByName(stuLink *head,char* name);

 	//按照名字查询当前节点
 	static stuLink* selectNowNodeByName( stuLink* head, char *name);
 
 	//删除节点--按照num删除
 	void deleteByNum(stuLink* head, int num);
 
 	//删除节点--按照name删除
 	static void deleteByName(stuLink*head, char *name);
 
 	//销毁链表
 	void freeLink(stuLink* head);
 
 	//循环打印链表
 	static void printLink(stuLink*head);

	// 保存链表
	static void save(stuLink * head);

	// 加载链表
	static void load(stuLink *head);

	// 测试函数
	//void TestLink();

private:

};

//SinglyLinkedList.cpp
#include "SinglyLinkedList.h"
SinglyLinkedList::SinglyLinkedList()
{
}

SinglyLinkedList::~SinglyLinkedList()
{
}

stuLink* SinglyLinkedList::createNewNode(STDataInfo stData)
{
	stuLink *NewNode = (stuLink*)malloc(sizeof(stuLink));
	NewNode->data = stData;
	NewNode->next = NULL;

	return NewNode;

}
 
void SinglyLinkedList::insertAfter(stuLink* head, STDataInfo data)
{
	if(NULL == head)
	{
		cout <<"当前节点不能为空" << endl;
		return;
	}

	while(NULL != head->next)
	{
		head = head->next;
	}

	stuLink * newNode = createNewNode(data);
	head->next = newNode;
}

// 返回前一个节点
stuLink* SinglyLinkedList::selectPreNodeByNum(stuLink* head, int num)
{
	if(NULL == head) // 判断头结点是否为空 
	{
		cout << "当前节点不能为空"<< endl;

		return NULL;
	}

	stuLink *pre = head; // 前一个节点
	head = pre->next; 
	while(NULL != head)
	{
		if(head->data.num == num)
		{
			return pre;
		}
		pre = head;
		head = head->next;
	}

	return NULL;
}

stuLink * SinglyLinkedList::selectNowNodeByNum(stuLink* head, int num)
{
	if(NULL == head) // 判断头结点是否为空 
	{
		cout << "当前节点不能为空" << endl;

		return NULL;

	}

	while(NULL!= head->next)
	{
		head = head->next;

		if(head->data.num == num)
		{
			return head;
		}
	}
	
	return NULL;
}

stuLink * SinglyLinkedList::selectPreNodeByName(stuLink *head, char* name)
{
	if(NULL == head)
	{
		cout <<"头结点为空" << endl;

		return NULL;
	}

	stuLink *pre = head;
	head = head->next; // 当前节点

	while(NULL != head)
	{
		if(0 == strcmp(head->data.name,name))
		{
			return pre;
		
		}

		pre = head;
		head = head->next;
	}

	cout << "节点不存在"<< endl;
	
	return NULL;

}

stuLink* SinglyLinkedList::selectNowNodeByName(stuLink* head, char *name)
{
	if(NULL == head) // 判断头结点是否为空
	{
		cout << "当前节点"<< endl;

		return NULL;
	}

	while(NULL != head->next)
	{
		head = head->next;
		if(0 == strcmp(head->data.name,name))
		{
			return head;
		}
	}

	return NULL;
}

void SinglyLinkedList::deleteByNum(stuLink* head, int num)
{
	if(NULL == head)
	{
		return ;
	}

	stuLink *preNode = selectPreNodeByNum(head, num);
	stuLink *delNode = preNode->next;

	preNode->next = delNode->next;
	free(delNode);

	cout <<" 删除成功" << endl;
}

void SinglyLinkedList::deleteByName(stuLink*head, char *name)
{
	if(NULL == head)
	{
		return;
	}

	stuLink *pPreNode = selectPreNodeByName(head, name);

	stuLink *delNode = pPreNode->next;
	pPreNode->next = delNode->next;
	free(delNode);

	cout << "节点删除成功"<< endl;
}

void SinglyLinkedList::freeLink(stuLink* head)
{
	if(NULL == head)
	{
		return;
	}

	head = head->next;
	while(NULL != head)
	{
		stuLink * tempNode = head->next;
		free(head);
		head = tempNode;
	}
}

void SinglyLinkedList::printLink(stuLink*head)
{
	if(NULL == head)
	{
		cout << "头节点为空" << endl;
		return;
	}
	
	head = head->next;

	while(NULL != head)
	{
		const char* pszName = head->data.name;
		const char* pszClub = head->data.club;
		const char* pszNation = head->data.nation;
		int iPrice = head->data.price;
		int iNum = head->data.num;

		cout << "球员名"<<pszName << " ";
		cout << "球衣号" << iNum << " ";
		cout << "俱乐部" << pszClub << " ";
		cout << "国籍" << pszNation << " ";
		cout << "身价" << iPrice << endl;
		head = head->next;

	}
}

void SinglyLinkedList::save(stuLink * head)
{
	if(NULL == head)
	{
		cout <<"头节点为空" << endl;
		return;
	}

	FILE * fp = NULL; // 文件指针变量
	fp = fopen("FootballPlayer.txt","w+");
	if(NULL == fp)
	{
		cout << "保存失败"<< endl;
		return;
	}

	head = head->next;
	while(NULL != head)
	{
		fwrite(&head->data,sizeof(STDataInfo),1,fp);
		head = head->next;
	}

	cout <<"保存成功" << endl;
	
	fclose(fp);
}

void SinglyLinkedList::load(stuLink *head)
{
	if(NULL == head)
	{
		cout << "头节点为空"<< endl;

		return;
	}

	FILE * fp = NULL; // 文件指针变量
	fp = fopen("FootballPlayer.txt", "r+");
	if(NULL == fp)
	{
		system("echo > FootballPlayer.txt");
		
		return;
	}

	while(1)
	{
		STDataInfo stInfo;
		int iFlag = fread(&stInfo,sizeof(STDataInfo),1,fp);
		if(iFlag <1)
		{
			break;
		}

		insertAfter(head, stInfo);
	}

	cout << "加载成功"<< endl;

	fclose(fp);
}
/*
void SinglyLinkedList::TestLink()
{
	// 初始化头结点
	stuLink *head = NULL;
	head = (stuLink *)malloc(sizeof(stuLink));
	head->next = NULL;

	// 新增节点
	STStudent stKAKA;
	strcpy(stKAKA.name,"KAKA");
	stKAKA.num = 22;
	insertAfter(head,stKAKA);

	STStudent stINZAGHI;
	strcpy(stINZAGHI.name, "INZAGHI");
	stINZAGHI.num = 9;
	insertAfter(head, stINZAGHI);

	STStudent stPirlo;
	strcpy(stPirlo.name, "Pirlo");
	stPirlo.num = 21;
	insertAfter(head, stPirlo);

	STStudent stBuffon;
	strcpy(stBuffon.name, "Buffon");
	stBuffon.num = 1;
	insertAfter(head, stBuffon);

	int num = 21;
	struct stuLink* nodeNow = selectNowNodeByNum(head, num);

	char name[20];
	strcpy(name, nodeNow->data.name);
	//strcpy(name, pre->next->data.name);

	cout << "Current Name is " <<name << endl;
}
*/

//Queue.h
#pragma once
#include "SinglyLinkedList.h"
/*
	队列实现
*/
class Queue :public SinglyLinkedList 
{
public:
	Queue();

	~Queue();

public:

	// 初始化队列
	static void InitializeQueue(stuLink *pQueue);

	// 入队
	static void enQueue(stuLink* pQueue,STDataInfo pNode);

	// 出队
	static void* deQueue(stuLink* pQueue, STDataInfo& stData);

	// 遍历队列
	static void PrintQueue(stuLink* pQueue);

	// 队列测试方法
	static void TestQueue();
private:

};
//Queue.cpp
#include "Queue.h"

Queue::Queue()
{
}

Queue::~Queue()
{
}

void Queue::InitializeQueue(stuLink *pQueue)
{
	pQueue = (stuLink*)malloc(sizeof(stuLink));
	pQueue->next = NULL;
}

void Queue::enQueue(stuLink* pQueue, STDataInfo Node)
{
	SinglyLinkedList::insertAfter(pQueue,Node);
}

void*  Queue::deQueue(stuLink* pQueue, STDataInfo& stData)
{
 	if(NULL == pQueue)
 	{
 		return NULL;
 	}
 
 	if(NULL == pQueue->next)
 	{
 		return NULL;
 	}

	stData = pQueue->next->data; // 待返回数据
	
	stuLink* tempNode = pQueue; // 头节点

	stuLink *delNode = pQueue->next; // 待删除节点

	stuLink* nextNode = delNode->next; // 待删除节点的下一个


	tempNode->next = nextNode;
	
	free(delNode);

	delNode = NULL;

	return NULL;
}

void Queue::PrintQueue(stuLink* pQueue)
{
	if(NULL == pQueue->next)
	{
		return;
	}

	pQueue = pQueue->next;
	while(NULL != pQueue)
	{
		cout << "Name is "<< pQueue->data.name<< endl;
		pQueue = pQueue->next;
	}
}

// 队列测试函数
void Queue::TestQueue()
{
	//stuLink* pQueue = NULL;

//	InitializeQueue(pQueue);

	STDataInfo stKAKA;
	strcpy(stKAKA.name , "KAKA");
	strcpy(stKAKA.club, "MILAN");
	strcpy(stKAKA.nation, "BRAZIL");
	stKAKA.price = 7000;
	stKAKA.num = 22;

	STDataInfo stINZAGHI;
	strcpy(stINZAGHI.name, "INAZGHI");
	strcpy(stINZAGHI.club, "MILAN");
	strcpy(stINZAGHI.nation, "ITALIA");
	stINZAGHI.price = 7000;
	stINZAGHI.num = 9;


	STDataInfo stPiero;
	strcpy(stPiero.name, "Piero");
	strcpy(stPiero.club, "JUVENTUS");
	strcpy(stPiero.nation, "ITALIA");
	stPiero.price = 8000;
	stPiero.num = 10;

	stuLink* pQueue = NULL;//创建头节点

	pQueue = (stuLink*)malloc(sizeof(stuLink));//分配堆空间

	pQueue->next = NULL;//让head的下一个节点为空

	enQueue(pQueue, stKAKA);
	enQueue(pQueue, stINZAGHI);
	enQueue(pQueue, stPiero);

	STDataInfo Node1;

	Queue::deQueue(pQueue, Node1);
	cout <<"Node1 Name = " << Node1.name<< endl;
	cout << "Node1 Club = " << Node1.club << endl;

	STDataInfo Node2;
	Queue::deQueue(pQueue, Node2);
	cout << "Node2 Name = " << Node2.name << endl;
	cout << "Node2 Club = " << Node2.club << endl;


	STDataInfo Node3;
	Queue::deQueue(pQueue, Node3);
	cout << "Node3 Name = " << Node3.name << endl;
	cout << "Node3 Club = " << Node3.club << endl;

}
//main.cpp
#include<iostream>
using namespace std;
#include "Queue.h"
#include <windows.h>



int main()
{
	Queue::TestQueue();
	system("pause");

	return 0;
}