基础数据结构(一）线性表的实现(链表、栈、队列、字符串)

汪呈祥

已于 2023-04-30 10:48:02 修改

阅读量57

点赞数 1

分类专栏：基础数据结构的实现文章标签：数据结构 c++

于 2023-04-28 20:22:42 首次发布

本文链接：https://blog.csdn.net/rrrrrrrrtgghyhbh/article/details/130434529

版权

基础数据结构的实现专栏收录该内容

3 篇文章 1 订阅

订阅专栏

1、单链表

#include <iostream>
typedef int ElemType;
typedef struct Node
{
	ElemType data;
	Node * next;
} *LinkList;

int InitList_L(LinkList & L);
int DestroyList_L(LinkList & L);
int ClearList_L(LinkList & L);
int LengthList_L(LinkList L);
int IsEmptyList_L(LinkList L);
void ShowList_L(LinkList L);
int GetElem_L(LinkList L, int i, ElemType & e);
int FindElem_L(LinkList L, ElemType e, int & loc);
Node * FindElem_L(LinkList L, ElemType e);
int InsertElem_L(LinkList & L, int i, ElemType e);
int DeleteElem_L(LinkList & L, int i, ElemType & e);
void Push_front(LinkList & L, ElemType e);
void CreatList_L(LinkList & L, int n);
void Push_back(LinkList & L, ElemType e);
void CreatList_LR(LinkList & L, int n);

int main()
{
	//测试
	LinkList L;//实例化出1个链表(头指针----指向链结点)
	InitList_L(L);//初始化1个链表(生成1个头结点)
	std::cout << "1 = NULL: " << IsEmptyList_L(L) << std::endl;
	std::cout << "LenthList_L: " << LengthList_L(L) << std::endl;
	ShowList_L(L);
	std::cout << "Add 3 Nodes:\n";
	//在堆区开辟3个结点
	Node *n1 = new Node;
	Node *n2 = new Node;
	Node *n3 = new Node;
	n1->data = 111;
	n1->next = n2;
	n2->data = 222;
	n2->next = n3;
	n3->data = 333;
	n3->next = nullptr;
	//链表串起来
	L->next = n1;
	std::cout << "1 = NULL: " << IsEmptyList_L(L) << std::endl;
	std::cout << "LenthList_L: " << LengthList_L(L) << std::endl;
	ShowList_L(L);
	std::cout << "Test InsertElem_L:\n";
	ElemType e = 654;
	InsertElem_L(L, 2, e);
	std::cout << "1 = NULL: " << IsEmptyList_L(L) << std::endl;
	std::cout << "LenthList_L: " << LengthList_L(L) << std::endl;
	ShowList_L(L);
	/*std::cout << "Test DeleteElem_L:\n";
	ElemType ee;
	DeleteElem_L(L, 5, ee);
	std::cout << "1 = NULL: " << IsEmptyList_L(L) << std::endl;
	std::cout << "LenthList_L: " << LengthList_L(L) << std::endl;
	ShowList_L(L);
	std::cout << "ee = " << ee << std::endl;*/
	ElemType ee = 7789955;
	std::cout << "Test Push_front func:\n";
	Push_front(L, ee);
	std::cout << "1 = NULL: " << IsEmptyList_L(L) << std::endl;
	std::cout << "LenthList_L: " << LengthList_L(L) << std::endl;
	ShowList_L(L);
	std::cout << "Test CreatList_L func:\n";
	//CreatList_L(L, 5);
	//std::cout << "1 = NULL: " << IsEmptyList_L(L) << std::endl;
	//std::cout << "LenthList_L: " << LengthList_L(L) << std::endl;
	//ShowList_L(L);
	//ElemType ee = 666, eee = 8789;;
	//std::cout << "Test Push_back func:\n";
	//Push_back(L, ee);
	//std::cout << "1 = NULL: " << IsEmptyList_L(L) << std::endl;
	//std::cout << "LenthList_L: " << LengthList_L(L) << std::endl;
	//ShowList_L(L);
	//Push_back(L, eee);
	//std::cout << "1 = NULL: " << IsEmptyList_L(L) << std::endl;
	//std::cout << "LenthList_L: " << LengthList_L(L) << std::endl;
	//ShowList_L(L);
	CreatList_LR(L, 5);
	std::cout << "1 = NULL: " << IsEmptyList_L(L) << std::endl;
	std::cout << "LenthList_L: " << LengthList_L(L) << std::endl;
	ShowList_L(L);

	system("pause");
	return 0;
}

//初始化1个空表
int InitList_L(LinkList & L)
{
	//1、实例化出1个头结点
	//2、修改头指针指向头结点
	//3、头结点的指针域指向NULL
	L = new Node;
	L->data = 0;
	L->next = nullptr;

	return 1;
}
//释放1个链表
int DestroyList_L(LinkList & L)
{
	//1、从头结点开始每次只delete1个结点
	//2、更新当前谁是第1个结点, 释放上一个结点
	Node * p = L;
	while (p)
	{
		L = L->next;
		delete p;
		p = L;
	}

	return 1;
}
//清空1个链表
int ClearList_L(LinkList & L)
{
	Node *p, *q;
	p = q = L->next;//从首元结点进入循环
	while (p) //通过p释放链结点
	{
		q = q->next;//q指向下一个结点
		delete p;//释放原结点
		p = q;//更新p指向(进入下一轮循环的条件)
	}
	L->next = nullptr;

	return 1;
}
//计算链表的长度
int LengthList_L(LinkList L)
{
	Node * p = L->next;//从首元结点进循环
	int len = 0;
	while (p)
	{
		len++;
		p = p->next;
	}

	return len;
}
//判断链表是否为空
int IsEmptyList_L(LinkList L)
{
	if (L->next)
		return 0;
	return 1;
}
//显示链表信息
void ShowList_L(LinkList L)
{
	Node * p = L;//从头结点开始输出
	while (p)
	{
		std::cout << "Current node address: " << p << " data: " << p->data << " next node address: " << p->next << std::endl;
		p = p->next;//p指向下一个结点(更新循环)
	}
	return;
}
//获取链表第i个位置上的元素
int GetElem_L(LinkList L, int i, ElemType & e)
{
	if (i < 1)
		return -2;
	else
	{
		Node * p = L->next;//从首元结点开始进循环
		int index = 1;
		while (index < i && p)
		{
			p = p->next;
			index++;
		}
		if (index < i)
			return -1;
		if (!p)
			return 0;
		e = p->data;
	}

	return 1;
}
//查找链表中是否存在某元素并返回编号
int FindElem_L(LinkList L, ElemType e, int & loc)
{
	Node * p = L->next;//从首元结点开始查找
	loc = 1;
	while (p && p->data != e)
	{
		p = p->next;
		loc++;
	}
	if (!p)
		return -1;

	return loc;
}
//按值查找元素, 返回地址
Node * FindElem_L(LinkList L, ElemType e)
{
	Node * p = L->next;//从首元结点开始查找
	while (p && p->data != e)
		p = p->next;
	return p;
}
//在链表的第i个位置插入元素
int InsertElem_L(LinkList & L, int i, ElemType e)
{
	if (i < 1 || i > LengthList_L(L) + 1)
		return -1;
	Node * temp = new Node;
	temp->data = e;//新建1个链结点
	//找到第i-1个结点和第i个结点的位置
	Node * p, *q;//2指针1个遍历链表, 1个记录第i个结点的位置
	p = L;//从链头结点开始遍历
	int index = 0;
	while (p && index < i - 1)
	{
		p = p->next;
		index++;
	}
	//出循环时p指向第i-1个结点, p->next指向第i个结点
	q = p->next;
	p->next = temp;
	temp->next = q;

	return 1;
}
//删除链表指定的第i个位置
int DeleteElem_L(LinkList & L, int i, ElemType & e)
{
	if (!L->next)
		return -2;
	if (i <1 || i > LengthList_L(L))
		return -1;
	Node * p = L;//从头结点开始
	int index = 0;
	while (index < i - 1)
	{
		p = p->next;
		index++;
	}
	//出循环时p --- i-1 p->next --- i
	Node * q = p->next;
	//修改i-1 指向 i+1
	p->next = q->next;
	//保留第i个结点的元素
	e = q->data;
	//删除第i个结点
	delete q;
	return 0;
}
//头插法
void Push_front(LinkList & L, ElemType e)
{
	Node * p = new Node;
	p->data = e;//在堆区新建1个结点
	p->next = L->next;//新结点直接指向链表原来的第1个位置
	//修改头指针的指针域
	L->next = p;
	return;
}
//头插法新建链表
void CreatList_L(LinkList & L, int n)
{
	L = new Node;
	L->data = 0;//记录表长
	L->next = nullptr;//初始化1个链表(新建1个头结点)
	for (int i = n; i > 0; i--)
	{
		Node * tmp = new Node;
		tmp->next = L->next;//直接让新结点指向链表的原第1个位置
		std::cout << "Enter the Elemnts(e, d, c, b, a): ";
		std::cin >> tmp->data;
		//修改头指针的指针域
		L->next = tmp;
		L->data++;
	}
}
//尾插法
void Push_back(LinkList & L, ElemType e)
{
	//新建1个结点
	Node * tmp = new Node;
	tmp->data = e;
	tmp->next = nullptr;//新结点直接指向nullptr
	//找到链表的最后1个结点
	Node * p = L;//从头指针开始遍历链表
	while (p->next)
		p = p->next; 
	//出循环时p指向链表的最后1个结点, 修改其指针域
	p->next = tmp;
	return;
}

void CreatList_LR(LinkList & L, int n)
{
	L = new Node;
	L->data = 0;//记录表长
	L->next = nullptr;
	Node * p;//开始遍历
	for (int i = 0; i < n; i++)
	{
		Node * tmp = new Node;
		std::cout << "Enter Elemnt(a, b, c, d, e): ";
		std::cin >> tmp->data;
		tmp->next = nullptr;
		//找到链表的最后1个位置
		p = L;//从链表头结点开始遍历
		while (p->next)
			p = p->next;//结束循环时p指向最后1个结点
		//修改最后1个结点的指针域
		p->next = tmp;
		L->data++;
	}
	return;
}

2、双向链表

#include <iostream>
typedef int ElemType;
//双向链表
typedef struct DuNode
{
	ElemType data;
	DuNode * next;
	DuNode * prior;
} *DuLinkList;

//初始化双向链表//空表
void InitList_L(DuLinkList & L);
//求链表表长
int LengthList_L(DuLinkList &L);
//显示链表所有信息
void ShowList_L(DuLinkList L);
//查找元素, 返回下标
int FindElem_L(DuLinkList L, ElemType e, int & loc);
//获取第i个位置上的元素
int GetElem_L(DuLinkList L, int i, ElemType & e);
//在第i个位置上插入新元素
int InsertElem_L(DuLinkList & L, int i, ElemType e);
//删除第i个位置上的元素
int DeleteElem_L(DuLinkList & L, int i, ElemType & e);
//释放双向链表
int DestroyList_L(DuLinkList & L);
//清空链表
int ClearList_L(DuLinkList & L);

int main()
{
	DuLinkList L;//实例化出1个双向链表(头指针唯一标识1个链表)
	InitList_L(L);//堆区新建1个头结点(头结点的prior和next均置nullptr)
	DuNode * n1 = new DuNode;
	DuNode * n2 = new DuNode;
	DuNode * n3 = new DuNode;
	//串起来
	L->next = n1;
	n1->data = 111;
	n1->next = n2;
	n2->data = 222;
	n2->next = n3;
	n3->data = 333;
	n3->next = nullptr;
	//再串另外1个方向
	n3->prior = n2;
	n2->prior = n1;
	n1->prior = L;
	std::cout << "Length: " << LengthList_L(L) << std::endl;
	ShowList_L(L);
	ElemType e = 67895;
	std::cout << InsertElem_L(L, 4, e) << "\n";
	std::cout << "Length: " << LengthList_L(L) << std::endl;
	ShowList_L(L);
	
	//DestroyList_L(L);
	std::cout << ClearList_L(L) << "\n";
	std::cout << "Length: " << LengthList_L(L) << std::endl;
	ShowList_L(L);

	system("pause");
	return 0;
}

//初始化双向链表//空表
void InitList_L(DuLinkList & L)
{
	//在堆区新建1个头结点
	L = new DuNode;
	//next 和 prior均置空
	L->next = L->prior = nullptr;
}
//求链表表长
int LengthList_L(DuLinkList &L)
{
	//选择一个方向进行遍历, 从头结点开始遍历
	DuNode * p = L;
	int index = 0;//头结点的data域用来保存链表长度
	while (p->next)
	{
		p = p->next;
		index++;
	}
	
	return index;
}
//显示链表所有信息
void ShowList_L(DuLinkList L)
{
	//选择一条链遍历所有结点
	DuNode * p = L;//从头结点开始遍历
	while (p)
	{
		std::cout << "Prior DuNode address: " << p->prior << " Current DuNode address: "
			      << p << " data: " << p->data << " Next DuNode address: " << p->next << '\n';
		p = p->next;
	}
}
//查找元素, 返回下标
int FindElem_L(DuLinkList L, ElemType e, int & loc)
{
	//选择一个方向从首元结点开始进循环遍历
	DuNode * p = L->next;
	int index = 1;
	while (p)
	{
		if (p->data == e)
		{
			loc = index;
			return index;
		}
		p = p->next;
		index++;
	}
	
	loc = -1;
	return -1;
}
//获取第i个位置上的元素
int GetElem_L(DuLinkList L, int i, ElemType & e)
{
	if (i < 1 || i > LengthList_L(L) || !L->next)
		return -1;
	else
	{
		DuNode * p = L->next;
		int index = 1;
		while (index < i)
		{
			p = p->next;
			index++;
		}
		e = p->data;
	}
	return 0;
}
//在第i个位置上插入新元素
int InsertElem_L(DuLinkList & L, int i, ElemType e)
{
	if (i < 1 || i > LengthList_L(L) + 1)
		return -1;
	DuNode * tmp = new DuNode;
	tmp->data = e;//新建1个结点
	//找到第i-1和第i个结点
	DuNode * p = L;
	int index = 0;
	while (index < i-1)
	{
		p = p->next;
		index++;
	}//出循环时, p指向i-1结点
	if (index == LengthList_L(L))
	{
		p->next = tmp;
		tmp->next = nullptr;
		tmp->prior = p;

		return 0;
	}
	//DuNode * q = p->next;//记录第i个结点
	//修改i-1 和 i的指针域
	/*p->next = tmp;
	tmp->next = q;
	q->prior = tmp;
	tmp->prior = p;*/
	tmp->next = p->next;
	tmp->prior = p;
	p->next->prior = tmp;
	p->next = tmp;

	return 1;
}
//删除第i个位置上的元素
int DeleteElem_L(DuLinkList & L, int i, ElemType & e)
{
	if (i < 1 || i > LengthList_L(L) || !L->next)
		return -1;
	DuNode * p = L;//从头结点开始遍历
	int index = 0;
	while (index < i)
	{
		p = p->next;
		index++;
	}
	//结束循环时p i p->next i+1 p->prior i-1
	e = p->data;
	//判断p是否为尾元
	if (!p->next)
	{
		
		p->prior->next = nullptr;
		delete p;
		return 0;
	}
	//修改i-1结点的后继指针域
	p->prior->next = p->next;//p->next没被修改, 一直指向i-1结点
	//修改i+1结点的前驱指针域
	p->next->prior = p->prior;//p->prior没被修改, 一直指向i+1结点
	//释放i结点
	delete p;
	return 1;
}
//释放双向链表
int DestroyList_L(DuLinkList & L)
{
	if (!L->next)
		return -1;
	DuNode * p = L;//用来遍历链表
	DuNode * tmp;//用来释放链表结点
	while (p)
	{
		tmp = p;//记下当前结点位置
		p = p->next;//更新到下一节点
		delete tmp;//释放当前结点
	}
	return 0;
}
//清空链表
int ClearList_L(DuLinkList & L)
{
	if (!L->next)
		return -1;
	DuNode * p = L->next;//用来遍历链表
	DuNode * tmp;//用来释放链表结点
	while (p)
	{
		tmp = p;//记下当前结点位置
		p = p->next;//更新到下一节点
		delete tmp;//释放当前结点
	}
	L->next = nullptr;
	return 0;
}

3、顺序栈

#include <iostream>
#define MAXSIZE 100
typedef int ElemType;
typedef struct
{
	//ElemType * data;//创建动态数组
	int stacksize;//栈的最大容量
	ElemType * base;//栈底指针指向第一个元素----堆区开辟内存也是返回第一个元素的首地址
	ElemType * top;
} Stack;
//初始化成一个空栈
int InitStack(Stack & S);
//判断是否为空栈
int IsEmptyStack(Stack S);
//求栈长度
int LengthStack(Stack S);
//清空栈
int ClearStack(Stack & S);
//销毁栈
void DestroyStack(Stack & S);
//入栈
int Push(Stack & S, ElemType e);
//出栈
int Pop(Stack & S, ElemType & e);
//显示栈信息
void ShowStack(Stack S);

int main()
{
	Stack S1;
	InitStack(S1);
	std::cout << "----Test----\n";
	std::cout << "0 = Empty: " << IsEmptyStack(S1) << " Length: " << LengthStack(S1) << std::endl;
	ShowStack(S1);
	//入栈
	Push(S1, 112);
	Push(S1, 345);
	Push(S1, 7512);
	std::cout << "0 = Empty: " << IsEmptyStack(S1) << " Length: " << LengthStack(S1) << std::endl;
	ShowStack(S1);
	//出栈
	ElemType e;
	Pop(S1, e);
	std::cout << "e = " << e << std::endl;
	std::cout << "0 = Empty: " << IsEmptyStack(S1) << " Length: " << LengthStack(S1) << std::endl;
	ShowStack(S1);
	//清空栈
	ClearStack(S1);
	std::cout << "0 = Empty: " << IsEmptyStack(S1) << " Length: " << LengthStack(S1) << std::endl;
	ShowStack(S1);
	//销毁栈
	DestroyStack(S1);
	std::cout << "0 = Empty: " << IsEmptyStack(S1) << " Length: " << LengthStack(S1) << std::endl;
	ShowStack(S1);

	return 0;
}
//初始化成一个空栈
int InitStack(Stack & S)
{
	//在堆区开辟内存
	S.base = new ElemType[MAXSIZE];
	S.stacksize = MAXSIZE;//栈的最大容量
	S.top = S.base;//栈顶指针=栈底指针  空栈
	if (!S.base)
		return -1;
	return 0;
}
//判断是否为空栈
int IsEmptyStack(Stack S)
{
	if (S.top == S.base)
		return 1;
	return 0;
}
//求栈长度
int LengthStack(Stack S)
{
	return (S.top - S.base) / sizeof(ElemType);
}
//清空栈
int ClearStack(Stack & S)
{
	//前提: 栈存在, 开辟堆区成功---返回堆区首元素地址----失败nullptr
	if (S.base)
		S.top = S.base;//重置为空栈
	return 0;
}
//销毁栈
void DestroyStack(Stack & S)
{
	if (!S.base) //前提是栈已经存在
	{
		//释放堆区内存
		delete S.base;
		S.stacksize = 0;//栈容量置0---堆区已经释放
		S.base = S.top = nullptr;
	}
	return;
}
//入栈
int Push(Stack & S, ElemType e)
{
	if (S.top - S.base == S.stacksize * sizeof(ElemType))
		return -1;
	*S.top++ = e;
	return 0;
}
//出栈
int Pop(Stack & S, ElemType & e)
{
	if (S.top == S.base) //空栈不能再出栈
		return -1;
	e = *(--S.top);
	return 0;
}
//显示栈信息
void ShowStack(Stack S)
{
	
	while (S.base != S.top)
	{
		std::cout << *S.base << '\t';
		S.base++;
	}
	std::cout << std::endl;
}

4、链栈

#include <iostream>
typedef int ElemType;
typedef struct Node
{
	ElemType data;
	Node * next;
} *LinkStack;
//初始化1个链栈
void InitStack(LinkStack & S);
//入栈
void Push(LinkStack & S, ElemType e);
//出栈
int Pop(LinkStack & S, ElemType & e);
//取栈顶元素
int GetElem(LinkStack S, ElemType & e);
//遍历栈元素
void ShowStack(LinkStack S);

int main()
{
	LinkStack S1;
	InitStack(S1);
	std::cout << "---Test---\n";
	ShowStack(S1);
	std::cout << "Push Test\n";
	Push(S1, 111);
	Push(S1, 222);
	Push(S1, 333);
	ShowStack(S1);
	std::cout << "Pop Test\n";
	ElemType e;
	Pop(S1, e);
	std::cout << "e = " << e << "\n";
	ShowStack(S1);
	GetElem(S1, e);
	std::cout << "e = " << e << "\n";

	return 0;
}
//初始化1个链栈
void InitStack(LinkStack & S)
{
	S = nullptr;
}
//入栈
void Push(LinkStack & S, ElemType e)
{
	Node * tmp = new Node;
	tmp->data = e;
	//在头指针和首元间插入新结点
	tmp->next = S;
	S = tmp;
	return;
}
//出栈
int Pop(LinkStack & S, ElemType & e)
{
	//判断栈是否为空
	if (!S)
		return 0;
	Node * tmp = S;//记录当前栈尾结点位置n
	e = tmp->data;//保存n结点元素
	S = S->next;//修改栈指针指向下一个结点n-1
	delete tmp;//释放原n结点
	return 1;
}
//取栈顶元素
int GetElem(LinkStack S, ElemType & e)
{
	//空栈没有栈顶元素
	if (!S)
		return -1;
	e = S->data;
	return 0;
}
//遍历栈元素
void ShowStack(LinkStack S)
{
	Node * p = S;//从栈顶开始遍历
	while (p)
	{
		std::cout << p << " " << p->data << "\n";
		p = p->next;
	}
}

5、队列-顺序存储

#include <iostream>
typedef int ElemType;
#define MAXQSIZE 5
typedef struct
{
	ElemType * base;//堆区开辟内存
	int front;//标记队头的位置
	int rear;//标记队尾的下一个位置
} SQueue;
//假想成首尾相接---循环队列
//初始化1个空队列
void InitSQueue(SQueue & SQ);
//入队(从队尾插入元素)
int EnSQueue(SQueue & SQ, ElemType e);
//出队(从队头删除元素--逻辑上访问不到--并不整体平移数组)
int DeSQueue(SQueue & SQ, ElemType & e);
//显示队列信息
void ShowSQueue(SQueue & SQ);
//求队列长度
int LengthSQueue(SQueue SQ);


int main()
{
	SQueue Q1;
	InitSQueue(Q1);
	ShowSQueue(Q1);
	std::cout << "Length : " << LengthSQueue(Q1) << std::endl;
	std::cout << "插入5个元素:\n";
	for (int i = 0; i < 5; i++)
		EnSQueue(Q1, i + 5);
	ShowSQueue(Q1);
	std::cout << "Length : " << LengthSQueue(Q1) << std::endl;
	std::cout << "删除1个元素:\n";
	ElemType e;
	DeSQueue(Q1, e);
	std::cout << "e = " << e << std::endl;
	ShowSQueue(Q1);
	std::cout << "Length : " << LengthSQueue(Q1) << std::endl;
	std::cout << "---Test---\n";
	EnSQueue(Q1, 66);
	ShowSQueue(Q1);
	std::cout << "Length : " << LengthSQueue(Q1) << std::endl;
	std::cout << "---Test---\n";
	EnSQueue(Q1, 77);
	ShowSQueue(Q1);
	std::cout << "Length : " << LengthSQueue(Q1) << std::endl;
	return 0;
}
//初始化1个空队列
void InitSQueue(SQueue & SQ)
{
	//在堆区开辟内存但不放元素
	SQ.base = new ElemType[MAXQSIZE];
	SQ.front = SQ.rear = 0;//空队列
}
//入队(从队尾插入元素)
int EnSQueue(SQueue & SQ, ElemType e)
{
	//先判断是否队满
	//采用少用1个空间的办法区分循环队列的 队空和队满 front == rear
	if ((SQ.rear + 1) % MAXQSIZE == SQ.front)
		return -1;
	SQ.base[SQ.rear] = e;
	SQ.rear = (SQ.rear + 1) % MAXQSIZE;
	return 0;
}
//出队(从队头删除元素--逻辑上访问不到--并不整体平移数组)
int DeSQueue(SQueue & SQ, ElemType & e)
{
	//先判断是否队空
	if (SQ.rear == SQ.front)
		return -1;
	e = SQ.base[SQ.front];
	SQ.front = SQ.front + 1 % MAXQSIZE;
	return 0;
}
//显示队列信息
void ShowSQueue(SQueue & SQ)
{
	for (int i = SQ.front; i != SQ.rear; i = (i + 1) % MAXQSIZE)
		std::cout << "Address: " << &SQ.base[i] << " value: " << SQ.base[i] << "\n";
}
//求队列长度
int LengthSQueue(SQueue SQ)
{
	int len = 0;
	for (int i = SQ.front; i != SQ.rear; i = (i + 1) % MAXQSIZE)
		len++;
	return len;
}

6、队列-链式存储

#include <iostream>
typedef int ElemType;
//链表结点
typedef struct Node
{
	ElemType data;//数据域
	Node  * next;//指针域
} *Queueptr;
//链队
typedef struct
{
	Queueptr front;//头指针---指向头结点 front->next---指向队头
	Queueptr rear;//尾指针---指向队尾
} LinkQueue;
//初始化1个链队
void InitQueue(LinkQueue & Q);
//销毁1个队列
void DestroyQueue(LinkQueue & Q);
//入队
void EnQueue(LinkQueue & Q, ElemType e);
//出队
int DeQueue(LinkQueue & Q, ElemType & e);
//获取队头元素
int GetHead(LinkQueue Q, ElemType & e);
//显示队列信息
void Show(LinkQueue Q);


int main()
{
	LinkQueue Q1;//实例化出1个链队
	InitQueue(Q1);
	Show(Q1);
	std::cout << "---Test---\n";
	Node * n1 = new Node;
	n1->data = 111;
	Node * n2 = new Node;
	n2->data = 222;
	Node * n3 = new Node;
	n3->data = 333;
	n1->next = n2;
	n2->next = n3;
	n3->next = nullptr;
	//串起来
	Q1.front->next = n1;
	Q1.rear = n3;
	Show(Q1);
	std::cout << "--Test--\n";
	EnQueue(Q1, 555);
	Show(Q1);
	std::cout << "--Test--\n";
	ElemType e;
	DeQueue(Q1, e);
	std::cout << "e = " << e << std::endl;
	Show(Q1);
	ElemType ee;
	GetHead(Q1, ee);
	std::cout << "ee = " << ee << std::endl;
	std::cout << "--END--\n";
	DestroyQueue(Q1);
	system("pause");
	Show(Q1);
	//std::cout << Q1.front->data << " " << Q1.front->next << " " << Q1.rear->data << "\n";

	return 0;
}
//初始化1个链队
void InitQueue(LinkQueue & Q)
{
	//在堆区开辟1个头结点
	Q.front = new Node;
	Q.front->next = nullptr;
	Q.rear = Q.front;//初始化为1个空队列
}
//销毁1个队列
void DestroyQueue(LinkQueue & Q)
{
	//从头结点开始挨个释放
	//可以只创建1个结点指针
	//Node * p = Q.front;//用来遍历链表
	//Node * q;//用来挨个释放链结点
	//while (p)
	//{
	//	q = p;
	//	p = p->next;
	//	delete q;
	//}
	Node * p;
	while (Q.front)
	{
		p = Q.front;
		Q.front = Q.front->next;
		delete p;
	}
}
//入队---从队尾入
void EnQueue(LinkQueue & Q, ElemType e)
{
	Node * tmp = new Node;
	tmp->data = e;
	tmp->next = nullptr;//在堆区开辟新结点
	//找到队尾加入链队
	Q.rear->next = tmp;
	//更新队尾
	Q.rear = tmp;
}
//出队
int DeQueue(LinkQueue & Q, ElemType & e)
{
	//判断是否为空队
	if (Q.front == Q.rear)
		return -1;
	//找到队头元素
	Node * tmp = Q.front->next;//队头首元
	e = tmp->data;//保存数据
	Q.front->next = tmp->next;
	//如果只有1个元素, 队尾指针也得修改，因为出队后变为空队
	if (Q.rear == tmp)
		Q.rear = Q.front;//空队都指向头结点
	delete tmp;

	return 0;
}
//获取队头元素
int GetHead(LinkQueue Q, ElemType & e)
{
	//判断是否为空
	if (Q.rear == Q.front)
		return -1;
	e = Q.front->next->data;
	return 0;
}
//显示队列信息
void Show(LinkQueue Q)
{
	Node * p = Q.front;
	while (p)
	{
		std::cout << "Address: " << p << " data: " << p->data << " Next Address: " << p->next << "\n";
		p = p->next;
	}
}

7、字符串+BF模式匹配算法

#include <iostream>

#define MAXSIZE 500
typedef struct
{
	char * ch;
	int len;
} SString;
//初始化1个字符串
void InitSString(SString SS);
//给1个字符串赋值
int AssignSString(SString SS);
//BF算法
int Find(SString T, SString S);

int main()
{



	system("pause");

	return 0;
}

void InitSString(SString SS)
{
	SS.ch = new char[MAXSIZE];
	SS.ch[0] = '\0';
	SS.len = 0;
}

int AssignSString(SString SS)
{
	int num;
	std::cout << "Enter Len of SString:";
	std::cin >> num;
	for (int i = 0; i < num; i++)
		std::cin >> SS.ch[i];
	SS.len = num;
	
	return 0;
}
//BF算法
int Find(SString T, SString S)
{
	int i = 1, j = 1;
	while (true)
	{
		if (T.ch[j] == S.ch[i])
		{
			if (j == T.len)
				return i;
		}
		else
		{
			if (i == S.len)
				return 0;
			//回溯
			i = i - j + 2;
			j = 1;
		}
	}

}