您的位置：360文档中心› 第三章 单链表 题目和答案

第三章 单链表 题目和答案

第三章 单链表 题目和答案
第三章 单链表 题目和答案

第2章自测卷答案

一、填空

1.顺序表中逻辑上相邻的元素的物理位置相互相邻。单链表中逻辑上相邻的元素的物理位置不

相邻。

2.在单链表中，除了首元结点外，任一结点的存储位置由其直接前驱结点值域指示。

3．在n个结点的单链表中要删除已知结点*p，需找到它的地址。

二、判断正误（在正确的说法后面打勾，反之打叉）

1. 链表的每个结点中都恰好包含一个指针。X

2. 链表的物理存储结构具有同链表一样的顺序。X

3. 链表的删除算法很简单，因为当删除链中某个结点后，计算机会自动地将后续的各个单元向前移动。X

4. 线性表的每个结点只能是一个简单类型，而链表的每个结点可以是一个复杂类型。Y

5. 顺序表结构适宜于进行顺序存取，而链表适宜于进行随机存取。Y

6. 顺序存储方式的优点是存储密度大，且插入、删除运算效率高。X

7. 线性表在物理存储空间中也一定是连续的。X

8. 线性表在顺序存储时，逻辑上相邻的元素未必在存储的物理位置次序上相邻。X

9. 顺序存储方式只能用于存储线性结构。X

10. 线性表的逻辑顺序与存储顺序总是一致的。X

三、单项选择题

（A）1. 链接存储的存储结构所占存储空间：

（A）分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针

（B）只有一部分，存放结点值

（C）只有一部分，存储表示结点间关系的指针

（D）分两部分，一部分存放结点值，另一部分存放结点所占单元数

（B）2. 链表是一种采用存储结构存储的线性表；

（A）顺序（B）链式（C）星式（D）网状

（D）3. 线性表若采用链式存储结构时，要求内存中可用存储单元的地址:

（A）必须是连续的（B）部分地址必须是连续的

（C）一定是不连续的（D）连续或不连续都可以

（B）4．线性表Ｌ在情况下适用于使用链式结构实现。

（Ａ）需经常修改Ｌ中的结点值（Ｂ）需不断对Ｌ进行删除插入

（Ｃ）Ｌ中含有大量的结点（Ｄ）Ｌ中结点结构复杂

（C）5．单链表的存储密度

（Ａ）大于1；（Ｂ）等于1；（Ｃ）小于1；（Ｄ）不能确定

（A）6、在单链表的一个结点中有个指针。

A、1

B、2

C、3

D、4

（D）7、设一个链表最常用的操作是在末尾插入结点和删除尾结点，则选用最节省时间。

A、单链表

B、单循环链表

C、带尾指针的单循环链表

D、带头结点的双循环链表

（B ）8、在单链表指针为p的结点之后插入指针为s的结点，正确的操作是。

A、p->next=s;s->next=p->next;

B、s->next=p->next;p->next=s;

C、p->next=s;p->next=s->next;

D、p->next=s->next;p->next=s;

（C ）9、对于一个头指针为head的带头结点的单链表，判定该表为空表的条件是。

A、head==NULL

B、head→next==NULL

C、head→next==head

D、head!=NULL （head指向谁的)

（c）10、在双向链表指针p的结点前插入一个指针q的结点操作是。

A、p->prior=q;q->next=p;p->prior->next=q;q->prior=q;

B、p->prior=q;p->prior->next=q;q->next=p;q->prior=p->prior;

C、q->next=p;q->prior=p->prior;p->Prior->next=q;p->prior=q;

D、q->prior=p->prior;q->next=q;p->prior=q;p->prior=q;

（A ）11、在一个单链表中，若删除P所指结点的后续结点，则执行。

A、p-next=p->next->next;

B、p=p->next;p->next=p->next->next;

C、p->next=p->next;

D、p=p->next->next;

（A）12、不带头结点的单链表head为空的判定条件是。

A、head=NULL

B、head->next=NULL

C、head->next=head

D、head!=NULL

（B）13、链表不具有的特点是。

A、插入、删除不需要移动元素

B、可随机访问任一元素

C、不必事先估计存储空间

D、所需空间与线性长度成正比

×）1. 链表的每个结点中都恰好包含一个指针。

答：错误。链表中的结点可含多个指针域，分别存放多个指针。例如，双向链表中的结点可以含有两个指针域，分别存放指向其直接前趋和直接后继结点的指针。

（×）2. 链表的物理存储结构具有同链表一样的顺序。错，链表的存储结构特点是无序，而链表的示意图有序。

（×）3. 链表的删除算法很简单，因为当删除链中某个结点后，计算机会自动地将后续的各个单元向前移动。错，链表的结点不会移动，只是指针内容改变。

（×）4. 线性表的每个结点只能是一个简单类型，而链表的每个结点可以是一个复杂类型。

错，混淆了逻辑结构与物理结构，链表也是线性表！且即使是顺序表，也能存放记录型数据。

（×）5. 顺序表结构适宜于进行顺序存取，而链表适宜于进行随机存取。

错，正好说反了。顺序表才适合随机存取，链表恰恰适于“顺藤摸瓜”

（×）6. 顺序存储方式的优点是存储密度大，且插入、删除运算效率高。

错，前一半正确，但后一半说法错误，那是链式存储的优点。顺序存储方式插入、删除运算效率较低，在表长为n的顺序表中，插入和删除一个数据元素，平均需移动表长一半个数的数据元素。

（×）7. 线性表在物理存储空间中也一定是连续的。

错，线性表有两种存储方式，顺序存储和链式存储。后者不要求连续存放。

（×）8. 线性表在顺序存储时，逻辑上相邻的元素未必在存储的物理位置次序上相邻。

错误。线性表有两种存储方式，在顺序存储时，逻辑上相邻的元素在存储的物理位置次序上也相邻。

（×）9. 顺序存储方式只能用于存储线性结构。

错误。顺序存储方式不仅能用于存储线性结构，还可以用来存放非线性结构，例如完全二叉树是属于非线性结构，但其最佳存储方式是顺序存储方式。（后一节介绍）

（×）10. 线性表的逻辑顺序与存储顺序总是一致的。

错，理由同7。链式存储就无需一致。

三、填空题

1、在带头结点的单链表L中，若要删除第一个元素，则需要执行下列三条语句：

_______________；L→next＝U→next；free（U）。

2、在单链表L中，若要在指针P所指结点之后插入由指针S所指的结点，则需执行下列语句：S->next=P->next；______________；

3、在带有头结点的单链表L中，第一个元素结点的指针是_____________。

4、双循环链表L中由指针P所指向的某结点为尾结点的条件是_______________。

1. 【严题集

2.2①】在顺序表中插入或删除一个元素，需要平均移动表中一半元素，具体移动的元素个数与表长和该元素在表中的位置有关。

2.线性表中结点的集合是有限的，结点间的关系是一对一的。

3. 向一个长度为n的向量的第i个元素(1≤i≤n+1)之前插入一个元素时，需向后移动

n-i+1 个元素。

4. 向一个长度为n的向量中删除第i个元素(1≤i≤n)时，需向前移动 n-i 个元素。

5. 在顺序表中访问任意一结点的时间复杂度均为 O(1) ，因此，顺序表也称为随机存

取的数据结构。

6. 【严题集2.2①】顺序表中逻辑上相邻的元素的物理位置必定相邻。单链表中逻辑上相邻的元素的物理位置不一定相邻。

7. 【严题集2.2①】在单链表中，除了首元结点外，任一结点的存储位置由其直接前驱结点的链域的值指示。

8．在n个结点的单链表中要删除已知结点*p，需找到它的前驱结点的地址，其时间复杂度为O（n）。

1、设有两个单链表L和L1，各结点结构如下：

试画出该链表的结构图，并编写算法，判断单链表L1是否与单链表L相同，相同返回1，不同返回0。

五、简答题

1. 【严题集

2.3②】试比较顺序存储结构和链式存储结构的优缺点。在什么情况下用顺序表比链表好？

答：①顺序存储时，相邻数据元素的存放地址也相邻（逻辑与物理统一）；要求内存中可用存储单元的地址必须是连续的。

优点：存储密度大（＝1？），存储空间利用率高。缺点：插入或删除元素时不方便。

②链式存储时，相邻数据元素可随意存放，但所占存储空间分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针

优点：插入或删除元素时很方便，使用灵活。缺点：存储密度小（<1），存储空间利用率低。

顺序表适宜于做查找这样的静态操作；链表宜于做插入、删除这样的动态操作。

若线性表的长度变化不大，且其主要操作是查找，则采用顺序表；

若线性表的长度变化较大，且其主要操作是插入、删除操作，则采用链表。

2 .【严题集2.1①】描述以下三个概念的区别：头指针、头结点、首元结点（第一个元素结点）。在单链表中设置头结点的作用是什么？

答：首元结点是指链表中存储线性表中第一个数据元素a

的结点。为了操作方便，通常在链

1

表的首元结点之前附设一个结点，称为头结点，该结点的数据域中不存储线性表的数据元素，其作用是为了对链表进行操作时，可以对空表、非空表的情况以及对首元结点进行统一处理。头指针是指向链表中第一个结点（或为头结点或为首元结点）的指针。若链表中附设头结点，则不管线性表是否为空表，头指针均不为空。否则表示空表的链表的头指针为空。这三个概念对单链表、双向链表和循环链表均适用。是否设置头结点，是不同的存储结构表示同一逻辑结构的问题。

头结点

头指针首元结点

简而言之，

头指针是指向链表中第一个结点（或为头结点或为首元结点）的指针；

头结点是在链表的首元结点之前附设的一个结点；数据域内只放空表标志和表长等信息（内放头指针？那还得另配一个头指针！！！）

的结点。

首元素结点是指链表中存储线性表中第一个数据元素a

1

《数据结构》实验报告 设计循环单链表

《数据结构》实验报告 1、实验名称:设计循环单链表 2、实验日期: 2013-3-26 3、基本要求： 1）循环单链表的操作，包括初始化、求数据元素个数、插入、删除、取数据元素； 2）设计一个测试主函数实际运行验证所设计循环单链表的正确性。 4、测试数据： 依次输入1，2，3，4，5，6，7，8，9，10，删除5，再依次输出数据元素。 5、算法思想或算法步骤: 主函数主要是在带头结点的循环单链表中删除第i个结点，其主要思想是在循环单链表中寻找到第i-1个结点并由指针p指示，然后让指针s指向a[i]结点，并把数据元素a[i]的值赋给x，最后把a[i]结点脱链，并动态释放a[i]结点的存储空间。 6、模块划分： 1）头文件LinList.h。头文件LinList.h中包括：结点结构体定义、初始化操作、求当前数据个数、插入一个结点操作、删除一个结点操作以及取一个数据元素操作； 2）实现文件dlb.cpp。包含主函数void main(void)，其功能是测试所设计的循环单链表的正确性。

7、数据结构： 链表中的结点的结构体定义如下： typedef struct Node { DataType data; struct Node *next; }SLNode; 8、源程序： 源程序存放在两个文件中，即头文件LinList.h和实现文件dlb.cpp。//头文件LinList.h typedef struct Node { DataType data; struct Node *next; }SLNode; void ListInitiate(SLNode **head) //初始化 { *head=(SLNode *)malloc(sizeof(SLNode)); //申请头结点，由head指示其地址 (*head)->next=*head; }

数据结构第三次实验+第二题链表排序

数据结构实验报告 实验名称：实验三——排序 学生姓名：XXX 班级：xxxxxxxxxxx 班内序号： 学号： 日期：2018年6月3日 1．实验要求 实验目的：通过选择下面两个题目之一，学习、实现、对比各种排序算法，掌握各种排序算法的优劣，以及各种算法使用的情况。 实验内容：使用链表实现下面各种排序算法，并进行比较。 排序算法： 1、插入排序 2、冒泡排序 3、快速排序 4、简单选择排序 5、其他 要求： 1、测试数据分成三类：正序、逆序、随机数据 2、对于这三类数据，比较上述排序算法中关键字的比较次数和移动次数（其 中关键字交换计为3次移动）。 3、对于这三类数据，比较上述排序算法中不同算法的执行时间，精确到微秒 （选作） 4、对2和3的结果进行分析，验证上述各种算法的时间复杂度 编写测试main()函数测试线性表的正确性。 2. 程序分析 2.1 存储结构

单链表，储存每个元素值同时，储存该元素的直接后继元素位置信息。即数据域（data），指针域（next）。struct Node { int data; struct Node *next; }; 2.2 关键算法分析 链表的建立： Linklist::Linklist (int a[],int n) { front = new Node; Node *r = front ; for(int i=0;idata = a[i]; r->next = s; r=s; } r->next = NULL; } 尾插法创建链表：①堆中建立新节点②将a[i]写入新节点data域③新节点加入链表r->next=s. ④修改尾指针r=s. 简单选择排序： void Linklist ::Link_Selectsort (int n) { Node *p=front->next ; int a=0,b=0; //a记载比较次数，b记载移动次数 while(p!=NULL) { Node *s =p; //s指向最小节点 Node *q=p->next ; while(q!=NULL)

数据结构 单链表基本操作代码

实验一单链表 #include "stdio.h" #include "stdlib.h" typedef int ElemType; typedef struct LNode { ElemType data; struct LNode *next; }LNode,*LinkList; void creatLNode(LinkList &head) { int i,n; LNode *p; head=(LNode*)malloc(sizeof(LNode)); head->next=NULL; printf("请输入链表的元素个数："); scanf("%d",&n); for(i=n;i>0;i--) { p=(LNode*)malloc(sizeof(LNode)); printf("第%d个元素：",i); scanf("%d",&p->data); p->next=head->next; head->next=p; } } void InsertLNode(LinkList &L) { LNode *p=L; int i,j=0,e; printf("请输入你要插入的位置（超过链表长度的默认插在最后！）："); scanf("%d",&i); printf("请输入你要插入的元素："); scanf("%d",&e); while (p->next&&jnext; ++j; }

LNode *s; s=(LNode*)malloc(sizeof(LNode)); s->data=e; s->next=p->next; p->next=s; } int DeleteLNode(LinkList &L,int i,int &e) { LNode *p; p=L; LNode *q; int j=0; while (p->next&&jnext; ++j; } if(!(p->next)||j>i-1) { printf("删除位置不合理!\n"); return 0; } q=p->next; p->next=q->next; e=q->data; free(q); return e; } void DeleteCF(LinkList &L) { LNode *p,*s,*r; p=L->next; while(p!=NULL) { r=p; s=r->next; while(s!=NULL) { if(p->data==s->data) { r->next=s->next; s=s->next;

链表排序算法总结

这个星期做数据结构课设，涉及到两个基于链表的排序算法，分别是基于链表的选择排序算法和归并排序算法。写出来跟大家一起分享一下，希望对数据结构初学朋友有所帮助，高手就直接忽视它吧。话不多说，下面就看代码吧。 [c-sharp]view plaincopy 1.node *sorted(node *sub_root) 2.{ 3.if (sub_root->next) 4. { 5. node * second_half = NULL; 6. node * first_half = sub_root; 7. node * temp = sub_root->next->next; 8.while (temp) 9. { 10. first_half = first_half->next; 11. temp = temp->next; 12.if(temp) 13. temp = temp->next; 14. } 15. second_half = first_half->next; 16. first_half->next = NULL; 17. node * lChild = sorted(sub_root); 18. node * rChild = sorted(second_half); 19.if (lChild->data < rChild->data) 20. { 21. sub_root = temp = lChild; 22. lChild = lChild->next; 23. } 24.else 25. { 26. sub_root = temp = rChild; 27. rChild = rChild->next; 28. } 29.while (lChild&&rChild) 30. { 31.if (lChild->data < rChild->data ) 32. { 33. temp->next = lChild; 34. temp = temp->next; 35. lChild = lChild->next; 36. } 37.else 38. {

数据结构 单链表详解

数据结构的概念： 数据的逻辑结构+ 数据的存储结构+ 数据的操作； 数据的数值：=====》数据===》数值型数据整形浮点数ASCII 非数值型数据图片声音视频字符 =====》数据元素=====》基本项组成（字段，域，属性）的记录。 数据的结构： 逻辑结构 ----》线性结构（线性表，栈，队列） ----》顺序结构 ----》链式结构 ----》非线性结构(树，二叉树，图) ----》顺序结构 ----》链式结构 存储结构 -----》顺序存储 -----》链式存储 -----》索引存储 -----》哈希存储==散列存储 数据的操作： 增 删 改 查 DS ====》数据结构===》DS = (D,R); 数据结构中算法： 1、定义：有穷规则的有序集合。 2、特性： 有穷性 确定性

输入 输出 3、算法效率的衡量 时间复杂度计算===》算法中可执行依据的频度之和，记为：T(n)。 是时间的一种估计值不是准确值。 计算结果的分析：1 将最终结果的多项式中常数项去掉 2 只保留所有多项式中最高阶的项 3 最后的最高阶项要去掉其常数项 时间复杂度的量级关系： 常量阶====》对数阶===》线性阶===》线性对数阶====》平方阶===》立方阶===》指数阶 以上关系可以根据曲线图来判断算法对时间复杂度的要求 空间复杂度计算====》算法执行过程中所占用的存储空间的量级，记为：D（n）。 计算方法是在运行过程中申请的动态内存的量级计算。 ///////////////////////////////////////////////////////////////////////////////////////////////// 线性表 顺序存储====》顺序表（数组） 链式存储====》单链表 特征：对于非空表，a0是表头没有前驱。 an-1 是表尾没有后继 ai的每个元素都有一个直接前驱和直接后继 基本操作：创建表=====》增加元素====》删除元素====》改变元素值====》查询元素 1、顺序表的操作 1.1 创建顺序表=====》定义个指定类型的数组====》int a[100] ={0};

链表实验报告

C语言程序设计实验报告 实验一：链表的基本操作一·实验目的 1.掌握链表的建立方法 2.掌握链表中节点的查找与删除 3.掌握输出链表节点的方法 4.掌握链表节点排序的一种方法 5.掌握C语言创建菜单的方法 6.掌握结构化程序设计的方法 二·实验环境 1.硬件环境：当前所有电脑硬件环境均支持 2.软件环境：Visual C++6.0 三.函数功能 1. CreateList // 声明创建链表函数 2.TraverseList // 声明遍历链表函数 3. InsertList // 声明链表插入函数 4.DeleteTheList // 声明删除整个链表函数 5. FindList // 声明链表查询函数 四．程序流程图 五．程序代码 #include #include typedef int Elemtype; typedef int Status; typedef struct node//定义存储节点 { int data;//数据域 struct node *next;//结构体指针 } *linklist,node;//结构体变量，结构体名称 linklist creat (int n)//创建单链表 { linklist head,r,p;//定义头指针r,p,指针 int x,i; head=(node *)malloc(sizeof(node));//生成头结点

r=head;//r指向头结点 printf("输入数字:\n"); for(i=n;i>0;i--)//for 循环用于生成第一个节点并读入数据{ scanf("%d",&x); p=(node *)malloc(sizeof(node)); p->data=x;//读入第一个节点的数据 r->next=p;//把第一个节点连在头结点的后面 r=p;//循环以便于生成第二个节点 } r->next=0;//生成链表后的断开符 return head;//返回头指针 } void output (linklist head)//输出链表 { linklist p; p=head->next; do { printf("%3d",p->data); p=p->next; } while(p); printf("\n") } Status insert ( linklist &l,int i, Elemtype e)//插入操作 { int j=0; linklist p=l,s; while(jnext; ++j; } if(!p || j>i-1) return -1; else { s=(node *)malloc(sizeof(node)); s->data=e; s->next=p->next; p->next=s; return 1; } } Status delect ( linklist &l,int i, Elemtype &e)//删除操作 { int j=0; linklist p=l,q; while(jnext) { p=p->next; ++j; } if(!p->next || j>i-1) return -1;

单链表实验报告

计算机与信息技术学院综合性、设计性实验报告 一、实验目的 (1)熟悉顺序表的创建、取值、查找、插入、删除等算法，模块化程序设计方法。 二、实验仪器或设备 (1)硬件设备：CPU为Pentium 4 以上的计算机，内存2G以上 (2)配置软件：Microsoft Windows 7 与VC++6.0 三、总体设计(设计原理、设计方案及流程等) 设计原理： 单链表属于线性表，线性表的存储结构的特点是：用一组任意存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的。因此，对于某个元素来说，不仅需要存储其本身的信息，还需要存储一个指示其直接后继的信息。 设计方案： 采用模块化设计的方法，设计各个程序段，最终通过主函数实现各个程序段的功能。设计时，需要考虑用户输入非法数值，所以要在程序中写入说可以处理非法数值的代码。 设计流程： 1. 引入所需的头文件； 2. 定义状态值； 3. 写入顺序表的各种操作的代码； 写入主函数，分别调用各个函数。在调用函数时，采用if结构进行判断输 入值是否非法，从而执行相应的程序 四、实验步骤(包括主要步骤、代码分析等) #include // EOF(=A Z 或F6),NULL #in clude // srand( ) ,rand( ),exit (n) #in clude // malloc( ),alloc( ),realloc() 等 #in clude // INT_MAX 等 #in clude #in clude #in clude // floor(),ceil( ),abs() #in clude // cout,ci n #in clude // clock( ),CLK_TCK,clock_t #defi ne TRUE 1 #defi ne FALSE 0 #defi ne OK 1 #defi ne ERROR 0 #defi ne INFEASIBLE -1

最新C语言链表排序

========================== 功能：选择排序(由小到大) 返回：指向链表表头的指针 ========================== */ /* 选择排序的基本思想就是反复从还未排好序的那些节点中， 选出键值（就是用它排序的字段，我们取学号num为键值）最小的节点， 依次重新组合成一个链表。 我认为写链表这类程序，关键是理解： head存储的是第一个节点的地址，head->next存储的是第二个节点的地址； 任意一个节点p的地址，只能通过它前一个节点的next来求得。 单向链表的选择排序图示： ---->[1]---->[3]---->[2]...---->[n]---->[NULL]（原链表） head 1->next 3->next 2->next n->next ---->[NULL]（空链表） first tail ---->[1]---->[2]---->[3]...---->[n]---->[NULL]（排序后链表） first 1->next 2->next 3->next tail->next 图10：有N个节点的链表选择排序 1、先在原链表中找最小的，找到一个后就把它放到另一个空的链表中； 2、空链表中安放第一个进来的节点，产生一个有序链表,并且让它在原链表中分离出来（此时要注意原链表中出来的是第一个节点还是中间其它节点）；

3、继续在原链表中找下一个最小的，找到后把它放入有序链表的尾指针的next,然后它变成其尾指针； */ struct student *SelectSort(struct student *head) { struct student *first; /*排列后有序链的表头指针*/ struct student *tail; /*排列后有序链的表尾指针*/ struct student *p_min; /*保留键值更小的节点的前驱节点的指针*/ struct student *min; /*存储最小节点*/ struct student *p; /*当前比较的节点*/ first = NULL; while (head != NULL) /*在链表中找键值最小的节点。*/ { /*注意：这里for语句就是体现选择排序思想的地方*/ for (p=head,min=head; p->next!=NULL; p=p->next) /*循环遍历链表中的节点，找出此时最小的节点。*/ { if (p->next->num < min->num) /*找到一个比当前min小的节点。*/ { p_min = p; /*保存找到节点的前驱节点：显然p->next的前驱节点是p。*/ min = p->next; /*保存键值更小的节点。*/ } }

数据结构课程设计单链表操作

《数据结构课程设计》报告 题目：单链表操作 专业：计算机科学与技术 班级： 单链表操作 针对带头结点的单循环链表，编写实现以下操作的算法函数。

实现要求： ⑴单链表建立函数create：先输入数据到一维数组A[M]中，然后根据一维 数组A[M]建立一个单循环链表，使链表中个元素的次序与A[M]中各元素的次序相同，要求该函数的时间复杂度为O(m)； ⑵定位查找函数Locate：在所建立的单循环链表中查找并返回值为key的 第1个元素的结点指针；若找不到，则返回NULL； ⑶求出该链表中值最大和次大的元素值，要求该算法的时间复杂度为O(m)， 最大和次大的元素值通过指针变量带回，函数不需要返回值； ⑷将链表中所有值比key(值key通过形参传入)小的结点作为值为key的结 点前驱，所有值比key大的结点作为值为key的结点后继，并尽量保持原有结点之间的顺序，要求该算法的时间复杂度为O(m); ⑸设计一个菜单，具有上述处理要求和退出系统功能。 ⒈本人完成的工作： 一、定义结构体：LNode 二、编写以下函数： （1）建立单循环链表 （2）建立定位查找函数 （3）求出链表中最大和次大值 （4）将链表中的值和输入的Key比较，小的作为key前驱结点，大的作为key 的后继结点 三、设计具有上述处理要求和退出系统菜单 ⒉所采用的数据结构：单链表 数据结构的定义： typedef struct Node //定义结点的结构体 { DataType data; //数据域 struct Node *next; //指针域

}LNode; //结点的类型 ⒊所设计的函数 （1）Create(void) LNode *Create(void) //建立单循环链表，链表头结点head作为返回值{ int i,j,n,A[M]; //建立数组A【M】 LNode *head,*p,*move; head=(LNode*)malloc(sizeof(LNode)); //创建空单循环链表head->next=head; move=head; printf("请输入数组元素的个数："); //输入数组 scanf("%d",&n); printf("请输入数组："); for(i=0;idata=A[j]; p->next=move->next; move->next=p; move=move->next; } return head; //返回头指针

链表实验报告

链表实验报告

————————————————————————————————作者: ————————————————————————————————日期：

《数据结构》实验报告二 系别:嵌入式系统工程系班级:嵌入式1１0０3班 学号:１1160400３１4姓名：孙立阔 日期：2012年４月９日指导教师:申华 一、上机实验的问题和要求： 单链表的查找、插入与删除。设计算法,实现线性结构上的单链表的产生以及元素的查找、插入与删除。具体实现要求: 1.从键盘输入1０个字符，产生不带表头的单链表，并输入结点值。 2.从键盘输入1个字符,在单链表中查找该结点的位置。若找到,则显示“找到了”；否则, 则显示“找不到”。 3.从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插 入在对应位置上，输出单链表所有结点值,观察输出结果。 4.从键盘输入１个整数,表示欲删除结点的位置，输出单链表所有结点值,观察输出结果。 5.将单链表中值重复的结点删除,使所得的结果表中个结点值均不相同,输出单链表所有结 点值,观察输出结果。 6.删除其中所有数据值为偶数的结点，输出单链表所有结点值,观察输出结果。 7.（★)将单链表分解成两个单链表A和B，使A链表中含有原链表中序号为奇数的元素, 而B链表中含有原链表中序号为偶数的元素，且保持原来的相对顺序，分别输出单链表Ａ和单链表B的所有结点值，观察输出结果。 二、程序设计的基本思想，原理和算法描述: (包括程序的结构,数据结构，输入/输出设计,符号名说明等） 创建一个空的单链表，实现对单链表的查找，插入,删除的功能。 三、源程序及注释： #dｅfiｎｅOK 1 #defｉne EＲＲOR 0 #ｄefiｎe INFEASIBLE －1 #defｉne OVEＲFＬOW －2 #deｆine TRUE 1

《数据结构与算法分析》课程设计：顺序表、单链表、顺序栈、查找、排序算法

*******大学 《数据结构与算法分析》课程设计 题目：数据结构上机试题 学生姓名： 学号： 专业：信息管理与信息系统 班级： 指导教师： 2014年04月

目录 一、顺序表的操作 (2) 【插入操作原理】 (2) 【删除操作原理】 (2) 【NO.1代码】 (3) 【运行截图演示】 (7) 二、单链表的操作 (10) 【创建操作原理】 (10) 【插入操作原理】 (10) 【删除操作原理】 (10) 【NO.2代码】 (11) 【运行截图演示】 (20) 三、顺序栈的操作 (25) 【数值转换原理】 (25) 【NO.3代码】 (26) 【运行截图演示】 (30) 四、查找算法 (32) 【顺序查找原理】 (32) 【折半查找原理】 (32) 【NO.4代码】 (33) 【运行截图演示】 (38) 五、排序算法 (40) 【直接插入排序原理】 (40) 【快速排序原理】 (40) 【NO.5代码】 (41) 【运行截图演示】 (46)

一、顺序表的操作 （1）插入元素操作：将新元素x 插入到顺序表a 中第i 个位置； （2）删除元素操作：删除顺序表a 中第i 个元素。 【插入操作原理】 线性表的插入操作是指在线性表的第i-1个数据元素和第i 个数据元素之间插入一个新的数据元素，就是要是长度为n 的线性表： ()11,,,,,i i n a a a a -………… 变成长度为n+1的线性表： ()11,,,,,,i i n a a b a a -………… 数据元素1i a -和i a 之间的逻辑关系发生了变化。 （其【插入原理】在课本P23的算法2.3有解释） 【删除操作原理】 反之，线性表的删除操作是使长度为n 的线性表： ()111,,,,,,i i i n a a a a a -+………… 变成长度为n-1的线性表： ()111,,,,,i i n a a a a -+………… 数据元素1i a -、i a 和1i a +之间的逻辑关系发生变化，为了在存储结构上放映这个变化，同样需要移动元素。 （其【删除原理】在课本P24的算法2.4有解释）

数据结构课程设计单链表

目录 1 选题背景 (2) 2 方案与论证 (3) 2.1 链表的概念和作用 (3) 2.3 算法的设计思想 (4) 2.4 相关图例 (5) 2.4.1 单链表的结点结构 (5) 2.4.2 算法流程图 (5) 3 实验结果 (6) 3.1 链表的建立 (6) 3.2 单链表的插入 (6) 3.3 单链表的输出 (7) 3.4 查找元素 (7) 3.5 单链表的删除 (8) 3.6 显示链表中的元素个数（计数） (9) 4 结果分析 (10) 4.1 单链表的结构 (10) 4.2 单链表的操作特点 (10) 4.2.1 顺链操作技术 (10) 4.2.2 指针保留技术 (10) 4.3 链表处理中的相关技术 (10) 5 设计体会及今后的改进意见 (11) 参考文献 (12) 附录代码： (13)

1 选题背景 陈火旺院士把计算机60多年的发展成就概括为五个“一”：开辟一个新时代----信息时代，形成一个新产业----信息产业，产生一个新科学----计算机科学与技术，开创一种新的科研方法----计算方法，开辟一种新文化----计算机文化，这一概括深刻影响了计算机对社会发展所产生的广泛而深远的影响。 数据结构和算法是计算机求解问题过程的两大基石。著名的计算机科学家P.Wegner指出，“在工业革命中其核心作用的是能量，而在计算机革命中其核心作用的是信息”。计算机科学就是“一种关于信息结构转换的科学”。信息结构（数据结构）是计算机科学研究的基本课题，数据结构又是算法研究的基础。

2 方案与论证 2.1 链表的概念和作用 链表是一种链式存储结构，链表属于线性表，采用链式存储结构，也是常用的动态存储方法。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 以“结点的序列”表示线性表称作线性链表（单链表） 单链表是链式存取的结构，为找第 i 个数据元素，必须先找到第 i-1 个数据元素。 因此，查找第 i 个数据元素的基本操作为：移动指针，比较 j 和 i 单链表 1、链接存储方法 链接方式存储的线性表简称为链表（Linked List）。 链表的具体存储表示为： ① 用一组任意的存储单元来存放线性表的结点（这组存储单元既可以是连续的，也可以是不连续的） ② 链表中结点的逻辑次序和物理次序不一定相同。为了能正确表示结点间的逻辑关系，在存储每个结点值的同时，还必须存储指示其后继结点的地址（或位置）信息（称为指针（pointer）或链(link)） 注意： 链式存储是最常用的存储方式之一，它不仅可用来表示线性表，而且可用来表示各种非线性的数据结构。 2、链表的结点结构 ┌───┬───┐ │data │next │ └───┴───┘ data域--存放结点值的数据域 next域--存放结点的直接后继的地址（位置）的指针域（链域） 注意： ①链表通过每个结点的链域将线性表的n个结点按其逻辑顺序链接在一起的。 ②每个结点只有一个链域的链表称为单链表（Single Linked List）。

单链表的插入和删除实验报告

. 实验一、单链表的插入和删除 一、目的 了解和掌握线性表的逻辑结构和链式存储结构，掌握单链表的基本算法及相关的时间性能分析。 二、要求： 建立一个数据域定义为字符串的单链表，在链表中不允许有重复的字符串；根据输入的字符串，先找到相应的结点，后删除之。 三、程序源代码 #include"stdio.h" #include"string.h" #include"stdlib.h" #include"ctype.h" typedef struct node //定义结点 { char data[10]; //结点的数据域为字符串 struct node *next; //结点的指针域 }ListNode; typedef ListNode * LinkList; // 自定义LinkList单链表类型 LinkList CreatListR1(); //函数，用尾插入法建立带头结点的单链表

ListNode *LocateNode(); //函数，按值查找结点 void DeleteList(); //函数，删除指定值的结点void printlist(); //函数，打印链表中的所有值 void DeleteAll(); //函数，删除所有结点，释放内存 //==========主函数============== void main() { char ch[10],num[10]; LinkList head; head=CreatListR1(); //用尾插入法建立单链表，返回头指针printlist(head); //遍历链表输出其值 printf(" Delete node (y/n):");//输入“y”或“n”去选择是否删除结点scanf("%s",num); if(strcmp(num,"y")==0 || strcmp(num,"Y")==0){ printf("Please input Delete_data:"); scanf("%s",ch); //输入要删除的字符串 DeleteList(head,ch); printlist(head); } DeleteAll(head); //删除所有结点，释放内存 } //==========用尾插入法建立带头结点的单链表

链表实现多项式相加实验报告

实验报告 课程名称：数据结构 题目：链表实现多项式相加 班级： 学号： 姓名： 完成时间：2012年10月17日

1、实验目的和要求 1）掌握链表的运用方法； 2）学习链表的初始化并建立一个新的链表； 3）知道如何实现链表的插入结点与删除结点操作； 4）了解链表的基本操作并灵活运用 2、实验内容 1）建立两个链表存储一元多项式； 2）实现两个一元多项式的相加； 3）输出两个多项式相加后得到的一元多项式。 3、算法基本思想 数降序存入两个链表中，将大小较大的链表作为相加后的链表寄存处。定义两个临时链表节点指针p,q,分别指向两个链表头结点。然后将另一个链表中从头结点开始依次与第一个链表比较，如果其指数比第一个小，则p向后移动一个单位，如相等，则将两节点的系数相加作为第一个链表当前节点的系数，如果为0，则将此节点栓掉。若果较大，则在p前插入q,q向后移动一个，直到两个链表做完为止。 4、算法描述 用链表实现多项式相加的程序如下： #include #include #include struct node{ int exp; float coef; struct node*next; };

void add_node(struct node*h1,struct node*h2); void print_node(struct node*h); struct node*init_node() { struct node*h=(struct node*)malloc(sizeof(struct node)),*p,*q; int exp; float coef=1.0; h->next=NULL; printf("请依次输入多项式的系数和指数(如:\"2 3\"；输入\"0 0\"时结束):\n"); p=(struct node*)malloc(sizeof(struct node)); q=(struct node*)malloc(sizeof(struct node)); for(;fabs(coef-0.0)>1.0e-6;) { scanf("%f %d",&coef,&exp); if(fabs(coef-0.0)>1.0e-6) { q->next=p; p->coef=coef; p->exp=exp; p->next=NULL; add_node(h,q); } } free(p); free(q); return(h); } void add_node(struct node*h1,struct node*h2) { struct node*y1=h1,*y2=h2; struct node*p,*q; y1=y1->next; y2=y2->next; for(;y1||y2;) if(y1) { if(y2) { if(y1->expexp) y1=y1->next; else if(y1->exp==y2->exp) { y1->coef+=y2->coef; if(y1->coef==0)

数据结构单链表输入输出(c++)

#include template class link { public: T date; link *next; link(const T info, link *nextvalue=NULL) { date=info; next=nextvalue; } link(link *nextvalue) { next=nextvalue; } }; templateclass inklist{ private: link *head,*tail; link *setpos(const int p); public: inklist(); ~inklist(); bool append(const T value); bool insert(const int p,const T value); bool remove(const int p); void print(); }; template inklist::inklist() { head=tail=new link(NULL); } template inklist::~inklist() { link *tmp; while(head!=NULL) { tmp=head; head=head->next; delete tmp; }

} template link *inklist::setpos(int i) { int count=0; if(i==-1) return head; link *p=new link(head->next); while( p!=NULL && countnext; count++; } return p; } template bool inklist::insert(const int i,const T value) { link *p,*q; if((p=setpos(i-1))==NULL){ cout<<"非法插入点"<(value,p->next); p->next=q; if(p==tail) tail=q; return true;} template bool inklist::remove(const int i) { link *p,*q; if((p=setpos(i-1))==NULL||p==tail) { cout<<"非法删除点"; return false; } q=p->next; if(q==tail) { tail=p; p->next=NULL; delete q; }

c++单向链表的排序

河北联合大学 2011-2012 第 2 学期
《 软 件 设 计 基 础 -C++》
课程设计报告
设计名称：设计一个处理单向链表的程序：链表的排序 姓 名：王学增 学 号：201005100206
专业班级：土木工程 1 班 学 院：建筑工程学院
设计时间：2012-5-31 设计地点：机房
指导教师评语： 教师评定： 自评成绩；75
指导教师签字：
年 年 月 月 日 日

《软件设计基础-C++》课程设计报告
第
2
页，共
16 页
目
录
1.课程设计目的···································· ···································· ···································· 2.课程设计任务与要求 ································ ································ ······························· 3.课程设计说明书··································· ··································· ·································· 4.课程设计成果···································· ···································· ···································· 5.程序调试过程···································· ···································· ···································· 6.设计问题的不足和改进方案 ···························· ···························· ··························· 7.课程设计心得···································· ···································· ···································· 8.参考文献······································· ······································· ······································

数据结构-单链表实验报告

单链表实验报告 一、实验目的 1、帮助读者复习C++语言程序设计中的知识。 2、熟悉线性表的逻辑结构。 3、熟悉线性表的基本运算在两种存储结构上的实现，其中以熟悉链表的操作为侧重点。 二、实验内容 [问题描述] 实现带头结点的单链表的建立、求长度，取元素、修改元素、插入、删除等单链表的基本操作。 [基本要求] （1）依次从键盘读入数据，建立带头结点的单链表； （2）输出单链表中的数据元素 （3）求单链表的长度； （4）根据指定条件能够取元素和修改元素； （5）实现在指定位置插入和删除元素的功能。 三、算法设计 （1）建立带表头结点的单链表；首先输入结束标志，然后建立循环逐个输入数据，直到输入结束标志。 （2）输出单链表中所有结点的数据域值；首先获得表头结点地址，然后建立循环逐个输出数据，直到地址为空。 （3）输入x,y在第一个数据域值为x的结点之后插入结点y，若无结点x，则在表尾插入结点y;建立两个结构体指针，一个指向当前结点，另一个指向当前结点的上一结点，建立循环扫描链表。当当前结点指针域不为空且数据域等于x的时候，申请结点并给此结点数据域赋值为y，然后插入当前结点后面，退出函数；当当前结点指针域为空的时候，申请结点并给此结点数据域赋值为y，插入当前结点后面，退出函数。 （4）输入k，删除单链表中所有的结点k，并输出被删除结点的个数。建立三个结构体指针，一个指向当前结点，另一个指向当前结点的上一结点，最后一个备用；建立整形变量l=0；建立循环扫描链表。当当前结点指针域为空的时候，如果当前结点数据域等于k，删除此结点，l++，跳出循环，结束操作；如果当前结点数据域不等于k，跳出循环，结束操作。当当前结点指针域不为空的时候，如果当前结点数据域等于k，删除此结点，l++，继续循环操作；如果当前结点数据域不等于k，指针向后继续扫描。循环结束后函数返回变量l的值，l便是删除的结点的个数。

C语言链表实验报告

链表实验报告 一、实验名称 链表操作的实现--学生信息库的构建 二、实验目的 （1）理解单链表的存储结构及基本操作的定义 （2）掌握单链表存储基本操作 （3）学会设计实验数据验证程序 【实验仪器及环境】计算机 Window XP操作系统 三、实验内容 1、建立一个学生成绩信息（学号，姓名，成绩）的单链表，按学号排序 2、对链表进行插入、删除、遍历、修改操作。 3、对链表进行读取（读文件）、存储（写文件） 四、实验要求 （1）给出终结报告（包括设计过程，程序）-打印版 （2）对程序进行答辩

五、实验过程、详细内容 1、概念及过程中需要调用的函数 （1）链表的概念结点定义 结构的递归定义 struct stud_node{ int num; char name[20]; int score; struct stud_node *next; }; （2）链表的建立 1、手动输入 struct stud_node*Create_Stu_Doc() { struct stud_node *head,*p; int num,score; char name[20]; int size=sizeof(struct stud_node); 【链表建立流程图】

2、从文件中直接获取 先建立一个 (3)链表的遍历 （4 ）插入结点 （5）删除结点 （6）动态储存分配函数malloc （） void *malloc(unsigned size) ①在内存的动态存储区中分配一连续空间，其长度为size ②若申请成功，则返回一个指向所分配内存空间的起始地址的指针 ③若申请不成功，则返回NULL （值为0） ④返回值类型：(void *) ·通用指针的一个重要用途 ·将malloc 的返回值转换到特定指针类型，赋给一个指针 【链表建立流程图】 ptr ptr ptr->num ptr->score ptr=ptr->next head pt r s s->next = ptr->next ptr->next = s 先连后断 ptr2=ptr1->next ptr1->next=ptr2->next free （ptr2）

相关主题
相关文档
最新文档