数据结构实验整理（一）

最新推荐文章于 2023-03-25 17:32:18 发布
最新推荐文章于 2023-03-25 17:32:18 发布
阅读量2k 收藏 41
点赞数 7
分类专栏： 模板 知识点整理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Annenlim/article/details/103260257
版权

文章目录

日常作业存档_(:з」∠)_

一.线性表的基本操作

(1) 实验目的
通过该实验，深入理解顺序表的逻辑结构、物理结构等概念，掌握顺序表基本操作的编程实现，注意顺序表插入、删除等操作过程中数据元素的移动现象，培养学生编写程序时，要考虑程序的强壮性，熟练掌握通过函数参数返回函数结果的办法。
(2) 实验内容
编程实现顺序表下教材第二章定义的线性表的基本操作，最好用菜单形式对应各个操作，使其编程一个完整的小软件。
(3) 参考界面
在这里插入图片描述
（3）验收/测试用例
通过菜单调用各个操作，测试点：

  • 没有初始化前进行其他操作，程序是否能控制住；
  • 初始化一个顺序表；
  • 插入数据(位置， 数据)，要测插入位置不合法的情况（0,1）、（2,1）(即是否在可插入的范围内），正确插入4个数据（1,2）、（1,1）、（3,3）；
  • 显示顺序表中的数据，屏幕输出1， 2， 3；
  • 判空，屏幕输出顺便表非空；
  • 顺便表长度，屏幕输出3；
  • 获取指定位置元素，要测指定位置在【1，3】范围之外的情况和之内的情况；
  • 定位，输入：4， 输出：不存在，输入2，输出位置为2；
  • 求直接前驱，要测求第一个元素的前驱、不存在顺序表中的元素的直接前驱，其他元素的直接前驱；
  • 求直接后继，要测最后一个元素的后继、不存在顺序表中的元素的直接后继，其他元素的直接后继；
  • 删除，要测位置在【1，3】范围之外的情况和之内的情况；
  • 清空操作后再测长度；
  • 销毁顺序表

实现代码

#include <stdio.h>
#include <stdlib.h>
#define LIST_INIT_SIZE 100 //初始分配量
#define LISTINCREMENT 10 //线性表存储空间分配量
typedef int ElemType;
typedef struct 
{
	ElemType *elem;
	int length;
	int listsize;
}SqList;
void InitList_Sq(SqList &L)//初始化 
{
	L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));
	if(!L.elem) 
	{
		printf("分配空间失败!\n");
		exit(1);
	}
	L.length = 0;
	L.listsize = LIST_INIT_SIZE;
	printf("创建成功！\n");

}	

void DestoryList(SqList &L)//销毁 
{
	if(L.elem)
	{
		delete L.elem;
		printf("销毁成功\n");
	}
	else
	printf("销毁失败\n");
}

void ClearList(SqList &L)//清空 
{
	if(L.length)
	{
		L.length = 0;
		printf("清空成功！\n");
	}
	else
	printf("无需清空。\n"); 
}

void IfEmpty(SqList &L)//判断是否为空 
{
	if(L.length)
	{
		printf("线性表非空！\n"); 
	}
	else
	printf("线性表为空。\n");
}

void GetLength(SqList &L)//取线性表长度 
{
	printf("线性表的长度为 %d \n",L.length); 
	
}

void GetElem(SqList &L,int i,int &e)//取值 第i位的数 为 e 
{
	if(i < 1||i > L.length)
	{
		printf("取值失败！\n");
	}
	else
	{
		e = L.elem[i-1];
		printf("第%d个元素为：%d\n",i,e);	
	}
}

void PriorElem(SqList &L,ElemType cur_e)//求某个元素对应的前驱 
/*输入直接是元素位置，判断有无前驱 有则直接输出elem[i-1]）*/
{
	int i = cur_e-1,pre;
	if(i == 0)
	printf("该元素没有前驱。\n");
	else if(i <= 0||i >= L.length)
	printf("该元素不存在。\n");
	else
	{
		pre = L.elem[i-1];
		printf("该元素的前驱为 %d\n",pre);
	 } 
}

void NextElem(SqList &L,ElemType cur_e)//求某个元素对应的后继 原理同上 
{
	int i = cur_e-1,next;
	if(i == L.length-1)
	 printf("该元素没有后继。\n");
	else if(i < 0||i > L.length-1)
	printf("该元素不存在。\n");
	else
	{
		next = L.elem[i+1];
		printf("该元素的后继为 %d \n",next);
	 } 
}


void ListInsert(SqList &L,int i,int e)//插入 i位置 数值e 
{
	if(i < 1 ||i > L.length+1)
	{
		printf("插入失败！\n");
	}
	else if(L.length == LIST_INIT_SIZE)
	{
		printf("插入失败！\n");
	}
	else
	{
		for(int j = L.length - 1;j >= i - 1;j--)
		{
			L.elem[j+1] = L.elem[j];
		}
		L.length++;
		L.elem[i-1] = e;
		printf("插入成功！\n");
	}
 } 
 
void ListDelete(SqList &L,int i)//删除指定位置元素 
{
	if(i < 1||i > L.length)
	{
		printf("删除失败！\n"); 
	}
	int j;
	for(j = i;j < L.length;j++)
	{
		L.elem[j-1] = L.elem[j];
	}
	--L.length;
	printf("删除成功！\n");
} 

void TraverseList(SqList L)//遍历输出（显示线性表） 
{
	int i;
	for(i=1;i<=L.length;i++)
	{
		printf("%d ",L.elem[i-1]);
	}
	printf("\n");
} 
int main()
{
	int n,i,e,cur_e;
	SqList L;
	L.elem = 0;
	printf("1----初始化一个线性表\n");
	printf("2----销毁线性表\n"); 
	printf("3----清空线性表\n"); 
	printf("4----判断线性表是否为空\n"); 
	printf("5----求线性表长度\n"); 
	printf("6----获取线性表指定位置元素\n"); 
	printf("7----求前驱\n"); 
	printf("8----求后继\n"); 
	printf("9----在线性表指定位置插入元素\n"); 
	printf("10----删除线性表指定位置元素\n"); 
	printf("11----显示线性表\n"); 
	printf("\t退出，输入一个负数！\n"); 
	printf("请输入操作代码：\n");  
	while(~scanf("%d",&n))
	{
		if(n < 0)
		{
			break;
		}
		if(n == 1)
		{
			InitList_Sq(L);
			
		}
		if(n == 2)
		{
			if(L.elem == 0)
			{
				printf("未进行初始化\n"); 
			}
			else
			{
				DestoryList(L);
				L.elem = 0;
			}
		
		}
		if(n == 3)
		{
			if(L.elem == 0)
			{
				printf("未进行初始化\n"); 
			}
			else
			{
				ClearList(L);
			}
		}
		if(n == 4)
		{
			if(L.elem == 0)
			{
				printf("未进行初始化\n"); 
			}
			else
			{
				IfEmpty(L);
			}
		}
		if(n == 5)
		{
			if(L.elem == 0)
			{
				printf("未进行初始化\n"); 
			}
			else
			{
				GetLength(L);
			}
		}
		if(n == 6)
		{
			if(L.elem == 0)
			{
				printf("未进行初始化\n"); 
			}
			else
			{
				printf("请输入需要获取的元素的位置：\n");
				scanf("%d",&i);
				GetElem(L,i,e);
			}
		}
		if(n == 7)
		{
			if(L.elem == 0)
			{
				printf("未进行初始化\n"); 
			}
			else
			{
				printf("请输入需要查找前驱的元素位置：\n");
				scanf("%d",&cur_e);
				PriorElem(L,cur_e);
			}
		}
		if(n == 8)
		{
			if(L.elem == 0)
			{
				printf("未进行初始化\n"); 
			}
			else
			{
				printf("请输入需要查找后继的元素位置：\n");
				scanf("%d",&cur_e);
				NextElem(L,cur_e);
			}
		}
		if(n == 9)
		{
			if(L.elem == 0)
				{
					printf("未进行初始化\n"); 
				}
				else
				{
					printf("请输入需要插入的元素的位置和值（输入格式：i,e）：\n");
					scanf("%d,%d",&i,&e);
					
					ListInsert(L,i,e); 
				}
			
		}
		if(n == 10)
		{
			if(L.elem == 0)
				{
					printf("未进行初始化\n"); 
				}
				else
				{
					printf("请输入需要删除的元素的位置：\n");
					scanf("%d",&i);
					ListDelete(L,i);
				}
		}
		if(n == 11)
		{
			if(L.elem == 0)
			{
				printf("未进行初始化\n"); 
			}
			else
			{
				TraverseList(L); 
			}
		}
	}
	return 0;
}

二.链表的基本操作

（1）实验目的
通过该实验，深入理解链表的逻辑结构、物理结构等概念，掌握链表基本操作的编程实现，熟练掌握C语言中指针的操作。和实验3对比，掌握线性结构两种不同存储方式的区别。
（2）实验内容
编程实现链表下教材第二章定义的线性表的基本操作，最好用菜单形式对应各个操作，使其编程一个完整的小软件。
（3）参考界面
在这里插入图片描述
（4）验收/测试用例
同实验一

实现代码

#include <stdio.h>
#include <stdlib.h>
void init()
{
	printf("可执行操作有：\n");
	for(int i = 0;i < 55;i++)
	printf("*");
	printf("\n");
	for(int i = 0;i < 15;i++)
	printf("*");
	printf("\t1.初始化或重置链表\t");
	for(int i = 0;i < 15;i++)
	printf("*");
	printf("\n");
	for(int i = 0;i < 15;i++)
	printf("*");
	printf("\t2.销毁链表\t\t");
	for(int i = 0;i < 15;i++)
	printf("*");
	printf("\n");
	for(int i = 0;i < 15;i++)
	printf("*");
	printf("\t3.链表中数据元素个数\t");
	for(int i = 0;i < 15;i++)
	printf("*");
	printf("\n");
	for(int i = 0;i < 15;i++)
	printf("*");
	printf("\t4.所指位序的元素值\t");
	for(int i = 0;i < 15;i++)
	printf("*");
	printf("\n");
	for(int i = 0;i < 15;i++)
	printf("*");
	printf("\t5.链表已存在元素的位序\t");
	for(int i = 0;i < 15;i++)
	printf("*");
	printf("\n");
	for(int i = 0;i < 15;i++)
	printf("*");
	printf("\t6.请输入元素，求直接前驱");
	for(int i = 0;i < 15;i++)
	printf("*");
	printf("\n");
	for(int i = 0;i < 15;i++)
	printf("*");
	printf("\t7.请输入元素，求直接后继");
	for(int i = 0;i < 15;i++)
	printf("*");
	printf("\n");
	for(int i = 0;i < 15;i++)
	printf("*"); 
	printf("\t8.在第i个位置插入元素\t");
	for(int i = 0;i < 15;i++)
	printf("*");
	printf("\n");
	for(int i = 0;i < 15;i++)
	printf("*");
	printf("\t9.删除第i个元素\t\t");
	for(int i = 0;i < 15;i++)
	printf("*");
	printf("\n");
	for(int i = 0;i < 15;i++)
	printf("*");
	printf("\t10.输出所输入的链表元素\t");
	for(int i = 0;i < 15;i++)
	printf("*");
	printf("\n");
	for(int i = 0;i < 15;i++)
	printf("*");
	printf("\t11.初始化并输入链表元素\t");
	for(int i = 0;i < 15;i++)
	printf("*");
	printf("\n");
	for(int i = 0;i < 15;i++)
	printf("*");
	printf("\t12.退出\t\t\t");
	for(int i = 0;i < 15;i++)
	printf("*");
	printf("\n");
	for(int i = 0;i < 55;i++)
	printf("*"); 
	printf("\n");
	printf("请输入你的选择：\n");
}

typedef struct LNode{
	int data;
	struct LNode *next;
}LNode,*LinkList;

void InitList(LinkList &L)//链表初始化 
{
	if(!(L == 0))
	{
		LinkList p,q;
		p = L->next;
		while(p)
		{
			q = p-> next;
			free(p);
			p = q;
		}
		L->next = NULL;
		printf("链表已重置\n");
	}
	else
	{
		L = (LNode*)malloc(sizeof(LNode));
		L->next = NULL;
		printf("初始化成功！\n");
	}
}

void DestoryList(LinkList *L)//链表销毁 
{
	LinkList q,p = *L;//p指向L链表头结点 
	if(p == 0)
	printf("链表未初始化！\n");
	else
	{
		while(p != 0)
		{
			q = p -> next;
			delete p;
			p = q;
		}
		*L = NULL;//头结点指针清空 
		L = 0;
		printf("链表销毁成功！\n");
	}
	
}

void CountNode(LinkList &L)//计算节点个数 
{
	if(L == 0)
	printf("链表未初始化！\n");
	else
	{
		int n = 0;
		LNode *p;
		p = L->next;
		while(p)
		{
			p = p->next;
			++n;
		}
		if(n)
		printf("节点有 %d 个\n",n);
		else
		printf("链表为空！\n");
	}
}
void CreatList(LinkList &L,int n)//初始化并创建单链表 向链表里插入n个数 
{
	if(!(L == 0))
	{
		printf("链表已初始化，无需重复操作！\n"); 
	}
	else
	{
		L = (LNode*)malloc(sizeof(LNode));
		L->next = NULL;
		printf("初始化成功！\n");
	}
	LNode *p,*tail;
	tail = L;//尾插法 
	printf("请输入元素："); 
	for(int i = 0;i < n;i++)
	{
		p = (LinkList)malloc(sizeof(LNode));
		scanf("%d",&(p->data));
		p->next = tail->next;
		tail->next= p;
		tail = p;
	}
}
void GetElem(LinkList L,int i,int &e)//所指位序的元素值 
{
	LNode *p;
	p = L->next;
	int j = 1;
	while(p && j < i)
	{
		p = p->next;
		++j;
	}
	if(!p || j > i)
	printf("获取失败！\n");
	else
	{
		e = p->data;
		printf("获取的值为:%d\n",e); 
	}
}

void GetPosition(LinkList L,int i)//所指元素值的位序（第一次出现的地方） 
{
	LNode *p;
	p = L->next;
	int j = 0,flag = 0;
	while(p)
	{
		while(p->data != i)
		{
			p = p->next;
			if(p == NULL)
			{
				flag = 1;
				break;
			}
			j++;
		}
		break;
	}
	if(flag == 0)
	printf("所指元素值的位序为：%d\n",j);
	else
	printf("未找到该元素值。\n"); 
}

void ElemPrimer(LinkList L,int e)//求前驱
{
	LinkList p = L->next,q = p->next;
	while(q)
	{
		if(e == q -> data)
		{
			if(p)
			printf("所求前驱为：%d\n",p->data);
			else
			printf("该节点无前驱\n");
			return;
		}
		else
		{
			p = q;
		}
		q = p->next;
	}
}
void ElemNext(LinkList L,int e)//求后继
{
	int i = 0;
	LinkList p = L->next,q = NULL;
	while(p)
	{
		if(e == p->data)
		{
			q = p->next;
			if(p)
			printf("所求后继的值为：%d\n",q->data);
			else
			printf("该节点无后继\n");
			return;
		}
		else
		p = p->next;
		i++;
	}
}

void ElemInsert(LinkList L,int i,int &e)//插入数值
{
	LinkList p,s;
	p = L->next;
	int j = 1;
	while(p && j < i)
	{
		p = p->next;
		j++;
	}
	if(!p || j > i)
	{
		printf("插入失败！\n");
	}
	s = (LinkList)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	printf("插入完成！\n");
}


void LinkListDelete(LinkList &L,int i)//删除指定位置数值
{
	int j = 0,e;
	LNode *p,*q;
	p = L;
	while((p->next)&&(j < i-1))
	{
		p = p->next;
		j++;
	}
	if(!(p->next) || (j > i-1))
	printf("删除位置错误！\n");
	else
	{
		q = p->next;
		p -> next = q -> next;
		e = q -> data;
		free(q);
		printf("删除成功！\n");
	}	
	
} 
void TraveList(LinkList L)//遍历输出
{
	LNode *p;
	p = L->next;
	while(p!=NULL)
	{
		printf("%d ",p->data);
		p = p->next;
	}
	printf("\n");
}
int main()
{
	int n,t,e;
	LinkList L;
	L = 0;
	init();
	while(~scanf("%d",&n))
	{
		if(n == 1)
		{
			InitList(L);	
		}
		if(n == 2)
		{
			DestoryList(&L);
		}
		if(n == 3)
		{
			CountNode(L);
		} 
		if(n == 4)
		{
			if(L == 0)
			printf("链表未初始化！\n");
			else
			{
				printf("请输入需要获取元素的位置：");
				scanf("%d",&t);
				GetElem(L,t,e);
			}
		}
		if(n == 5)
		{
			if(L == 0)
			printf("链表未初始化！\n");
			else
			{
				printf("请输入需要查找的元素的值：");
				scanf("%d",&t);
				GetPosition(L,t);
			}
		}
		if(n == 6)
		{
			int e;
			if(L == 0)
			printf("链表未初始化！\n");
			else
			{
				printf("请输入需要求前驱的元素值：");
				scanf("%d",&e);
				ElemPrimer(L,e);
			}
		}
		if(n == 7)
		{
			int e;
			if(L == 0)
			printf("链表未初始化！\n");
			else
			{
				printf("请输入需要求后继的元素值：");
				scanf("%d",&e);
				ElemNext(L,e);
			}
		}
		if(n == 8)
		{
			int i,e;
			if(L == 0)
			printf("链表未初始化！\n");
			else
			{
				printf("请输入需要插入的位置和数字(一行，用空格隔开):");
				scanf("%d %d",&i,&e);
				ElemInsert(L,i,e);
			}	
		}
		if(n == 9)
		{
			int i;
			if(L == 0)
			printf("链表未初始化！\n");
			else
			{
				printf("请输入需要删除元素的位序：");
				scanf("%d",&i);
				LinkListDelete(L,i);
			}
		}
		if(n == 10)
		{
			if(L == 0)
			printf("链表未初始化！\n");
			else
			{
				TraveList(L);
			}
		}
		if(n == 11)
		{
			printf("请输入需要输入元素的个数：");
			scanf("%d",&t);
			CreatList(L,t);
			printf("输入完成！\n");
		}
		if(n == 12)
		{
			printf("程序结束！\n");
			break;
		}
	}
	return 0;
}

三.顺序栈的基本操作

（1）实验目的
通过该实验，让学生掌握栈的相关基本概念，认识栈是插入和删除集中在一端进行的线性结构，掌握栈的“先入后出”操作特点。栈在进行各类操作时，栈底指针固定不动，掌握栈空、栈满的判断条件。
（2）实验内容
用顺序存储结构，实现教材定义的栈的基本操作，提供数制转换功能，将输入的十进制整数转换成二进制。
（3）参考界面
在这里插入图片描述
（4）验收/测试用例
通过菜单调用各个操作，测试点：

  • 没有初始化前进行其他操作，程序是否能控制住；
  • 初始化一个栈；
  • 判栈空，屏幕显示栈为空；
  • 3个数入栈， 1、2、3；
  • 栈长度，屏幕输出3；
  • 取栈顶元素，再判栈空，然后再判栈长度。让学生知道取栈顶元素不改变栈中的内容，栈顶指针不发生改变；
  • 出栈，再判栈长度；
  • 销毁栈，再做其他操作，判断程序是否能控制

代码实现

#include <stdio.h>
#include <stdlib.h>
void i1();
void init();
const int Stacksize = 100,addsize = 10;
typedef struct{
	int *top;
	int *base;
	int stacksize;
	int length;
}SqStack;
int InitStack(SqStack &S)//1初始化 
{
	S.base = (int *)malloc(Stacksize * sizeof(int));
	if(!S.base)
	{
		printf("栈初始化失败！\n");
		return 0;
	}
	S.top = S.base;
	S.stacksize = Stacksize;
	S.length = 0;
	printf("栈初始化成功！\n");
}
int DestoryStack(SqStack &S)//2销毁 
{
	if(S.base)
	{
		free(S.base);
		S.base = NULL;
		S.top = NULL;
		S.stacksize = 0;
		printf("销毁成功！\n");
		return 1;
	}
}
int ClearStack(SqStack &S)//3置空 
{
	if(S.base)
	{
		S.top = S.base;
		printf("栈置空成功！\n");
	}
	else
	printf("栈已经为空\n");
	
 } 
int Empty(SqStack &S)//4 判空 
{
	if(S.top == S.base)
	return 1;
	else
	return 0;
}
int Length(SqStack S)//5长度 
{
	if(S.top == S.base)
	{
		printf("栈为空！\n");
	}
	else
	printf("栈的长度为：%d\n",S.length);
}
int GetTop(SqStack &S)//6取栈顶元素 
{
	if(S.top == S.base)
	{
		return 0;
	}
	else
	{
		return *(S.top - 1);
	}
}
int Push(SqStack &S,int e)//7元素压入栈 
{
	if(S.top - S.base >= S.stacksize)
	{
		S.base = (int*)realloc(S.base,(S.stacksize + addsize)*sizeof(int));
		if(!S.base)
		{
			printf("分配空间失败！\n");
			return 0;
		}
		S.top = S.stacksize + S.base;
		S.stacksize += addsize;
	}
	*S.top++ = e;
	S.length++;
	printf("插入成功！\n");
} 
int DeleteStack(SqStack &S)//8删除栈顶元素并返回值 
{
	if(S.base == S.top)
	{
		printf("栈为空！\n");
		return 0;
	}
	printf("删除的栈顶元素为：%d\n",*(S.top-1));
	free(S.top-1);
	S.top--;
	S.stacksize--;
	printf("删除成功！\n");
}
int Pop(SqStack S)//9弹出栈内元素 
{
	if(S.base == S.top)
	{
		printf("栈为空！\n");
		return 0;
	}
	int *p = S.base;
	printf("栈内元素值为:\n");
	while(p != S.top)
	{
		printf("%d ",*p);
		p++;
	}
}
void Initscanf(SqStack &S,int e)//10创建并输出 
{
	int k;
	if(S.base)
	printf("栈已进行了初始化！\n");
	else
	InitStack(S);
	printf("请输入%d个入栈元素:",e);
	for(int i = 0;i < e;i++)
	{
		scanf("%d",&k);
		Push(S,k);
	}
	printf("\n");
}
int main()
{
	int n,e;
	SqStack S;
	S.base = 0; 
	init();
	while(scanf("%d",&n)!=EOF)
	{
		if(!S.base && n != 1 && n != 10 && n != 11)
		{
			printf("栈未进行初始化！\n");
			continue;
		} 
		if(S.base && n == 1)
		{
			printf("栈已进行了初始化！\n");
			continue;
		}
		if(n == 1)
		{
			InitStack(S);
		}
		if(n == 2)
		{
			DestoryStack(S);
		}
		if(n == 3)
		{
			ClearStack(S);
		}
		if(n == 4)
		{
			if(Empty(S))
			printf("栈为空！\n");
			else
			printf("栈为非空！\n");
		}
		if(n == 5)
		{
			 Length(S);
		}
		if(n == 6)
		{
			if(!GetTop(S))
			printf("栈为空！\n");
			else
			printf("栈顶元素为:%d\n",GetTop(S));
		}
		if(n == 7)
		{
			printf("请输入需要压入栈的元素值：");
			scanf("%d",&e);
			Push(S,e); 
		}
		if(n == 8)
		{
			DeleteStack(S); 
		}
		if(n == 9)
		{
			Pop(S);
			printf("\n");
		}
		if(n == 10)
		{
			printf("请输入需要入栈的元素个数：");
			scanf("%d",&e);
			Initscanf(S,e);
		}
		if(n == 11)
		{
			printf("程序结束！");
			break;
		}
	}
	
	
}
void i1()
{
	for(int i = 0;i < 20;i++)
	printf("*");
}
void init()
{
	for(int i = 0;i < 76;i++)
	printf("*");
	printf("\n");
	i1();
	printf(" 1.初始化为空栈\t\t\t");
	i1();
	printf("\n");
	i1();
	printf(" 2.销毁栈\t\t\t\t");
	i1();
	printf("\n");
	i1();
	printf(" 3.将栈置空\t\t\t\t");
	i1();
	printf("\n");
	i1();
	printf(" 4.判断栈是否为空栈\t\t\t");
	i1();
	printf("\n");
	i1();
	printf(" 5.返回栈的长度\t\t\t");
	i1();
	printf("\n");
	i1();
	printf(" 6.求栈顶元素\t\t\t");
	i1();
	printf("\n");
	i1();
	printf(" 7.插入元素,并使其成为栈顶元素\t");
	i1();
	printf("\n");
	i1();
	printf(" 8.删除栈顶元素，并返回其值\t\t");
	i1();
	printf("\n");
	i1();
	printf(" 9.输出栈内元素\t\t\t");
	i1();
	printf("\n");
	i1();
	printf(" 10.创建并输出入栈元素\t\t");
	i1();
	printf("\n");
	i1();
	printf(" 11.退出\t\t\t\t");
	i1();
	printf("\n");
	for(int i = 0;i < 76;i++)
	printf("*");
	printf("\n");
	printf("请输入选择:");
}

四.链队列的基本操作

（1）实验目的
通过该实验，使学生理解链队列的构造特点并灵活应用，掌握链队基本操作的编程实现，认识栈是在一端进行插入，在另一端进行删除集中操作的线性结构，掌握队列的“先入先出”操作特点，知道判断队列空和满的条件，进一步熟悉C语言中指针操作。
（2）实验内容
用链式存储结构，实现教材定义的队列的基本操作。
（3）参考界面在这里插入图片描述
（4）验收/测试用例
通过菜单调用各个操作，测试点：

  • 没有初始化前进行其他操作，程序是否能控制住；
  • 初始化一个队列；
  • 判队列空，屏幕显示队列为空；
  • 4个数入队， 1、2、3、5；
  • 栈长度，屏幕输出4；
  • 取队头元素，再判栈空，然后再判栈长度。让学生知道取队头元素不改变队列中的内容，队头指针不发生改变；
  • 出队，再判栈长度；
  • 销毁队，再做其他操作，判断程序是否能控制

代码实现

#include <stdio.h>
#include <stdlib.h> 
void init(); 
typedef struct QNode{
	int data;
	QNode *next;
}QNode,*QPtr;
typedef struct{
	QPtr front;
	QPtr rear;
	int length;
}LinkQ;
int e;
int InitQueue(LinkQ &Q)//1初始化 
{
	if(Q.front)
	{
		printf("已进行过初始化！\n");
	}
	else
	{
		Q.front = Q.rear = new QNode;
		Q.front -> next = NULL;
		Q.length = 0;
		printf("初始化成功！\n");
	}
}
int DestoryQ(LinkQ &Q)//2队列销毁 
{
	if(!Q.front)
	{
		printf("队列未进行初始化！\n");
	}
	else
	{
		while(Q.front)
		{
			Q.rear = Q.front->next;
			delete(Q.front);
			Q.front = Q.rear;
		}
		Q.front = 0;
		printf("队列销毁成功！\n");
	}
}  
int ClearQ(LinkQ &Q)//3置空 
{
	if(!Q.front)
	{
		printf("队列未进行初始化！\n");
	}
	else
	{
		if(Q.front == Q.rear) 
		printf("队列已经为空！\n");
		else{
			Q.front = Q.rear;
			Q.length = 0; 
			printf("队列置空成功！\n");
		}
	}
 } 
int EmptyQ(LinkQ &Q)//4判空 
{
	if(!Q.front)
	{
		printf("队列未进行初始化！\n");
	}
	else
	{
		if(Q.front == Q.rear)
		{
			printf("队列为空！\n");
		}
		else
		printf("队列为非空!\n");
	}
} 
int LengthQ(LinkQ &Q)//5元素个数 
{
	if(!Q.front)
	{
		printf("队列未进行初始化！\n");
	}
	else{
		printf("队列内元素的个数是:%d\n",Q.length);
	}
} 
int GetTop(LinkQ Q)//6队头元素 
{
	QNode *p;
	if(!Q.front)
	{
		printf("队列未进行初始化！\n");
	}
	else{
		if(Q.front == Q.rear)
		{
			printf("队列为空！\n");
		}
		else
		{
			p = Q.front->next;
			printf("队头元素为：%d\n",p->data);
			
		}
	}
}
int EnQ(LinkQ &Q)//7插入队头元素 
{
	if(!Q.front)
	{
		printf("队列未进行初始化！\n");
	}
	else
	{
		printf("请输入需要插入的元素值:");
		scanf("%d",&e);
		QNode *p = new QNode;
		p->data = e;
		p->next = NULL;
		Q.rear->next = p;
		Q.rear = p;
		Q.length++;
		printf("插入成功！\n");
	}
}
int DeleteQ(LinkQ &Q)//8删除队头元素 
{
	QNode *p;
	if(!Q.front)
	{
		printf("队列未进行初始化！\n");
	}
	else
	{
		if(Q.front == Q.rear)
		{
			printf("队列为空！\n");
		}
		else
		{
			p = Q.front->next;
			Q.front->next = p->next;//如果是最后一个 则为NULL 
			if(Q.rear == p)
			Q.rear = Q.front;
			free(p);
			printf("删除成功！\n");
		}
	}
}
int InitCreateQ(LinkQ &Q)//9初始化并创建 
{
	int k;
	InitQueue(Q);
	printf("请输入入队元素的个数：");
	scanf("%d",&e);
	printf("请输入%d个入队元素\n"); 
	for(int i = 0;i <e;i++)
	{
		scanf("%d",&k);
		QNode *p = new QNode;
		p->data = k;
		p->next = NULL;
		Q.rear->next = p;
		Q.rear = p;
		Q.length++;
		printf("插入成功！\n");
	}
}
int PrintQ(LinkQ Q)//10输出队列元素 
{
	QNode *p;
	if(!Q.front)
	{
		printf("队列未进行初始化！\n");
	}
	else
	{
		if(Q.front == Q.rear)
		{
			printf("队列为空！\n");
		}
		else
		{
			p = Q.front->next;
			while(p != NULL)
			{
				printf("%d ",p->data);
				p = p->next;
			}
			printf("\n");
		}
	}
}

int main()
{
	int n;
	init();
	LinkQ Q;
	Q.front = 0;
	while(~scanf("%d",&n))
	{
		if(n == 1)
		{
			InitQueue(Q);
		}
		if(n == 2)
		{
			DestoryQ(Q);
		}
		if(n == 3)
		{
			ClearQ(Q);
		}
		if(n == 4)
		{
			EmptyQ(Q);
		}
		if(n == 5)
		{
			LengthQ(Q);
		}
		if(n == 6)
		{
			GetTop(Q);
		}
		if(n == 7)
		{
			EnQ(Q);
		}
		if(n == 8)
		{
			DeleteQ(Q); 
		}
		if(n == 9)
		{
			InitCreateQ(Q); 
		}
		if(n == 10)
		{
			PrintQ(Q);
		}
		if(n == 11)
		{
			break;
		}
	}
	
	
	return 0;
}
void i1()
{
	for(int i = 0;i < 20;i++)
	printf("*");
}
void init()
{
	for(int i = 0;i < 76;i++)
	printf("*");
	printf("\n");
	i1();
	printf(" 1.初始化队列\t\t\t");
	i1();
	printf("\n");
	i1();
	printf(" 2.销毁队列\t\t\t\t");
	i1();
	printf("\n");
	i1();
	printf(" 3.清空队列\t\t\t\t");
	i1();
	printf("\n");
	i1();
	printf(" 4.判断队列是否为空\t\t\t");
	i1();
	printf("\n");
	i1();
	printf(" 5.返回队列中元素个数\t\t");
	i1();
	printf("\n");
	i1();
	printf(" 6.返回队列队头元素\t\t\t");
	i1();
	printf("\n");
	i1();
	printf(" 7.插入新的队尾元素\t\t\t");
	i1();
	printf("\n");
	i1();
	printf(" 8.删除队头元素\t\t\t");
	i1();
	printf("\n");
	i1();
	printf(" 9.初始化并创建队列\t\t\t");
	i1();
	printf("\n");
	i1();
	printf(" 10.输出队列元素\t\t\t");
	i1();
	printf("\n");
	i1();
	printf(" 11.退出\t\t\t\t");
	i1();
	printf("\n");
	for(int i = 0;i < 76;i++)
	printf("*");
	printf("\n");
	printf("请输入选择:");
}
西北工业大学数据结构实验报告
07-12
包含11次数据结构实验报告以及配套代码，结构完整，符合要求，实验成绩97分。 啰嗦几句： 更加建议大家自己写，我这个更多的是自己的资源存档 有问题的话私信，看到会回复 关于代码，因为当时比较仓促，还没有进行...
南邮数据结构实验一.doc
最新发布
10-12
实验内容涉及数据结构中的线性表和多项式算术运算，要求学生通过编程实践掌握线性表的顺序存储与链式存储表示方法，顺序表的基本操作，以及如何利用顺序表和链表解决应用问题。 #### 线性表基本操作 实验内容包括...
数据结构实验5 链队列的基本操作
Far_Rainbow的博客
10-31 2151
姓名：Far_Rainbow 学号： 202505000X 专业： 软件工程 年级：2020级 实验名称：实验5 链队列的基本操作 实验内容： （1）实验目的 通过该实验，使学生理解链队列的构造特点并灵活应用，掌握链队基本操作的编程实现，认识栈是在一端进行插入，在另一端进行删除集中操作的线性结构，掌握队列的“先入先出”操作特点，知道判断队列空和满的条件，进一步熟悉C++中指针操作。 （2）实验内容 用链式存储结构，实现教材定义的队列的基本操作。 3）参考界面 菜单中包括以下功能： 1.初始化队列，2.销毁队
数据结构实验5_C语言_链队列的基本操作、入队、出队、获取队头元素等
xiaosi的博客
10-30 8725
实验5、链队列的基本操作 （1）实验目的 通过该实验，使学生理解链队列的构造特点并灵活应用，掌握链队基本操作的编程实现，认识栈是在一端进行插入，在另一端进行删除集中操作的线性结构，掌握队列的“先入先出”操作特点，知道判断队列空和满的条件，进一步熟悉C语言中指针操作。 （2）实验内容 用链式存储结构，实现教材定义的队列的基本操作。 （3）参考界面 菜单中包括以下功能： 初始化队列， 销毁队列， 清空队列， 队列判空， 求队列长度， 获取队头元素， 插入一个 元素， 删除一个元素， 输出所有元素。 要求：自
数据结构实验六——链队列
weixin_34106122的博客
01-21 236
#include <stdio.h> #include <stdlib.h> int flag=0; typedef struct Qnode { char data; struct Qnode *next; }Qnode,*QnodePtr; typedef struct LinkQueue { QnodePtr front; Qn...
C语言实现链队列的初始化&进队&出队
weixin_30888413的博客
11-28 1164
Code /*链表实现队列的一系列操作*/ #include<stdio.h> #include<stdlib.h> #define OK 1 #define ERROR 0 typedef struct node { int data; //数据域 st...
数据结构 实验5、链队列的基本操作
爱吃棉花糖~
04-23 1594
数据结构 实验5、链队列的基本操作 （1）实验目的 通过该实验，使学生理解链队列的构造特点并灵活应用，掌握链队基本操作的编程实现，认识栈是在一端进行插入，在另一端进行删除集中操作的线性结构，掌握队列的“先入先出”操作特点，知道判断队列空和满的条件，进一步熟悉C语言中指针操作。 （2）实验内容 用链式存储结构，实现教材定义的队列的基本操作。 （3）参考界面 （4）验收/测试用例 通过菜单调用各个操作，测试点：  没有初始化前进行其他操作，程序是否能控制住；  初始化一个队列；  判队列空，屏幕显示队列
2023年整理数据结构实验八：快速排序(12页).doc
03-07
根据给定文件的信息，我们可以详细地探讨快速排序这一重要的数据结构与算法知识点。 ### 快速排序概述 快速排序是一种非常高效的排序算法，其基本思想是分治法（Divide and Conquer）。它通过一趟排序将待排序的...
华科数据结构实验报告
12-16
在“华科数据结构实验报告”中，我们可以期待深入理解这门学科的关键概念和算法。实验通常包括实际编程任务，旨在帮助学生掌握抽象数据类型（ADT）、数据结构的操作以及它们在解决问题时的应用。 实验报告可能涵盖...
数据结构 学生成绩统计 实验报告附源代码.doc
01-18
《数据结构 学生成绩统计 实验报告》 在计算机科学领域，数据结构是至关重要的概念，它涉及如何高效地组织和存储数据以便于访问和处理。本实验报告旨在通过学生成绩统计系统的设计和实现，让学生掌握线性结构的逻辑...
数据结构（c语言版）-------链队列的初始化、入队、出队、队列的遍历等操作
weixin_43870670的博客
03-17 3517
链队列的基本操作 文章目录链队列的基本操作链队列结构初始化入队出队获取队头元素队列的长度获取队尾元素遍历队列测试代码 链队列结构 typedef struct node { int data; struct node *next; }Node; typedef struct queue { Node *front; Node *rear; }Queue;//链队列的结构 初始化 bool...
#数据结构与算法分析实验报告C语言版（ 链队列的基本操作实现）（1-4）
NightRav5n的博客
11-16 1458
实验要求： （1）建立链队列并实现判空、入队、出队、取队头元素等基本操作； （2）在主函数中测试链队列的基本操作，要求输入一个序列入队，然后再输出队列的内容。 实现提示： 首先定义链队列的数据类型，然后定义链队列的创建、判空、入队、出队、取队头元素等基本操作，最后在主函数中输入一个序列入队，然后再输出队列的内容。 ————————我是分割线—————————————————— 源代码： #include<stdio.h> #include<malloc.h> //链队列的定义： ty
队列的初始化、进队，出队操作(C语言实现)
weixin_46626833的博客
05-28 4701
//头文件和机构体 #include <stdio.h> #include <stdlib.h> typedef int elemtype; //链表节点 typedef struct LinkQueuenode { elemtype data; struct LinkQueuenode *next; }LinkQueue; //指向链表的头结点的节点 typedef struct LQueue { LinkQueue *front; LinkQue
实验6、链队列的基本操作（简单易懂，代码可以直接运行）
于笨笨的博客
09-24 924
链队列的基本操作（简单易懂，代码可以直接运行） （1）实验目的 通过该实验，使学生理解链队列的构造特点并灵活应用，掌握链队基本操作的编程实现，认识栈是在一端进行插入，在另一端进行删除集中操作的线性结构，掌握队列的“先入先出”操作特点，知道判断队列空和满的条件，进一步熟悉C语言中指针操作。 （2）实验内容 用链式存储结构，实现教材定义的队列的基本操作。 （3）参考界面 （4）验收/测试用例 通过菜单调用各个操作，测试点：  没有初始化前进行其他操作，程序是否能控制住；  初始化一个队列；  判队列空，
链队列操作实验报告，附完整代码，运行结果截图（链队列的出队入队）
weixin_47758084的博客
03-25 1229
上机实验时一边调试程序一边将实验报告上关于程序调试和运行结果的信息填写到实验报告上，实验完成时上交实验报告。（4）编写主函数对上面各个函数实现调用，记录并分析程序的运行结果。（4）编写主函数对上面各个函数实现调用，记录并分析程序的运行结果。通过上机实验，加深对队列的链式存储结构知识的掌握。（1）完成环境设置及链队列的结构体定义。（1）完成环境设置及链队列的结构体定义。（1）掌握队列的链式存储结构及其编程。（3）编写入队函数、出队函数。（3）编写入队函数、出队函数。（2）编写初始化函数。
实现链队列的初始化、入队和出队操作
热门推荐
ancientear的博客
05-04 1万+
编程实现链队列的初始化、入队和出队操作。 #include&amp;lt;stdio.h&amp;gt; #include&amp;lt;iostream&amp;gt; #include&amp;lt;stdlib.h&amp;gt; #define OK 1 #define OVERFLOW 2 #define ERROR -1 using namespace std; typedef int QElemType; typedef i
C语言数据结构链队列（创建、入队、出队、取对头元素、遍历）
Algorithm_Soul
06-13 8651
/* *链队列的相关操作 *创建一个rear和front指针的结构体 *创建一个链表的结构体 *初始化时rear和front指向head指针 *采用尾插法创建链表 *操作 （初始化、创建、入队 、出队、取对头元素、遍历） */ #include<stdio.h> #include<stdlib.h> #include<time.h> #include<st...
链队列实验
CHENCHWT的博客
04-25 719
#ifndef Linkqueue_H#define Linkqueue_Htemplate&lt;class datatype&gt;struct Node{datatype data;Node&lt;datatype&gt;*next;};template&lt;class datatype&gt;class Linkqueue {public:Linkqueue();~Linkqueue()...
C语言版：链队的建立和基本操作
m0_53318344的博客
07-01 1171
数据结构C语言版：链队的建立和初始化，入队，出队，判断是否为空，取队头元素 文章目录前言一、基本思路二、实现过程1.结点生成2.队头队尾指针设置3.入队和出队三、代码实现总结 前言 注意：数据结构学习一定需要结合图形来理解，尤其是先理解图的做法，然后在编写代码，思考了之后在动手，这样效率会更好。不要急于动手，冷静下来思考， 想这一步我该如何用我学习的知识解决。 提示：以下是本篇文章正文内容，下面案例可供参考 一、基本思路 链队的基本思路：第一步，链~~想到结点， 结点是不是需要指针和数据域。
数据结构实验代码整理与拷贝数分析
资源摘要信息: "数据结构实验代码拷贝数.rar" ...总结而言，"数据结构实验代码拷贝数.rar" 这一资源提供了学习数据结构的编程实践机会，涵盖了从环境准备到问题解决的全过程，是提高数据结构理解和编程能力的重要资料。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值