线性表的基本操作实验报告

合集下载

实验一线性表操作实验报告

实验一线性表操作实验报告

实验一线性表操作实验报告__大学计算机学院实验报告课程名称数据结构实验名称__线性表操作实验报告要求:1.实验目的 2.实验内容 3.实验步骤 4.运行结果 5.流程图 6.实验体会一、实验目的 1 熟悉并掌握线性表的逻辑结构、物理结构。

2 熟悉并掌握顺序表的存储结构、基本操作和具体的函数定义。

3 熟悉VC++程序的基本结构,掌握程序中的用户头文件、实现文件和主文件之间的相互关系及各自的作用。

4 熟悉VC++操作环境的使用以及多文件的输入、编辑、调试和运行的全过程。

二、实验要求 1 实验之前认真准备,编写好程序。

2 实验中认真调试程序,对运行结果进行分析^p ,注意程序的正确性和健壮性的验证。

3 不断积累程序的调试方法。

三、实验内容基本题: 1 对元素类型为整型的顺序存储的线性表进行插入、删除和查找操作。

程序:#include #include #include const LIST_INIT_SIZE=10; const LISTINCREMENT=1; typedef struct { int _elem; int length; int listsize; }SqList; void InitList_Sq(SqListL) //构造一个空的线性表L { L.elem=(int_)malloc(LIST_INIT_SIZE_sizeof(int)); if(!L.elem)e_it(0); //存储分配失败 L.length=0; //空表长度为0L.listsize=LIST_INIT_SIZE; //初始存储容量 coutL.length+1)cout=L.listsize) //当前存储空间已满,增加分配 { int_newbase=(int_)realloc(L.elem,(L.listsize+LISTINCREMENT)_sizeof(int)); if(!newbase) e_it(0); //存储分配失败 L.elem=newbase; //新基址 L.listsize+=LISTINCREMENT; //增加存储容量 } int_q=(L.elem[i-1]); for(int_p=(L.elem[L.length-1]);=q;--p) _(p+1)=_p; _q=j; ++L.length; coutL.length)) cout>_; _p=_; p++;List.length++; } cout>y; if(y==1) { cout>m>>n;ListInsert_Sq(List,m,n); disp(List); } else if(y==2){ cout>m; ListDelete_Sq(List,m,j); cout>m; cout #include#include int a[100]; int josephus(int n,int s,int m) { if(!(n_s_m)) { cout>n; cout>s; cin>>m; _=josephus(n,s,m);cout>y; }while(y==1); getch; } 运行结果:(2)提高:#include using namespace std; typedef struct LNode { struct LNode _ne_t; int a; }LNode,_LinkList; class JosephouCircle //定义一个类包括三个元素 { public: void SetValue; void PickOut; private: int n; int s; int m; }; void JosephouCircle::SetValue //设置初值的大小{ cout>n; cout>s; cout>m; } void JosephouCircle::PickOut { LinkList L; LNode _p,_q; int j,k; L=(LinkList)malloc(sizeof(LNode)); L->ne_t=NULL; LNode_r; r=L; for (int i=1;ia=i; p->ne_t=NULL; r->ne_t=p; r=p; } p->ne_t=L->ne_t; p=L->ne_t; j=1;while(pjne_t;++j; } for(i=1;ine_t; } q=p->ne_t;p->ne_t=q->ne_t; p=q->ne_t; k=q->a; cout<<“输出的结果为:“<<k<<endl; free(q); } } int main(int argc,char_argv[]) { JosephouCircle Jo1; Jo1.SetValue; Jo1.PickOut; return 0; } 运行结果:四、实验体会与总结 1、对于线性链表和顺序表都属于线性表问题,但是线性链表比顺序表要灵活,方便;2、线性表在做元素寻找的操作的时候,必须从头结点开始寻找。

数据结构线性表试验报告(最终定稿)

数据结构线性表试验报告(最终定稿)

数据结构线性表试验报告(最终定稿)第一篇:数据结构线性表试验报告线性表上机实习1、实验目的(1)熟悉将算法转换为程序代码的过程。

(2)了解顺序表的逻辑结构特性,熟练掌握顺序表存储结构的C 语言描述方法。

(3)熟练掌握顺序表的基本运算:查找、插入、删除等,掌握顺序表的随机存取特性。

(4)了解线性表的链式存储结构,熟练掌握线性表的链式存储结构的C语言描述方法。

(5)熟练掌握线性链表(单链表)的基本运算:查找、插入、删除等,能在实际应用中灵活选择适当的链表结构。

2、实验要求(1)熟悉顺序表的插入、删除和查找。

(2)熟悉单链表的插入、删除和查找。

3、实验内容: ① 顺序表(1)抽象数据类型定义typedef struct {TypeData data[maxsize];//容量为maxsize的静态顺手表int n;//顺序表中的实际元素个数}SeqList;//静态顺序表的定义在本次实验中,首先建立一个空的静态顺序表,然后键盘输入数据存入表中,然后进入菜单选择界面,通过不同的数字输入,实现对顺序表,删除,插入,查找,显示等操作。

(2)存储结构定义及算法思想在顺序表结构体的定义中,typedef int TypeData 为整型,存储结构如下:for(n=0;ncout<<“请输入线性表数据”<cin>>L.data[n];//顺序将数据存入顺序表}//其他存储与此类似,都是直接赋值与数组的某一位插入版块子函数:void insert(SeqList &L)//插入数据 {int a,b,c,k;cout<<“请输入插入的数及其插入的位置”<cin>>a>>b;if(b<=0||b>(L.n+1)){cout<<“不能在该位置插入”<k=L.data[b-1];L.data[b-1]=a;c=L.n;L.n=L.n+1;while(c>b){L.data[c]=L.data[c-1];c--;//通过循环,实现插入位置后的数据挨个往后移动一位}L.data[b]=k;} 顺序表的插入与删除操作类似,在插入与删除后,都要循环调整后面数组的每一位元素,同时记录数据元素的长度的标示符也要跟着改变。

数据结构--实验报告 线性表的基本操作

数据结构--实验报告 线性表的基本操作

数据结构..实验报告线性表的基本操作数据结构实验报告线性表的基本操作1.引言本实验报告旨在介绍线性表的基本操作。

线性表是一种常见的数据结构,它是一组有限元素的有序集合,其中每个元素之间存在一个特定的顺序关系。

线性表的操作包括插入、删除、查找等,这些操作对于有效地管理和利用数据非常重要。

2.实验目的本实验的目的是通过实践理解线性表的基本操作,包括初始化、插入、删除、查找等。

通过编写相应的代码,加深对线性表的理解,并掌握相应的编程技巧。

3.实验内容3.1 初始化线性表初始化线性表是指创建一个空的线性表,为后续的操作做准备。

初始化线性表的方法有多种,如顺序表和链表等。

下面以顺序表为例进行说明。

顺序表的初始化包括定义表头指针和设置表的长度等操作。

3.2 插入元素插入元素是指将一个新的元素插入到线性表的指定位置。

插入元素有两种情况:插入到表的开头和插入到表的中间。

插入元素的操作包括移动其他元素的位置以腾出空间,并将新的元素插入到指定位置。

3.3 删除元素删除元素是指将线性表中的某个元素删除。

删除元素有两种情况:删除表的开头元素和删除表的中间元素。

删除元素的操作包括将被删除元素的前一个元素与后一个元素进行连接,断开被删除元素与表的联系。

3.4 查找元素查找元素是指在线性表中寻找指定的元素。

查找元素的方法有多种,如遍历线性表、二分查找等。

查找元素的操作包括比较目标元素与线性表中的元素进行匹配,直到找到目标元素或遍历完整个线性表。

4.实验步骤4.1 初始化线性表根据线性表的类型选择相应的初始化方法,如创建一个空的顺序表并设置表的长度。

4.2 插入元素输入要插入的元素值和插入的位置,判断插入的位置是否合法。

如果合法,移动其他元素的位置以腾出空间,将新的元素插入到指定位置。

如果不合法,输出插入位置非法的提示信息。

4.3 删除元素输入要删除的元素值,判断元素是否在线性表中。

如果在,则找到目标元素的前一个元素和后一个元素,进行连接删除操作。

数据结构--实验报告 线性表的基本操作

数据结构--实验报告 线性表的基本操作

数据结构--实验报告线性表的基本操作数据结构--实验报告线性表的基本操作一、引言本实验报告旨在通过实际操作,掌握线性表的基本操作,包括初始化、插入、删除、查找等。

线性表是最基本的数据结构之一,对于理解和应用其他数据结构具有重要的作用。

二、实验目的1·了解线性表的定义和基本特性。

2·掌握线性表的初始化操作。

3·掌握线性表的插入和删除操作。

4·掌握线性表的查找操作。

5·通过实验巩固和加深对线性表的理解。

三、线性表的基本操作1·初始化线性表线性表的初始化是将一个线性表变量设置为空表的过程。

具体步骤如下:(1)创建一个线性表的数据结构,包括表头指针和数据元素的存储空间。

(2)将表头指针指向一个空的数据元素。

2·插入元素插入元素是向线性表中指定位置插入一个元素的操作。

具体步骤如下:(1)判断线性表是否已满,如果已满则无法插入元素。

(2)判断插入位置是否合法,如果不合法则无法插入元素。

(3)将插入位置及其后面的元素都向后移动一个位置。

(4)将待插入的元素放入插入位置。

3·删除元素删除元素是从线性表中删除指定位置的元素的操作。

具体步骤如下:(1)判断线性表是否为空,如果为空则无法删除元素。

(2)判断删除位置是否合法,如果不合法则无法删除元素。

(3)将删除位置后面的元素都向前移动一个位置。

(4)删除最后一个元素。

4·查找元素查找元素是在线性表中查找指定元素值的操作。

具体步骤如下:(1)从线性表的第一个元素开始,逐个比较每个元素的值,直到找到目标元素或遍历完整个线性表。

(2)如果找到目标元素,则返回该元素的位置。

(3)如果未找到目标元素,则返回找不到的信息。

四、实验步骤1·初始化线性表(1)定义线性表的数据结构,包括表头指针和数据元素的存储空间。

(2)将表头指针指向一个空的数据元素。

2·插入元素(1)判断线性表是否已满。

C语言-线性表实验报告

C语言-线性表实验报告

一.实验名称1.线性表基本操作;2.处理约瑟夫环问题二.试验目的:1.熟悉C语言的上机环境,掌握C语言的基本结构.2.定义单链表的结点类型。

3.熟悉对单链表的一些基本操作和具体的函数定义.4.通过单链表的定义掌握线性表的链式存储结构的特点.5.熟悉对单链表的一些其它操作。

三.实验内容1.编制一个演示单链表初始化、建立、遍历、求长度、查询、插入、删除等操作的程序.2。

编制一个能求解除约瑟夫环问题答案的程序.实验一线性表表的基本操作问题描述:1. 实现单链表的定义和基本操作。

该程序包括单链表结构类型以及对单链表操作的具体的函数定义程序中的单链表(带头结点)结点为结构类型,结点值为整型。

/*定义DataType为int类型*/typedef int DataType;/* 单链表的结点类型*/typedef struct LNode{DataType data;struct LNode *next;}LNode,*LinkedList;LinkedList LinkedListInit()//初始化单链表void LinkedListClear(LinkedList L)// 清空单链表int LinkedListEmpty(LinkedList L)//检查单链表是否为空void LinkedListTraverse(LinkedList L)// 遍历单链表int LinkedListLength(LinkedList L)//求单链表的长度/*从单链表表中查找元素*/LinkedList LinkedListGet(LinkedList L,int i)/*从单链表表中查找与给定元素值相同的元素在链表中的位置*/int LinkedListLocate(LinkedList L, DataType x)void LinkedListInsert(LinkedList L,int i,DataType x)//向单链表中插入元素/* 从单链表中删除元素*/void LinkedListDel(LinkedList L,DataType x)/*用尾插法建立单链表*/LinkedList LinkedListCreat( )2。

数据结构--实验报告 线性表的基本操作

数据结构--实验报告 线性表的基本操作

数据结构--实验报告线性表的基本操作数据结构实验报告[引言]在本次实验中,我们将学习线性表的基本操作,包括插入、删除、查找等。

通过实践操作,加深对线性表的理解和掌握。

[实验目的]1.学习线性表的基本概念和操作。

2.熟悉线性表的插入、删除和查找等基本操作。

3.掌握线性表的实现方式及其相应的算法。

[实验内容]1.线性表的定义与表示1.1 线性表的定义1.2 线性表的顺序存储结构1.3 线性表的链式存储结构2.线性表的基本操作2.1初始化线性表2.2判断线性表是否为空2.3 插入操作2.3.1 在指定位置插入元素2.3.2 在表尾插入元素2.4 删除操作2.4.1 删除指定位置的元素2.4.2 删除指定值的元素2.5 查找操作2.5.1 按位置查找元素2.5.2 按值查找元素2.6 修改操作2.6.1修改指定位置的元素 2.6.2 修改指定值的元素2.7 清空线性表2.8 销毁线性表[实验步骤]1.初始化线性表1.1 创建一个空的线性表对象1.2 初始化线性表的容量和长度2.插入操作2.1在指定位置插入元素2.1.1 检查插入位置的合法性2.1.2 将插入位置后的元素依次后移2.1.3在指定位置插入新元素2.2 在表尾插入元素2.2.1 将表尾指针后移2.2.2 在表尾插入新元素3.删除操作3.1 删除指定位置的元素3.1.1 检查删除位置的合法性3.1.2 将删除位置后的元素依次前移3.1.3 修改线性表的长度3.2 删除指定值的元素3.2.1 查找指定值的元素位置3.2.2调用删除指定位置的元素操作4.查找操作4.1 按位置查找元素4.1.1 检查查找位置的合法性4.1.2 返回指定位置的元素4.2 按值查找元素4.2.1 从头到尾依次查找元素4.2.2 返回第一个匹配到的元素5.修改操作5.1修改指定位置的元素5.1.1 检查修改位置的合法性5.1.2修改指定位置的元素值5.2修改指定值的元素5.2.1 查找指定值的元素位置5.2.2调用修改指定位置的元素操作6.清空线性表6.1 设置线性表长度为07.销毁线性表7.1 释放线性表的内存空间[实验结果]使用线性表进行各种基本操作的测试,并记录操作的结果和运行时间。

数据结构线性表实验报告

数据结构线性表实验报告

数据结构线性表实验报告数据结构线性表实验报告实验目的:本次实验主要是为了学习和掌握线性表的基本操作和实现方式。

通过实验,我们可以加深对线性表的理解,并能够熟悉线性表的基本操作。

实验设备与环境:本次实验所需的设备包括计算机和编程环境。

我们选择使用C语言来实现线性表的操作,并在Visual Studio Code编程软件中进行编写和调试。

实验内容:1.线性表的定义和基本操作1.1 线性表的定义:线性表是一种有序的数据结构,其中的元素按照一定的顺序存储,可以插入、删除和访问元素。

1.2 线性表的基本操作:1.2.1 初始化线性表:创建一个空的线性表。

1.2.2 判断线性表是否为空:判断线性表是否不含有任何元素。

1.2.3 获取线性表的长度:返回线性表中元素的个数。

1.2.4 在线性表的指定位置插入元素:在线性表的第i个位置插入元素x,原第i个及其之后的元素依次后移。

1.2.5 删除线性表中指定位置的元素:删除线性表中第i个位置的元素,原第i+1个及其之后的元素依次前移。

1.2.6 获取线性表中指定位置的元素:返回线性表中第i个位置的元素的值。

1.2.7 清空线性表:将线性表中的元素全部删除,使其变为空表。

2.线性表的顺序存储结构实现2.1 线性表的顺序存储结构:使用数组来实现线性表的存储方式。

2.2 线性表的顺序存储结构的基本操作:2.2.1 初始化线性表:创建一个指定长度的数组,并将数组中的每个元素初始化为空值。

2.2.2 判断线性表是否为空:判断线性表的长度是否为0。

2.2.3 获取线性表的长度:返回线性表数组的长度。

2.2.4 在线性表的指定位置插入元素:将要插入的元素放入指定位置,并将原位置及其之后的元素依次后移。

2.2.5 删除线性表中指定位置的元素:将指定位置的元素删除,并将原位置之后的元素依次前移。

2.2.6 获取线性表中指定位置的元素:返回指定位置的元素的值。

2.2.7 清空线性表:将线性表数组中的每个元素赋空值。

数据结构--实验报告 线性表的基本操作

数据结构--实验报告 线性表的基本操作

数据结构--实验报告线性表的基本操作线性表的基本操作实验报告1.引言线性表是最基本的数据结构之一,它可以用来存储一系列具有相同数据类型的元素。

本实验旨在通过实践掌握线性表的基本操作,包括插入、删除、查找和修改元素等。

本文档将详细介绍实验所需的步骤和操作方法。

2.实验目的1.掌握线性表的插入和删除操作。

2.理解线性表的查找和修改元素的方法。

3.熟悉线性表的基本操作在算法中的应用。

3.实验环境本实验使用编程语言/软件名称作为开发环境,具体要求如下:________●操作系统:________操作系统名称和版本●编程语言:________编程语言名称和版本4.实验步骤4.1 初始化线性表在程序中创建一个空的线性表,用于存储元素。

实现方法:________具体的初始化方法和代码示例 4.2 插入元素在线性表中指定位置插入一个新元素。

实现方法:________具体的插入元素方法和代码示例 4.3 删除元素删除线性表中指定位置的元素。

实现方法:________具体的删除元素方法和代码示例 4.4 查找元素在线性表中查找指定元素的位置。

实现方法:________具体的查找元素方法和代码示例 4.5 修改元素修改线性表中指定位置的元素值。

实现方法:________具体的修改元素方法和代码示例5.实验结果在完成上述步骤后,我们得到了一个可以进行插入、删除、查找和修改元素的线性表。

具体操作结果如下:________●插入元素操作结果:________插入元素的具体操作结果●删除元素操作结果:________删除元素的具体操作结果●查找元素操作结果:________查找元素的具体操作结果●修改元素操作结果:________修改元素的具体操作结果6.实验总结通过本次实验,我们深入理解了线性表的基本操作,并且掌握了这些操作的实现方法。

线性表在实际应用中十分常见,熟练掌握线性表的操作对于开发高效的算法和数据结构具有重要意义。

线性表实验报告

线性表实验报告

线性表实验报告一、实验目的本次实验的主要目的是深入理解线性表的基本概念和操作,通过实际编程实现线性表的存储和基本运算,掌握线性表在数据结构中的应用,提高对数据结构的理解和编程能力。

二、实验环境本次实验使用的编程语言为C++,开发工具为Visual Studio 2019。

三、实验原理线性表是一种最基本、最简单的数据结构,它是由 n(n≥0)个数据元素组成的有限序列。

在这个序列中,每个数据元素的位置是按照其逻辑顺序排列的。

线性表有两种存储结构:顺序存储结构和链式存储结构。

顺序存储结构是用一组地址连续的存储单元依次存储线性表中的数据元素,使得逻辑上相邻的两个元素在物理位置上也相邻。

其优点是可以随机访问表中的任意元素,时间复杂度为 O(1);缺点是插入和删除操作需要移动大量元素,时间复杂度为 O(n)。

链式存储结构是通过指针将各个数据元素链接起来,每个数据元素由数据域和指针域组成。

其优点是插入和删除操作不需要移动大量元素,时间复杂度为 O(1);缺点是不能随机访问表中的元素,需要从头指针开始遍历,时间复杂度为 O(n)。

四、实验内容本次实验实现了顺序表和链表的基本操作,包括创建、插入、删除、查找、遍历等。

1、顺序表的实现定义顺序表的结构体,包括数据存储数组和表的长度。

实现顺序表的初始化函数,将表的长度初始化为 0。

实现顺序表的插入函数,在指定位置插入元素,如果插入位置非法或表已满,则返回错误。

实现顺序表的删除函数,删除指定位置的元素,如果删除位置非法,则返回错误。

实现顺序表的查找函数,查找指定元素,如果找到则返回元素的位置,否则返回-1。

实现顺序表的遍历函数,输出表中的所有元素。

2、链表的实现定义链表的结构体,包括数据域和指向下一个节点的指针域。

实现链表的创建函数,创建一个空链表。

实现链表的插入函数,在指定位置插入元素,如果插入位置非法,则返回错误。

实现链表的删除函数,删除指定位置的元素,如果删除位置非法,则返回错误。

线性表的实验报告

线性表的实验报告

线性表的实验报告线性表的实验报告概述:线性表是一种常见的数据结构,它是由一组具有相同数据类型的元素组成的序列。

本次实验旨在通过实际操作线性表,掌握线性表的基本操作以及了解其应用场景。

实验目的:1. 理解线性表的概念和基本操作;2. 掌握线性表的顺序存储结构和链式存储结构;3. 熟悉线性表的常见应用场景。

实验材料:1. 计算机;2. 编程软件(如C、C++、Java等);3. 实验教材或参考资料。

实验步骤:一、线性表的顺序存储结构实验1. 创建一个空的线性表;2. 向线性表中插入若干元素;3. 删除线性表中的某个元素;4. 根据索引查找线性表中的元素;5. 遍历线性表,输出所有元素。

二、线性表的链式存储结构实验1. 创建一个空的链表;2. 向链表中插入若干节点;3. 删除链表中的某个节点;4. 根据节点值查找链表中的节点;5. 遍历链表,输出所有节点。

实验结果:1. 顺序存储结构实验结果:- 成功创建空的线性表;- 成功插入若干元素;- 成功删除某个元素;- 成功根据索引查找元素;- 成功遍历线性表,输出所有元素。

2. 链式存储结构实验结果:- 成功创建空的链表;- 成功插入若干节点;- 成功删除某个节点;- 成功根据节点值查找节点;- 成功遍历链表,输出所有节点。

实验分析:1. 顺序存储结构适用于元素个数固定或变化不大的情况,插入和删除操作需要移动大量元素,效率较低;2. 链式存储结构适用于元素个数不固定的情况,插入和删除操作只需修改指针,效率较高;3. 线性表的应用场景包括但不限于:图书馆图书管理系统中的图书列表、学生信息管理系统中的学生列表等。

实验总结:通过本次实验,我深入了解了线性表的概念、基本操作以及两种常见存储结构。

顺序存储结构适用于元素个数固定的情况,而链式存储结构适用于元素个数不固定的情况。

线性表在实际应用中有着广泛的应用场景,如图书馆管理系统、学生信息管理系统等。

在以后的学习和工作中,我将灵活运用线性表,为解决实际问题提供便利。

实验一线性表操作实验报告

实验一线性表操作实验报告

实验一_线性表操作_实验报告实验一:线性表操作一、实验目的1.理解线性表的基本概念和特点。

2.掌握线性表的基本操作,包括插入、删除、查找等。

3.通过实验,提高动手能力和解决问题的能力。

二、实验原理线性表是一种较为常见的数据结构,它包含零个或多个数据元素,相邻元素之间有前后关系。

线性表具有以下特点:1.元素之间一对一的顺序关系。

2.除第一个元素外,每个元素都有一个直接前驱。

3.除最后一个元素外,每个元素都有一个直接后继。

常见的线性表有数组、链表等。

本实验主要针对链表进行操作。

三、实验步骤1.创建链表:首先创建一个链表,并给链表添加若干个节点。

节点包括数据域和指针域,数据域存储数据,指针域指向下一个节点。

2.插入节点:在链表中插入一个新的节点,可以选择在链表的头部、尾部或中间插入。

3.删除节点:删除链表中的一个指定节点。

4.查找节点:在链表中查找一个指定数据的节点,并返回该节点的位置。

5.遍历链表:从头节点开始,依次访问每个节点的数据。

四、实验结果与分析1.创建链表结果:我们成功地创建了一个链表,每个节点都有数据域和指针域,数据域存储数据,指针域指向下一个节点。

2.插入节点结果:我们成功地在链表的头部、尾部和中间插入了新的节点。

插入操作的时间复杂度为O(1),因为我们只需要修改指针域即可。

3.删除节点结果:我们成功地删除了链表中的一个指定节点。

删除操作的时间复杂度为O(n),因为我们可能需要遍历整个链表才能找到要删除的节点。

4.查找节点结果:我们成功地在链表中查找了一个指定数据的节点,并返回了该节点的位置。

查找操作的时间复杂度为O(n),因为我们可能需要遍历整个链表才能找到要查找的节点。

5.遍历链表结果:我们成功地遍历了整个链表,并访问了每个节点的数据。

遍历操作的时间复杂度为O(n),因为我们可能需要遍历整个链表。

通过本次实验,我们更加深入地理解了线性表的基本概念和特点,掌握了线性表的基本操作,包括插入、删除、查找等。

数据结构线性表操作实验报告

数据结构线性表操作实验报告

《数据结构》实验报告实验题目:线性表的操作实验目的:1.掌握上机调试线性表的基本方法;2.掌握线性表的一些基本操作;实验内容:将两个有序链表合并为一个有序链表一、需求分析1.实验程序中先创建两个有序链表,演示程序以用户和计算机的对话方式执行,即在计算机终端上显示“提示信息”之后,由用户在键盘上输入两个链表中的相应数据。

2.将两个链表合并时可按数据从大到小或从小到大合并,用户根据提示可选择一种排序方式。

3.程序执行命令包括:(1)构造链表;(2)输入数据;(3)合并两个链表,根据用户需求选择一种排序方式;(4)将合并结果输出;(5)结束4.测试数据:链表1数据为:2,4,6,7,10链表2数据为:1,3,5,6,7,12按从小到达合并为:1,2,3,4,5,6,6,7,7,10,12;按从大到小合并为:12,10,7,7,6,6,5,4,3,2,1;二、概要设计1.基本操作Linklist creat ()操作结果:构造一个链表,并输入数据,返回头节点指针。

void print(Linklist head)初始条件:链表已存在;操作结果:将链表输出。

void MergeList_1(Linklist La,Linklist Lb)初始条件:有序线性链表La 和Lb 已存在;操作结果:将La 和Lb 两个链表按从小到大的顺序合并。

void MergeList_2(Linklist La,Linklist Lb)初始条件:有序线性链表La 和Lb 已存在;操作结果:将La 和Lb 两个链表按从大到小的顺序合并。

2.本程序包括四个模块:(1)主程序模块;(2)链表数据输入模块;(3)链表合并模块;(4)链表输出模块;三、详细设计1.元素类型,节点类型,指针类型主程序模块 数据输入 按从小到大合并两链表 按从大到小合并两链表 将新链表输出 将新链表输出typedef struct LNode //定义节点{int data;struct LNode *next;}LNode,* Linklist;2.每个模块的分析(1)主函数模块int main(){Linklist head1,head2;int i;printf("请输入链表1数据(由小到大,输入0表示输入结束):\n");head1=creat(); //创建链表1,将头结点指针返回为head1printf("请输入链表2数据(由小到大,输入0表示输入结束):\n");head2=creat();printf("请选择排序方式(输入1则从小到达合并,输入其它整数则按从大到小合并):");scanf("%d",&i); //创建链表2,将头结点指针返回为head2if(i==1) //选择两种排序方式,如果输入1,则合并后按从小到大输出;输入其它数,合成链表按从大到小输出{printf("按小到大将两表合并得:\n");MergeList1(head1,head2); //将创建好的两表的头结点地址head1,head2作为函数参数}else{ printf("按从大到小将两表合并得:\n");MergeList2(head1,head2); //将创建好的两表的头结点地址head1,head2作为函数参数}return 0;}(2)数据输入创建链表模块Linklist creat() //创建链表函数,并将创建链表的头结点指针返回{Linklist head,p,s;int z=1,x;head=(LNode *) malloc(sizeof(LNode));p=head;while(z){scanf("%d",&x);if(x!=0) //输入0表示链表数据输入结束{s=(LNode *)malloc(sizeof(LNode));s->data=x;p->next=s;s->next=NULL;p=s;}elsez=0;}return(head);}(3)合并链表模块,两个函数分别表示两种排序方式,将链表合并后直接在函数中调用链表输出函数void print(Linklist head)将链表输出void MergeList_1(Linklist La,Linklist Lb)//已知链表La和Lb元素都按从小到大排列,将La和Lb合并成新链表,其中元素也按从小到大排列{Linklist pa,pb,pc,Lc;pa = La->next; pb = Lb->next;Lc = pc = La; //把La的头节点作为新建链表Lc的头结点while (pa && pb){if (pa->data <= pb->data){pc->next = pa;pc = pa;pa = pa->next;}else{pc->next = pb;pc = pb;pb = pb->next;}}pc->next = pa ? pa : pb; //插入剩余段print(Lc); //将链表Lc输出}void MergeList_2(Linklist La,Linklist Lb)//已知链表La和Lb的元素都按从小到大排列,合并La和Lb得到新链表,其中元素按照从大到小的顺序排列{Linklist pa,qa,pb,qb,Lc; //设指针qa,qb,分别作为pa,pb的前驱的指针pa=La->next;pb=Lb->next;Lc=La;Lc->next=NULL;while(pa&&pb){if(pa->data<=pb->data){qa=pa;pa=pa->next;qa->next=Lc->next;Lc->next=qa;}else{qb=pb;pb=pb->next;qb->next=Lc->next;Lc->next=qb;}}while(pa) //如果pa不为空,则将La链的剩余段倒叙插入到头节点的后面{qa=pa;pa=pa->next;qa->next=Lc->next;Lc->next=qa;}while(pb) //如果pb不为空,则将Lb链的剩余段倒叙插入到头结点的后面{qb=pb;pb=pb->next;qb->next=Lc->next;Lc->next=qb;}print(Lc); //将新合成的链表Lc输出}(4)链表输出模块,实现最终链表的输出void print(Linklist head) //链表输出函数,将链表输出{LNode *p;p=head->next;if(head!=NULL)do{printf("%d ",p->data);p=p->next;} while (p);printf("\n");四、程序使用说明及测试结果1.程序使用说明(1)本程序的运行环境为VC6.0;(2)进入演示程序后显示提示信息:请输入链表1数据(由小到大,输入0表示输入结束):按要求输入数据请输入链表2数据(由小到大,输入0表示输入结束):按要求输入数据请选择排序方式(输入1则从小到达合并,输入其它整数则按从大到小合并):输入数据选择合并方式2.测试结果对链表1输入数据2,4,6,7,10,0对链表2输入数据1,3,5,6,7,12,0输入数据选择排序方式:如果输入:1 输出结果为:1,2,3,4,5,6,6,7,7,10,12如果输入:3(整数非1)输出结果为:12,10,7,7,6,6,5,4,3,2,13.调试中遇到的错误分析第一次运行时有问题,看以看出它的排序方式是对的,但是输出是多出前面一个很大的数,可能是输出函数void print(Linklist head)有问题,检查程序:此处逻辑出错,直接将p指针指向head,然后就将p->data输出,因此第一个数是头指针head所对应节点的值,所以可将p=head;改为p=head->next;这样p就指向第一个节点。

数据结构线性表实验报告五篇

数据结构线性表实验报告五篇

数据结构线性表实验报告五篇第一篇:数据结构线性表实验报告实验报告课程名:数据结构实验名:线性表及其操作姓名:班级:学号:撰写时间:2014.09.24一实验目的与要求1.掌握线性表的实现2.掌握线性表的基本操作的实现二实验内容• 分别完成线性表的顺序表示及链式表示• 在两种表示上, 分别实现一些线性表的操作, 至少应该包括–在第i个位置插入一个元素–删除第i个元素–返回线性表长–返回第i个元素的值三实验结果与分析#include #include //---------线性表链式表示-----------struct V//声明一个结构体类型struct V { int value;struct V * next;//定义结构体变量};void PrintLink(struct V*p)//定义一个结构体指针{ while(p!=NULL)//只要指针指向的变量不为NULL;就会一直循环链表指向下一个结构体{printf(“%d, ”,(*p).value);p=(*p).next;//指针指向下一个结构体} printf(“n”);} void Link(){struct V*head;head=(struct V*)malloc(sizeof(struct V));//开辟一个长度为size的内存(*head).value=-100;//表头为-100(*head).next=NULL;printf(“------------线性表链式表示------------n”);int i,n=10;struct V*p=head;printf(“10个数据:n”);for(i=0;i(*p).next=(struct V*)malloc(sizeof(struct V));p=(*p).next;(*p).value=2*i;(*p).next=NULL;} PrintLink(head);//调用PrintLink函数printf(“删除第四个数据:n”);int k=4;p=head;for(i=1;ip=(*p).next;} struct V*temp=(*p).next;//k表示插入和删除的位置(*p).next=(*temp).next;free(temp);PrintLink(head);printf(“插入第十个数据:n”);k=10;p=head;for(i=1;ip=(*p).next;} temp=(*p).next;(*p).next=(struct V*)malloc(sizeof(struct V));(*(*p).next).value=-99;(*(*p).next).next=temp;PrintLink(head);}//---------线性表顺序表示-----------void seq1(){ int i,n=10,k=4;int a[10];//---------输出数组元素------------printf(“-------------线性表顺序表示---------n”);for(i=0;ia[i]=i;} printf(“数组元素为:n”);for(i=0;iprintf(“%3d”,a[i]);} printf(“n”);//--------插入一个数组元素---------int m=n+1,j=12;//插入元素12 int b[20];for(i=0;i if(i{b[i]=a[i];}else if(i==k){b[i]=j;}else{b[i]=a[i-1];} } printf(“输出插入一个元素的数组:n”);for(i=0;i{if(i{c[i]=a[i];}else{c[i]=a[i+1];} } printf(“输出删除一个元素的数组:n”);for(i=0;i printf(“数组元素为:n”);for(i=1;i<=a[0];i++){a[i]=i;} for(i=0;i<2*a[0];i++){printf(“%d,”,a[i]);} printf(“n”);//-----在k 位置插入一个元素------------for(i=a[0];i>=k;i--){a[i+1]=a[i];} a[k]=-100;++a[0];for(i=0;i<2*a[0];i++){printf(“%d,”,a[i]);} printf(“n”);//-------在k---------------for(i=0;i>k;i++){a[i]=a[i+1];} a[k]=-1;a[0]=n;--a[0];for(i=0;i<2*a[0];i++){printf(“%d,”,a[i]);} printf(“n”);} int main(int argc,char *argv[]){ seq1();seq2();Link();return 0;} 图1:实验结果截图实验分析:已在程序中按规定格式标注。

线性表实验报告

线性表实验报告

线性表实验报告导言:线性表是数据结构中最基本也是最常用的一种结构之一。

它以一种线性的方式存储和组织数据,简单而高效。

本实验旨在通过对线性表的实践操作,加深对线性表概念的理解,并掌握其基本操作。

实验目的:1. 了解线性表的基本概念和特点;2. 掌握线性表的基本操作,如插入、删除、查找等;3. 熟悉线性表的顺序存储和链式存储结构;4. 学会通过编程实现线性表的基本操作。

实验内容:本次实验分为两个部分,分别是线性表的顺序存储和链式存储结构。

一、顺序存储结构的线性表操作1. 初始化线性表:定义一个固定大小的数组,用于存储线性表中的元素;2. 插入元素:从表尾开始,逐个向前移动元素,为新元素腾出位置;3. 删除元素:从指定位置开始,逐个向后移动元素,覆盖待删除元素;4. 查找元素:按照线性表的顺序依次比较元素,直到找到目标元素或遍历结束;5. 获取表长度:通过记录插入和删除操作的次数,得到线性表的长度。

二、链式存储结构的线性表操作1. 定义结点:创建一个结点类,包含数据域和指向下一结点的指针;2. 初始化链表:定义一个头指针,将其初始化为 NULL,表示链表为空;3. 插入元素:找到插入位置的前一个结点,将新结点插入到其后面;4. 删除元素:找到待删除结点的前一个结点,将其指针指向待删除结点的下一个结点;5. 查找元素:从链表头部开始遍历,逐个比较结点中的数据,直到找到目标元素或遍历结束;6. 获取表长度:通过遍历链表中的结点,计数来获取表长度。

实验过程:1. 根据实验目的,在 C/C++ 环境下创建一个项目,并命名为"LinearList";2. 依次完成顺序存储结构和链式存储结构的线性表操作函数的编写;3. 调用这些函数,对线性表进行初始化、插入、删除、查找等操作;4. 验证线性表操作的正确性,并检查函数是否能正确处理各种边界情况;5. 根据实验内容,编写实验报告,记录实验过程和结果。

实验1 线性表的基本操作

实验1  线性表的基本操作

实验一线性表的基本操作一、实验目的(1)掌握线性表顺序存储和链式存储的方法及基本运算的实现。

(2)掌握将算法在VC++6.0语言环境下实现的过程。

二、实验准备(1)复习线性表的定义,掌握顺序存储、链式存储的方法及操作。

(2)复习C语言中指针与结构体的概念、定义方式。

(3)掌握链表的C语言的实现。

(4)实验的计算机中安装了Microsoft VC++ 6.0。

三、实验内容顺序表1)首先创建一个顺序表:从键盘读入一组整数(长度小于等于20),按输入顺序放入顺序表,输入以-1结束(注意-1不放到顺序表内);将创建好的顺序表元素依次输出到屏幕上。

2)在已创建好的顺序表中插入一个元素:从键盘读入需插入的元素值和插入位置,调用插入函数完成插入操作;然后将顺序表元素依次输出到屏幕上。

3)在已创建好的顺序表中删除一个元素:从键盘读入欲删除的元素位置(序号),调用删除函数完成删除操作;然后将顺序表元素依次输出到屏幕上。

算法提示:➢需求分析:1.功能(1)建立一顺序表(2)显示顺序表中每个元素(3)在上述的顺序表中的指定位置插入指定的元素,并输出顺序表中所有数据。

(4)在上述的顺序表中的指定位置删除指定的元素,并输出顺序表中所有数据。

2.输入要求从键盘输入顺序表中所有数据,输入以-1结束(注意-1不放到顺序表内);需插入的数据元素的位置、值;要删除的数据元素的位置(序号)。

3. 测试数据顺序表中所有数据:15,26,58,27,9插入的数据元素的位置、值:1,28;6,28;0,28要删除的数据元素的位置:3➢概要设计:1.数据结构:提示:相关常量和顺序表数据类型定义#define MAXNUM 20#define true 1#define false 0typedef struct{int data[MAXNUM];int length;}list_type;2.模块划分:a)建立顺序表的createlist函数;b)显示输出顺序中每个结点的数据的showlist函数;c)insertlist函数:插入函数。

线性表的基本操作实验报告

线性表的基本操作实验报告

线性表的基本操作实验报告线性表的基本操作1、需求分析:构建一个顺序表并实现顺序表的一些基本操作,例如创建列表,插入、删除元素,求元素的前驱等功能。

(1) 顺序表中数据元素为整形数字,范围属于int型。

(2) 输出部分操作提示以及功能操作所得到的数据(int型)。

(3) 顺序表建立、删除、插入、查询、判空、判满、查询前后驱等功能。

(4) 测试数据:a)b)2、概要设计:用一个结构定义了一个数组,和数组内容的长度。

主程序使用switch语句对将要进行的操作进行选择,调用各个功能函数。

3、实验源代码如下:#include<iostream>using namespace std;typedef struct{int date[100];int length;}SeqList;SeqList L;SeqList SeqListInit()//初始化顺序表 {cout<<"你定义的顺序表的长度(长度小于)"<<endl;cin>>L.length;cout<<"顺序表里面储存数据为"<<endl;for(int i=0;i<L.length;i++){int a;cin>>a;L.date[i]=a;}return L;}void ListClear()/* 清空顺序表*/{L.length=0;}int ListLength()/* 求顺序表长度*/{cout<<L.length<<endl;return 0;}int ListEmpty()/* 检查顺序表是否为空*/ { if(L.length==0)cout<<"为空"<<endl;elsecout<<"不为空"<<endl;return 0;}int ListFull()/*检查顺序表是否为满*/ { if(L.length==100)cout<<"为满"<<endl;elsecout<<"未满"<<endl;return 0;}void ListTraverse()/* 遍历顺序表*/{for(int i=0;i<L.length;i++)cout<<L.date[i]<<" ";cout<<endl;}int ListGet(int i)/* 从顺序表中查找元素*/ { if(i>=0&&i<L.length)cout<<L.date[i-1]<<endl;return 0;}int ListLocate(int x){for(int i=0;i<L.length;i++)if(L.date[i]==x)cout<<L.date[i];return 0;}void ListInsert(int i, int x){if(i>=0&&i<L.length){for(int m=0;i<=L.length-i;m++)L.date[L.length]=L.date[L.length-1];L.date[i-1]=x;L.length++;}}void ListDelete(int i){if(i>=0&&i<L.length){for(i;i<L.length;i++)L.date[i-1]=L.date[i];L.length--;}}int ListPrior(int e){if(e-2>=0&&e-2<L.length)cout<<L.date[e-2]<<endl;return 0;}int ListNext(int e){if(e>=0&&e<L.length)cout<<L.date[e]<<endl; return 0; }int main(){while(1){int i;cout<<"1初始化顺序表"<<endl;cout<<"2清空顺序"<<endl;cout<<"3求顺序表长度"<<endl;cout<<"4检查顺序表是否为空"<<endl;cout<<"5检查顺序表是否为满"<<endl;cout<<"6遍历顺序表"<<endl;cout<<"7从顺序表中查找元素"<<endl;cout<<"8从顺序表中查找与给定元素值相同的元素的位置"<<endl; cout<<"9向顺序表插入元素"<<endl;cout<<"10从顺序表中删除元素"<<endl;cout<<"11求元素前驱"<<endl;cout<<"12求元素后继"<<endl;cin>>i;switch (i){case 1:SeqListInit();break;case 2:ListClear();break;case 3:ListLength();break;case 4:ListEmpty();break;case 5:ListFull();break;case 6:ListTraverse();break;case 7:{int m;cout<<"请输入查找元素的位置"<<endl; cin>>m;ListGet(m);break;}case 8:{int m;cout<<"请输入查找元素"<<endl; cin>>m;ListLocate(m);break;}case 9:{int x;cout<<"请输入插入的元素"<<endl; cin>>x;ListInsert(i,x);break;}case 10:{int m;cout<<"请输入删除的元素"<<endl; cin>>m;ListDelete(m);break;}case 11:{int m;cout<<"请输入元素的位置"<<endl; cin>>m;ListPrior(m);break;}case 12:{int m;cout<<"请输入元素的位置"<<endl; cin>>m;ListNext(m);break;}default:break;}}}4、a) 遇见形参与实参搞混问题,改形参里面的内容并不影响其原本数据。

线性表实验报告

线性表实验报告

线性表实验报告实验目的:掌握线性表的基本概念和实现方式,熟悉线性表的各种操作。

实验原理:线性表是由同类型的数据元素构成的有序序列。

在线性表中,除了第一个元素外,每个元素都有且仅有一个直接前驱元素;除了最后一个元素外,每个元素都有且仅有一个直接后继元素。

本实验主要通过C语言的实现,实现了线性表的基本操作,包括初始化、插入、删除、查找等。

实验内容:1.初始化线性表:定义一个长度为n的结构体数组,用于存储线性表的元素,同时设置线性表的长度为0。

2.插入元素:在指定位置pos后插入元素elem,首先判断线性表是否已满,若已满则无法插入;若未满,则将pos后的所有元素往后移动一位,然后将elem插入到pos位置,最后将线性表的长度加1。

3.删除元素:删除指定位置pos的元素,首先判断线性表是否为空或pos是否合法,若为空或pos不合法则无法删除;若合法,则将pos后的所有元素往前移动一位,最后将线性表的长度减1。

4.查找元素:按照元素值查找元素在线性表中的位置,首先判断线性表是否为空,若为空则无法查找;若不为空,则遍历线性表,逐一比较元素值,找到则返回其位置,找不到则返回-1。

5.输出线性表:按顺序输出线性表中的元素值。

实验结果:经过测试,线性表的各种操作均实现了。

可以正确地初始化、插入、删除、查找元素,并成功输出线性表中的元素值。

实验总结:通过本实验,我对线性表的概念和实现方式有了更深入的了解,并通过C语言的实现掌握了线性表的各种操作。

线性表是数据结构中最基本、最简单的一种,但在实际应用中非常广泛。

掌握了线性表的操作,对于理解和应用其他更复杂的数据结构具有重要的意义。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验一:线性表的基本操作【实验目的】学习掌握线性表的顺序存储结构、链式存储结构的设计与操作。

对顺序表建立、插入、删除的基本操作,对单链表建立、插入、删除的基本操作算法。

【实验内容】1.顺序表的实践1) 建立4个元素的顺序表s=sqlist[]={1,2,3,4,5},实现顺序表建立的基本操作。

2) 在sqlist []={1,2,3,4,5}的元素4和5之间插入一个元素9,实现顺序表插入的基本操作。

3) 在sqlist []={1,2,3,4,9,5}中删除指定位置(i=5)上的元素9,实现顺序表的删除的基本操作。

2.单链表的实践3.1) 建立一个包括头结点和4个结点的(5,4,2,1)的单链表,实现单链表建立的基本操作。

2) 将该单链表的所有元素显示出来。

3) 在已建好的单链表中的指定位置(i=3)插入一个结点3,实现单链表插入的基本操作。

4) 在一个包括头结点和5个结点的(5,4,3,2,1)的单链表的指定位置(如i=2)删除一个结点,实现单链表删除的基本操作。

5) 实现单链表的求表长操作。

【实验步骤】1.打开VC++。

2.建立工程:点File->New,选Project标签,在列表中选Win32 Console Application,再在右边的框里为工程起好名字,选好路径,点OK->finish。

至此工程建立完毕。

3.创建源文件或头文件:点File->New,选File标签,在列表里选C++ Source File。

给文件起好名字,选好路径,点OK。

至此一个源文件就被添加到了刚创建的工程之中。

4.写好代码5.编译->链接->调试1、#include "stdio.h"#include "malloc.h"#define OK 1#define OVERFLOW -2#define ERROR 0#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef int ElemType;typedef int Status;typedef struct {ElemType *elem;int length;int listsize;} SqList;Status InitList( SqList &L ) {int i,n;L.elem = (ElemType*) malloc (LIST_INIT_SIZE*sizeof (ElemType)); if (!L.elem) return(OVERFLOW);printf("输入元素的个数:");scanf("%d",&n);printf("输入各元素的值:");for(i=0;i<n;i++)scanf("%d",&L.elem[i]);L.length = n;L.listsize = LIST_INIT_SIZE;return OK;}Status ListInsert(SqList &L, int i, ElemType e) {ElemType *newbase,*p,*q;if (i < 1 || i > L.length+1) return ERROR;if (L.length >= L.listsize) {newbase = (ElemType *)realloc(L.elem, (L.listsize+LISTINCREMENT)*sizeof (ElemType));if (!newbase) return(OVERFLOW);L.elem = newbase;L.listsize += LISTINCREMENT;}q = &(L.elem[i-1]);for (p = &(L.elem[L.length-1]); p >= q; --p)*(p+1) = *p;*q = e;++L.length;return OK;}Status ListDelete(SqList &L, int i, ElemType &e) {ElemType *p,*q;if((i < 1) || (i > L.length)) return ERROR;p = &(L.elem[i-1]);e = *p;q = L.elem+L.length-1;for (++p; p <= q; ++p) *(p-1) = *p;--L.length;return OK;}void VisitList(SqList L){ int i;for(i=0;i<L.length;i++)printf("%d\t",L.elem[i]);}void main(){int i,e;SqList L;InitList(L) ;VisitList(L);printf("输入插入位置和值:");scanf("%d,%d",&i,&e);printf("插入元素后,表中的值:"); ListInsert(L,i,e);VisitList(L);printf("输入删除位置:");scanf("%d",&i);printf("删除元素后,表中的值:"); ListDelete(L,i,e);VisitList(L);}2、#include "stdio.h"#include "malloc.h"#define OK 1#define OVERFLOW -2#define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 typedef int ElemType;typedef int Status;typedef struct {ElemType *elem;int length;int listsize;} SqList;Status InitList( SqList &L ) {int i,n;L.elem = (ElemType*) malloc (LIST_INIT_SIZE*sizeof (ElemType)); if (!L.elem) return(OVERFLOW);printf("输入元素的个数:");scanf("%d",&n);printf("输入各元素的值:");for(i=0;i<n;i++)scanf("%d",&L.elem[i]);L.length = n;L.listsize = LIST_INIT_SIZE;return OK;}void VisitList(SqList L){ int i;for(i=0;i<L.length;i++)printf("%d\t",L.elem[i]);}void main(){SqList L;InitList(L) ;VisitList(L);}3、#include "stdio.h"#include "malloc.h"#define OK 1#define OVERFLOW -2#define ERROR 0typedef int Status;typedef int ElemType;typedef struct LNode {ElemType data;struct LNode *next;} LNode,*LinkList;Status ListInsert(LinkList &L,int i,ElemType e){ LinkList p,s;int j;p=L;j=0;while(p&&j<i-1) {p=p->next;++j;}if(!p||j>i) return ERROR;s=(LinkList)malloc(sizeof(LNode));s->data=e;s->next=p->next;p->next=s;return OK;}Status ListDelete(LinkList &L,int i,ElemType &e){ LinkList p,q;int j;p=L;j=0;while(p->next&&j<i-1){p=p->next;++j;}if(!(p->next)||j>i-1) return ERROR;q=p->next;p->next=q->next;e=q->data;free(q);return OK;}Status CreateList(LinkList &L, int n) {int i;LinkList p;L = (LinkList) malloc (sizeof (LNode));L->next = NULL;printf("输入元素的个数和相应值:");scanf("%d",&n);for (i = n; i > 0; --i) {p = (LinkList) malloc (sizeof (LNode));//生成新结点 scanf("%d",&p->data);//输入指针p指出i=n时所对应的数值 p->next = L->next;L->next = p;}return OK;}void VisitList(LinkList L){LNode *p;p=L->next;while(p){printf("%d\t",p->data);p=p->next;}}void main(){int i,n;LinkList L;ElemType e;CreateList(L,n);VisitList(L);printf("输入插入位置和值:");scanf("%d,%d",&i,&e);printf("插入元素后,表中的值:");ListInsert(L,i,e);VisitList(L);printf("输入删除位置:");scanf("%d",&i);printf("删除元素后,表中的值:");ListDelete(L,i,e);VisitList(L);}【实验心得】今天是本学期的第一次上机实验课,老师先给我们发了本次上机的内容以及部分实验代码,因为是第一次接触这门课程,还没有理解这门学科的特点和学习方法,所以同学们都觉得无从下手。

相关文档
最新文档