数据结构教程实验二链表基本操作的实现

已于 2023-11-21 15:59:09 修改
阅读量1.9k 收藏 24
点赞数 4
分类专栏： 数据结构实验报告 文章标签： 数据结构 链表
于 2023-06-16 18:18:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Annzz123/article/details/131251862
版权
该实验涵盖了链表的基本操作，包括初始化单链表，使用尾插法插入元素，输出链表，计算长度，判断是否为空，获取指定位置元素，按位置插入和删除元素。此外，还实现了链表的就地逆置和元素递增排序。最后，扩展到循环链表和双向循环链表，展示其插入和删除操作。
摘要由CSDN通过智能技术生成

实验二  链表基本操作的实现

一、实验目的

1 . 掌握线性表的链式存储结构及基本操作，深入了解链表的基本特性，以便在实际问题背景下灵活运用它们。

2.深入理解和灵活掌握链表的插入、删除等操作。

二、实验环境

1.硬件：每个学生需配备计算机一台。

2.软件：Windows操作系统+Visual C++。

三、实验要求

1.将建表、遍历、插入、删除分别定义为4个子函数，通过主函数实现对上述子函数的调用。

2.输入数据：链表中每个结点为结构体类型，数据域（data）设定为整型。

四、实验内容

1.实现单链表各种基本运算

在实现单链表各种基本运算的基础上，设计主程序，完成如下功能：

（1）初始化单链表h。

（2）依次采用尾插法插入12，25，7，9，10共5个元素。

（3）输出单链表h。

（4）输出单链表h的长度。

（5）判断单链表h是否为空。

（6）输出单链表h第4个元素。

（7）输出元素5的位置。

（8）在第4个元素的位置上插入元素100。

（9）输出单链表h。

（10）删除单链表h的第3个元素。

（11）输出单链表h。

（12）释放单链表h。

实现程序：

#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct LNode{
	ElemType data;
	struct LNode *next;
}LinkNode;
//初始化单链表
void InitList(LinkNode *&L)
{
	L=(LinkNode *)malloc(sizeof(LinkNode));
	L->next=NULL;
}
//头插法建立单链表
void CreateListF(LinkNode *&L,ElemType a[],int n)
{
	LinkNode *s;
	L=(LinkNode *)malloc(sizeof(LinkNode));
	L->next=NULL;
	for(int i=0;i<n;i++)
	{
		s=(LinkNode *)malloc(sizeof(LinkNode));
		s->data=a[i];
		s->next=L->next;
		L->next=s;
	}
}
//尾插法建立单链表
void CreateListR(LinkNode *&L,ElemType a[],int n)
{
	LinkNode *s,*r;
	L=(LinkNode *)malloc(sizeof(LinkNode));
	L->next=NULL;
	r=L;
	for(int i=0;i<n;i++)
	{
		s=(LinkNode *)malloc(sizeof(LinkNode));
		s->data=a[i];
		r->next=s;
		r=s;
	}
	r->next=NULL;
}
//单链表的销毁
void DestryList(LinkNode *&L)
{
	LinkNode *pre=L,*p=pre->next;
	while(p!=NULL)
	{
		free(pre);
		pre=p;
		p=pre->next;
	}
	free(pre);
}
//判断单链表是否为空
bool ListEmpty(LinkNode *L)
{
	return(L->next==NULL);
}
//求单链表的表长
int ListLength(LinkNode *L)
{
	int i=0;
	LinkNode *p=L;
	while(p->next!=NULL)
	{
		i++;
		p=p->next;
	}
	return(i);
}
//输出单链表
void DispList(LinkNode *L)
{
	LinkNode *p=L->next;
	while(p!=NULL)
	{
		printf("%3d",p->data);
		p=p->next;
	}
	printf("\n");
}
//求单链表中某个数据元素值
bool GetElem(LinkNode *L,int i,ElemType &e)
{
	int j=0;
	LinkNode *p=L;
	if(i<0)return false;
	while(j<i && p!=NULL)
	{
		j++;
		p=p->next;
	}
	if(p==NULL)
		return false;
	else
	{
		e=p->data;
		return true;
	}
}
//按元素值查找
int LocateElem(LinkNode *L,ElemType e)
{
	int i=1;
	LinkNode *p=L->next;
	while (p!=NULL && p->data!=e)
	{
		p=p->next;
		i++;
	}
	if(p==NULL)
		return(0);
	else
		return(i);
}
//插入数据元素
bool ListInsert(LinkNode *&L,int i,ElemType e)
{
	int j=0;
	LinkNode *p=L,*s;
	if(i<=0) return false;
	while(j<i-1 && p!=NULL)
	{
		j++;
		p=p->next;
	}
	if(p==NULL)
		return false;
	else
	{
		s=(LinkNode *)malloc(sizeof(LinkNode));
		s->data=e;
		s->next=p->next;
		p->next=s;
		return true;
	}
}
//删除数据元素
bool ListDelete(LinkNode *&L,int i,ElemType e)
{
	int j=0;
	LinkNode *p=L,*q;
	if(i<=0) return false;
	while(j<i-1 && p!=NULL)
	{
		j++;
		p=p->next;
	}
	if(p==NULL)
		return false;
	else
	{
		q=p->next;
		if(q==NULL)
			return false;
		e = q->data;
		p->next=q->next;
		free(q);
		return true;
	}
}
//设计主函数
void main()
{
	LinkNode *h;
	ElemType e;
	printf("单链表的基本运算如下；\n");
	printf("(1)初始化单链表h\n");
	InitList(h);
	printf("(2)依次采用尾插法插入12，25，7，9，10共5个元素\n");
	int i,y;
	char s;
	//循环输入，遇到回车停止输入
	for(i=1;i<51&&s!='\n';i++){
			scanf("%d",&y);
			s=getchar();
			ListInsert(h,i,y);
	}
	printf("(3)输出单链表h:");
	DispList(h);
	printf("(4)输出单链表h的长度:%d\n",ListLength(h));
	printf("(5)判断单链表h是否为空");
	printf("%s\t\n",(ListEmpty(h)?"空":"非空"));
	GetElem(h,4,e);
	printf("(6)输出单链表h第4个元素%d\n",e);
	printf("(7)输出元素5的位置:%d\n",LocateElem(h,5));
	printf("(8)在第4个元素的位置上插入元素100\n");
	ListInsert(h,4,100);
	printf("(9)输出单链表h");
	DispList(h);
	printf("(10)删除单链表h的第3个元素\n");
	ListDelete(h,3,e);
	printf("(11)输出单链表h");
	DispList(h);
	printf("(12)释放单链表h");
	DestryList(h);
}

运行结果：

测试结果：

通过！

2.单链表的应用

（1）设计算法，实现单链表h就地逆置操作。

实现程序：

#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct LNode{
	ElemType data;
	struct LNode *next;
}LinkNode;
//初始化单链表
void InitList(LinkNode *&L)
{
	L=(LinkNode *)malloc(sizeof(LinkNode));
	L->next=NULL;
}
//头插法建立单链表
void CreateListF(LinkNode *&L,ElemType a[],int n)
{
	LinkNode *s;
	L=(LinkNode *)malloc(sizeof(LinkNode));
	L->next=NULL;
	for(int i=0;i<n;i++)
	{
		s=(LinkNode *)malloc(sizeof(LinkNode));
		s->data=a[i];
		s->next=L->next;
		L->next=s;
	}
}
//插入数据元素
bool ListInsert(LinkNode *&L,int i,ElemType e)
{
	int j=0;
	LinkNode *p=L,*s;
	if(i<=0) return false;
	while(j<i-1 && p!=NULL)
	{
		j++;
		p=p->next;
	}
	if(p==NULL)
		return false;
	else
	{
		s=(LinkNode *)malloc(sizeof(LinkNode));
		s->data=e;
		s->next=p->next;
		p->next=s;
		return true;
	}
}
//尾插法建立单链表
void CreateListR(LinkNode *&L,ElemType a[],int n)
{
	LinkNode *s,*r;
	L=(LinkNode *)malloc(sizeof(LinkNode));
	L->next=NULL;
	r=L;
	for(int i=0;i<n;i++)
	{
		s=(LinkNode *)malloc(sizeof(LinkNode));
		s->data=a[i];
		r->next=s;
		r=s;
	}
	r->next=NULL;
}
//单链表的销毁
void DestryList(LinkNode *&L)
{
	LinkNode *pre=L,*p=pre->next;
	while(p!=NULL)
	{
		free(pre);
		pre=p;
		p=pre->next;
	}
	free(pre);
}
//输出单链表
void DispList(LinkNode *L)
{
	LinkNode *p=L->next;
	while(p!=NULL)
	{
		printf("%3d",p->data);
		p=p->next;
	}
	printf("\n");
}
//就地逆置函数
void listReserve(LinkNode *L)
{
    if (L == NULL ||L->next == NULL) 
       return;
	
    LinkNode* p = L->next->next;           
    L->next->next = NULL;					
	
	while (p != NULL)                    
    {
        LinkNode* q = p->next;
        p->next = L->next;
        L->next = p;                   
        p = q;                           
    }
}
void main()
{
   LinkNode *h;
   InitList(h);
	printf("依次采用尾插法插入12，25，7，9，10共5个元素\n");
	int i,y;
	char s;
	//循环输入，遇到回车停止输入
	for(i=1;i<51&&s!='\n';i++){
			scanf("%d",&y);
			s=getchar();
			ListInsert(h,i,y);
	}
	printf("输出单链表h:");
	DispList(h);
	listReserve(h);
	printf("输出逆置后单链表h");
	DispList(h);
	DestryList(h);
}

运行结果：

测试结果：

通过！

（2）设计算法，将单链表h中的元素按递增有序排列。

实现程序：

#include<stdio.h>

#include<stdlib.h>

typedef int ElemType;

typedef struct LNode{

ElemType data;

struct LNode *next;

}LinkNode;

//初始化单链表

void InitList(LinkNode *&L)

{

L=(LinkNode *)malloc(sizeof(LinkNode));

L->next=NULL;

}

//头插法建立单链表

void CreateListF(LinkNode *&L,ElemType a[],int n)

{

LinkNode *s;

L=(LinkNode *)malloc(sizeof(LinkNode));

L->next=NULL;

for(int i=0;i<n;i++)

{

s=(LinkNode *)malloc(sizeof(LinkNode));

s->data=a[i];

s->next=L->next;

L->next=s;

}

}



//插入数据元素

bool ListInsert(LinkNode *&L,int i,ElemType e)

{

int j=0;

LinkNode *p=L,*s;

if(i<=0) return false;

while(j<i-1 && p!=NULL)

{

j++;

p=p->next;

}

if(p==NULL)

return false;

else

{

s=(LinkNode *)malloc(sizeof(LinkNode));

s->data=e;

s->next=p->next;

p->next=s;

return true;

}

}

//尾插法建立单链表

void CreateListR(LinkNode *&L,ElemType a[],int n)

{

LinkNode *s,*r;

L=(LinkNode *)malloc(sizeof(LinkNode));

L->next=NULL;

r=L;

for(int i=0;i<n;i++)

{

s=(LinkNode *)malloc(sizeof(LinkNode));

s->data=a[i];

r->next=s;

r=s;

}

r->next=NULL;

}

//单链表的销毁

void DestryList(LinkNode *&L)

{

LinkNode *pre=L,*p=pre->next;

while(p!=NULL)

{

free(pre);

pre=p;

p=pre->next;

}

free(pre);

}

//排序

void Sort(LinkNode *&L)     

{

    LinkNode *p,*pre,*q;

    p=L->next->next;    

    L->next->next=NULL;     

    while(p!=NULL)

    {

        q=p->next;   

        pre=L;     

        while(pre->next!=NULL&&pre->next->data<p->data)

        {

            pre=pre->next;    

        }

        p->next=pre->next;

        pre->next=p;      

        p=q;

    }

}

//输出单链表

void DispList(LinkNode *L)

{

LinkNode *p=L->next;

while(p!=NULL)

{

printf("%3d",p->data);

p=p->next;

}

printf("\n");

}

void main()

{

   LinkNode *h;

   InitList(h);

printf("依次采用尾插法插入12，25，7，9，10共5个元素\n");

int i,y;

char s;

//循环输入，遇到回车停止输入

for(i=1;i<51&&s!='\n';i++){

scanf("%d",&y);

s=getchar();

ListInsert(h,i,y);

}

printf("输出单链表h:");

DispList(h);

Sort(h);

printf("输出排序后单链表h");

DispList(h);

DestryList(h);

}

运行结果：

测试结果：

通过！

五、思考题

1.建立一个循环链表，并且实现插入、删除操作。

实现程序：

#include<stdio.h>

#include<malloc.h>

typedef int ElemType;

typedef struct LNode{

ElemType data;

struct LNode *next;

}LinkNode;

//头插法建立循环列表

void CreateListF(LinkNode *&L,ElemType a[],int n){

LinkNode *s;

int i;

L=(LinkNode *)malloc(sizeof(LinkNode));

L->next=NULL;

for(i=0;i<n;i++){

s=(LinkNode *)malloc(sizeof(LinkNode));

s->data=a[i];

s->next=L->next;

L->next=s;

}

s=L->next;

while(s->next!=NULL)

s=s->next;

s->next=L;

}

//尾插法建立循环列表

void CreateListR(LinkNode *&L,ElemType a[],int n){

LinkNode *s,*r;

int i;

L=(LinkNode *)malloc(sizeof(LinkNode));

L->next=NULL;

r=L;

for(i=0;i<n;i++){

s=(LinkNode *)malloc(sizeof(LinkNode));

s->data=a[i];

r->next=s;

r=s;

}

r->next=L;

}

//初始化线性表

void InitList(LinkNode *&L){

L=(LinkNode *)malloc(sizeof(LinkNode));

L->next=L;

}

//销毁线性表

void DestoyList(LinkNode *&L){

LinkNode *pre=L,*p=pre->next;

while(p!=L){

free(pre);

pre=p;

p=pre->next;

}

free(pre);

}

//输出线性表

void DispList(LinkNode *L){

LinkNode *p=L->next;

while(p!=L){

printf("%d\t",p->data);

p=p->next;

}

printf("\n");

}

//插入元素

bool ListInsert(LinkNode *&L,int i,ElemType e){

int j=1;

LinkNode *p=L,*s;

if(i<=0)return false;

if(p->next==L || i==1){

s=(LinkNode *)malloc(sizeof(LinkNode));

s->data=e;

s->next=p->next;

p->next=s;

return true;

}

else{

p=L->next;

while(j<=i-2&&p!=L){

j++;

p=p->next;

}

if(p==L)

return false;

else{

s=(LinkNode *)malloc(sizeof(LinkNode));

s->data=e;

s->next=p->next;

p->next=s;

return true;

}

}

}

//删除元素

bool ListDelete(LinkNode *&L,int i,ElemType &e){

int j=1;

LinkNode *p=L,*q;

if(i<=0||L->next==L)

return false;

if(i==1){

q=L->next;

e=q->data;

L->next=q->next;

free(q);

return true;

}

else{

p=L->next;

while(j<=i-2&&p!=L){

j++;

p=p->next;

}

if(p==L)

return false;

else{

q=p->next;

e=q->data;

p->next=q->next;

free(q);

return true;

}

}

}

//主函数

void main(){

LinkNode *h;

ElemType e;

InitList(h);

printf("依次采用尾插法插入12，25，7，9，10共5个元素\n");

int i,y;

char s;

//循环输入，遇到回车停止输入

for(i=1;i<51&&s!='\n';i++){

scanf("%d",&y);

s=getchar();

ListInsert(h,i,y);

}

printf("输出循环单链表h:");

DispList(h);

printf("删除循环单链表h的第3个元素\n");

ListDelete(h,3,e);

printf("输出循环单链表h:");

DispList(h);

}

运行结果：

测试结果：

通过！

2.建立一个双向循环链表，并实现双向循环链表基本操作。

实现程序：

#include<stdio.h>

#include<malloc.h>

typedef int ElemType;

typedef struct DNode{

ElemType data;

struct DNode *prior;

struct DNode *next;

}DLinkNode;

//头插法建立循环双链表

void CreateListF(DLinkNode *&L,ElemType a[],int n){

DLinkNode *s;

L=(DLinkNode *)malloc(sizeof(DLinkNode));

L->next=NULL;

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

s=(DLinkNode *)malloc(sizeof(DLinkNode));

s->data=a[i];

s->next=L->next;

if(L->next!=NULL)L->next->prior=s;

L->next=s;

s->prior=L;

}

s=L->next;

while(s->next!=NULL)

s=s->next;

s->next=L;

L->prior=s;

}

//尾插法建立循环双链表

void CreateListR(DLinkNode *&L,ElemType a[],int n){

DLinkNode *s,*r;

L=(DLinkNode *)malloc(sizeof(DLinkNode));

L->next=NULL;

r=L;

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

s=(DLinkNode *)malloc(sizeof(DLinkNode));

s->data=a[i];

r->next=s;

s->prior=r;

r=s;

}

r->next=L;

L->prior=r;

}

//初始化线性表

void InitList(DLinkNode *&L){

L=(DLinkNode *)malloc(sizeof(DLinkNode));

L->prior=L->next=L;

}

//销毁线性表

void DestroyList(DLinkNode *&L){

DLinkNode *pre=L,*p=pre->next;

while(p!=L){

free(pre);

pre=p;

p=pre->next;

}

free(pre);

}

//判断线性表是否为空

bool ListEmpty(DLinkNode *L){

return(L->next==L);

}

//求线性表长度

int ListLength(DLinkNode *L){

DLinkNode *p=L;

int i=0;

while(p->next!=L){

i++;

p=p->next;

}

return(i);

}

//输出线性表

void DispList(DLinkNode *L){

DLinkNode *p=L->next;

while(p!=L){

printf("%d\t",p->data);

p=p->next;

}

printf("\n");

}

//求线性表中第i个元素

bool GetElem(DLinkNode *L,int i,ElemType &e){

int j=1;

DLinkNode *p=L->next;

if(i<=0||L->next==L)

return false;

if(i==1){

e=L->next->data;

return true;

}

else{

while(j<=i-1&&p!=L){

j++;

p=p->next;

}

if(p==L)

return false;

else{

e=p->data;

return true;

}

}

}

//插入第i个元素

bool ListInsert(DLinkNode *&L,int i,ElemType e){

int j=1;

DLinkNode *p=L,*s;

if(i<=0)

return false;

if(p->next==L){

s=(DLinkNode *)malloc(sizeof(DLinkNode));

s->data=e;

p->next=s;

s->next=p;

p->prior=s;

s->prior=p;

return true;

}

else if(i==1){

s=(DLinkNode *)malloc(sizeof(DLinkNode));

s->data=e;

s->next=p->next;

p->next=s;

s->next->prior=s;

s->prior=p;

return true;

}

else{

p=L->next;

while(j<=i-2 && p!=L){

j++;

p=p->next;

}

if(p==L)

return false;

else{

s=(DLinkNode *)malloc(sizeof(DLinkNode));

s->data=e;

s->next=p->next;

if(p->next!=NULL)p->next->prior=s;

s->prior=p;

p->next=s;

return true;

}

}

}

//删除第i个元素

bool  ListDelete(DLinkNode *&L,int i,ElemType &e){

int j=1;

DLinkNode *p=L,*q;

if(i<=0 || L->next==L)

return false;

if(i==1){

q=L->next;

e=q->data;

L->next=q->next;

q->next->prior=L;

free(q);

return true;

}

else{

p=L->next;

while(j<=i-2 && p!=NULL){

j++;

p=p->next;

}

if(p==NULL)

return false;

else{

q=p->next;

if(q==NULL)

return 0;

e=q->data;

p->next=q->next;

if(p->next!=NULL)

p->next->prior=p;

free(q);

return true;

}

}

}

//主函数

void main(){

DLinkNode *h;

ElemType e;

printf("循环双链表的基本运算如下；\n");

printf("(1)初始化循环双表h\n");

InitList(h);

printf("(2)依次采用尾插法插入12，25，7，9，10共5个元素\n");

ListInsert(h,1,12);

ListInsert(h,2,25);

ListInsert(h,3,7);

ListInsert(h,4,9);

ListInsert(h,5,10);

printf("(3)输出循环双链表h:");

DispList(h);

printf("(4)循环双链表h的长度:%d\n",ListLength(h));

printf("(5)循环双链表h为%s\n",(ListEmpty(h)?"空":"非空"));

GetElem(h,4,e);

printf("(6)输出循环双链表h第4个元素%d\n",e);

printf("(7)在第4个元素的位置上插入元素100\n");

ListInsert(h,4,100);

printf("(8)输出循环双链表h");

DispList(h);

printf("(9)删除循环双链表h的第3个元素\n");

ListDelete(h,3,e);

printf("(10)输出循环双链表h");

DispList(h);

printf("(11)释放循环双链表h");

DestroyList(h);

}

运行结果：

测试结果：

通过！

六、实验总结

通过本次实验学习了怎样实现单链表各种基本运算和实现单链表h就地逆置的操作以及单链表h中的元素按递增有序排列。同时学习了循环链表，并且实现插入、删除操作和双向循环链表，并实现双向循环链表基本操作。每种列表大致代码相同只是有些子函数和声明列表时不同。在错误中寻找经验，一个程序的顺利完成有很多次错误更改错误也是一种经验。

小孙同学1024
关注
专栏目录
数据结构 实验二 链表的基本操作
TXYGoodluck的博客
09-25 9200
链表的基本操作 任务一：单链表的生成和输出 任务描述： 从键盘输入数据，创建一个初始链表。通过调用定义的基本操作函数来实现单链表上的插入、删除元素等操作。调试程序并对相应的输出作出分析；修改输入数据，预期输出并验证输出的结果。加深对有关算法的理解。 相关知识： 为了完成本关任务，你需要掌握： 1.尾插法建立单链表 2.单链表的遍历（输出） - 尾插法建立单链表 本关任务：尾插法是通过将新结点逐个插入到链表的尾部来创建链表。同前插法一样,每次申请一个新结点,读入相应的数据元素值。不同的是,为了使新结点能够插入
实验二 链表基本操作的实现
12-18
【实验课程名称】算法与数据结构 【实验项目名称】链表基本操作的实现
数据结构实验报告-链表
最新发布
smwymzqbyl的博客
08-04 1057
通过本次实验的学习，我深化了对链表的理解，提升了算法设计和实现能力，为今后在数据结构和算法领域的学习和研究奠定了坚实基础。通过实践操作，我掌握了这两种链表的操作方法，并能够根据需求合理选择使用哪种类型的链表。通过实践操作，我熟练掌握了链表的定义和特点，对其内部指针关系有了更深入的理解。其次，我通过实验实现了链表的基本操作算法，包括插入、删除、查找等操作，并对这些算法的时间复杂度进行了分析。// 将长度存放在头结点的数据域中。(2）计算单链表的长度，并将结果存放在头结点的数据域中，然后输出单链表。
数据结构实验2——链表
weixin_34302798的博客
01-18 212
<span style="font-size:18px;">#include <stdio.h> #include <stdlib.h> typedef struct LNode { char data; struct LNode *next; }LNode,*Linklist; int flag=0; void menu() { ...
实验二：链表的基本操作的实验报告
12-04
源代码： #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define flag 0 typedef int ElemType; typedef struct linkList { ElemType data; struct linkList *next; }LinkList; #include #include //#include //#include "linkList.h" void init_LinkList(LinkList *head)
数据结构实验之链表一：顺序建立链表
°渐行渐远っ的博客
02-28 432
数据结构实验之链表一：顺序建立链表 Time Limit:1000 msMemory Limit:65536 KiB SubmitStatistic Problem Description 输入N个整数，按照输入的顺序建立单链表存储，并遍历所建立的单链表，输出这些数据。 Input 第一行输入整数的个数N； 第二行依次输入每个整数。 Output 输出这组整数。 Samp...
c语言实现单链表实验报告,链表的基本操作实验报告.doc
weixin_39614704的博客
05-18 718
学号1445203105姓名王胜博班级软件5班成绩实验名称实验三 链表的基本操作是否原创是《数据结构》实验报告实验要求编程实现链表下教材第二章定义的线性表的基本操作，最好用菜单形式对应各个操作，使其编程一个完整的小软件。实验目的通过该实验，深入理解链表的逻辑结构、物理结构等概念，掌握链表基本操作的编程实现，熟练掌握C语言中指针的操作。和实验2对比，掌握线性结构两种不同存储方式的区别。设计思想用函数...
李春葆数据结构教程上机实验全部源代码
06-04
总之，李春葆教授的《数据结构教程》上机实验源代码是一个宝贵的资源，它提供了亲自动手实现和调试数据结构的机会。通过深入学习和实践这些代码，不仅可以巩固理论知识，还能提升编程技能，为未来在计算机科学领域的...
链表结构实现及其操作教程_C/C++数据结构实验
在数据结构的教学实验中，链表是非常重要的实验对象，因为它不仅仅是一个数据存储的概念，而且还是一个很好的练习动态内存管理和指针操作的工具。通过操作链表，学生能够深入理解内存分配和回收，以及如何通过指针...
数据结构教程 李春葆（第5版）练习题参考答案
09-24
《数据结构教程》是李春葆教授编著的一本经典教材，第5版进一步更新和完善了教学内容，涵盖了线性结构、树形结构、图结构、动态规划、排序算法等多个重要领域。 本教程的练习题旨在帮助学生深入理解和掌握数据结构...
数据结构实验-栈的基本操作
g332273438的博客
06-15 985
数据结构—栈的基本操作（链式储存）（进栈，出栈，遍历，初始化，判空，销毁）
数据结构实验二（单链表基本操作）题目和源程序
04-02
实验内容 1．编写程序完成单链表的下列基本操作： (1)初始化单链表La。 (2)在La中第i个元素之前插入一个新结点。 (3)删除La中的第i个元素结点。 (4)在La中查找某结点并返回其位置。 (5)打印输出La中的结点元素值。 2 .构造两个带有表头结点的有序单链表La、Lb，编写程序实现将La、Lb合并成一个有序单链表Lc。 合并思想是：程序需要3个指针：pa、pb、pc，其中pa，pb分别指向La表与Lb表中当前待比较插入的结点，pc 指向Lc表中当前最后一个结点。依次扫描La和Lb中的元素，比较当前元素的值，将较小者链接到*pc之后，如此重复直到La或Lb结束为止，再将另一个链表余下的内容链接到pc所指的结点之后。 3．构造一个单链表L，其头结点指针为head，编写程序实现将L逆置。（即最后一个结点变成第一个结点，原来倒数第二个结点变成第二个结点，如此等等。）
数据结构实验2-链表
12-04
编程实现顺序表数据结构，包括： 顺序表定义 顺序表基本运算：插入、删除、定位 2、在顺序表中存储下列数字：10，4，0，7，44，56，0，0，6，13，0，78 编写程序将顺序表中的所有零元素删除。分别使用下述3种方法实现。 方法1：每找到一个待删点，就将其后所有点前移一位。若有多个待删点，后面的点要移动多次，移动量大，最坏O(n2)。 方法2：对每一个零元，用尾部的非零元与其交换。这可采用前后交替扫描的方法。每结点最多移动1次，O(n)。但会改变非零元的相对位置。 方法3：每找到一个零元，并不马上删除，而是累计当前零元数s。于是，对每一个非零元，将其前移s个位置。每结点最多移动1次，O(n)。
数据结构实验4-单链表（二）
12-04
1、编程实现：两个一元多项式相加的算法。 比如： x8-5x4+2x2+6x+1 2x12+9x10-6x8+5x4+3x-4 结果为：2x12+9x10-5x8+2x2+9x-3 提示：编写三个函数：创建多项式，显示多项式和两个多项式相加，在main函数里面调用这些函数，先依次创建两个多项式，然后实现相加，最后把相加的结果输出显示。 2、选做题：删除单链表中结点值在low到high之间的结点。 例如，给出一个单链表，包含的数据元素有1,3,5,7,9,11；其中low=3，high=9，则删除后剩下的元素为1,11。
数据结构实验——链表
12-14
数据结构实验——链表 数据结构实验——链表
数据结构教程第5版上机指导的代码
01-14
本教程聚焦于《数据结构教程》的第五版，该版本通常包括理论讲解和实践操作两部分。描述中提到，主教材中可能并未包含所有的上机实验代码，而这些实践环节对于深入理解和应用数据结构至关重要。因此，此压缩包提供的...
数据结构实验二之单链表
dj_ing的博客
10-08 659
1.建立一个由n个学生成绩的顺序表，n的大小由自己确定，每一个学生的成绩信息由自己确定，实现数据的对表进行插入、删除、查找等操作。分别输出结果。------用单链表来实现。 #include using namespace std; struct Node { double data; Node*next; }; class stu { private: Node*first; int
数据结构二：链表
qq_56701924的博客
10-10 1239
链表相关的知识点和编程题
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小孙同学1024

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值