(实验二链表及其应用)
实验2 链表基本操作
实验2 链表基本操作一、实验目的1．定义单链表的结点类型。
2．熟悉对单链表的一些基本操作和具体的函数定义。
3．通过单链表的定义掌握线性表的链式存储结构的特点。
4．掌握循环链表和双链表的定义和构造方法。
二、实验内容该程序的功能是实现单链表的定义和操作。
该程序包括单链表结构类型以及对单链表操作的具体的函数定义和主函数。
程序中的单链表（带头结点）结点为结构类型，结点值为整型。
/* 定义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)/* 从单链表表中查找与给定元素值相同的元素在链表中的位置 */ LinkedList LinkedListLocate(LinkedList L, DataType x)/* 向单链表中插入元素 */void LinkedListInsert(LinkedList L,int i,DataType x)/* 从单链表中删除元素 */void LinkedListDel(LinkedList L,DataType x)/* 用尾插法建立单链表 */LinkedList LinkedListCreat( )//---------------------程序示例---------------------//#include<stdlib.h>#include<stdio.h>/* 定义ElemType为int类型 */typedef int ElemType;#define TRUE 1#define FALSE 0#define flag -1/* 单链表的结点类型 */typedef struct LNode{ElemType data;struct LNode *next;} LNode,*LinkedList;/* 初始化单链表 */LinkedList LinkedListInit(){LinkedList L;L=(LinkedList)malloc(sizeof(LNode));L->next=NULL;printf("成功初始化链表\n");return L;}/* 清空单链表 */void LinkedListClear(LinkedList L){L->next=NULL;}/* 检查单链表是否为空 */int LinkedListEmpty(LinkedList L){if (L->next==NULL) return TRUE;else return FALSE;}/* 遍历单链表 */void LinkedListTraverse(LinkedList L){LinkedList p;p=L->next;while (p!=NULL){printf("%d ",p->data);p=p->next;}}//求链表长度int LinkedListLength (LinkedList L){LinkedList p;int j;p=L->next;j=0;while (p!=NULL){j++;p=p->next;}return j;}//LinkedList LinkedListGet (LinkedList L, int i){LinkedList p;int j;p=L->next;j=1;while (p!=NULL && j<i ){p=p->next;j++;}if (j==i) return p;else return NULL;}LinkedList LinkedListLocate ( LinkedList L, ElemType x) {LinkedList p;p=L->next;while ( p!=NULL && p->data != x)return p;}void LinkedListInsert(LinkedList L, int i, ElemType x) {LinkedList pre,p,s;int j;pre=L;j=1;p=L->next;while (pre&&j<i){pre=p;p=p->next;j++;}if (pre==NULL){printf("给的i值超过了表长");exit(0);}s=(LNode *)malloc(sizeof(LNode));s->data=x;pre->next=s;s->next=p;}void LinkedListDel (LinkedList L,ElemType x){LinkedList pre,p;int j;pre=L;j=1;p=L->next;while (p&&p->data!=x){pre=p;p=p->next;j++;}if (p==NULL){printf("表中没有值为x的结点");}pre->next=p->next;free(p);}LinkedList LinkedListCreat( ){LinkedList L=LinkedListInit(),p,r;ElemType x;r=L;printf("please input data,input -1 is end\n");scanf("%d",&x);while (x!=flag){p=(LinkedList)malloc(sizeof(LNode));p->data=x;r->next=p;r=p;scanf("%d",&x);}r->next=NULL;return L;}int main1(){int quit=0;int i;ElemType e;LinkedList L;while (!quit){int d;printf("please input the operation\n");printf("1.初始化链表 2.清空链表3.求链表长度4.检查链表是否为空\n"); printf("5.遍历链表 6.从链表中查找元素\n");printf("7.从链表中查找与给定元素值相同的元素在顺序表中的位置\n"); printf("8.向链表中插入元素9. 从链表中删除元素10.创建一个单链表\n"); printf("其他键退出。
实验二链表的实现和应用[最新]
![实验二链表的实现和应用[最新]](https://img.taocdn.com/s3/m/0366383ccec789eb172ded630b1c59eef8c79a2c.png)
实验二链表的实现和应用一、实验目的掌握线性表的链式存储结构设计与基本操作的实现二、实验内容与要求⑴定义线性表的链式存储表示；⑵基于所设计的存储结构实现线性表的基本操作；⑶编写一个主程序对所实现的线性表进行测试；⑷线性表的应用：①设线性表L1和L2分别代表集合A和B，试设计算法求A和B的并集C，并用线性表L3代表集合C；②设线性表L1和L2中的数据元素为整数，且均已按值非递减有序排列，试设计算法对L1和L2进行合并，用线性表L3保存合并结果，要求L3中的数据元素也按值非递减有序排列。
三、数据结构设计在主函数中实现函数的调用，从而实现线性表的插入、删除、创建、显示等。
四、测试结果通过输入不同的数字（1~6）实现不同的操作，在两个线性表结合时，线性表二在源程序中已给出的，通过操作可以得到非单调递减的有序数列五、心得体会在写程序的过程中要注意分析，参照其他标准程序，多上机运行一点点的改正错误，这样才会有所提高。
MAIN.C 方丽平信计1203班1130112321 最后修改时间2014/3/31#include<stdio.h>#include<stdlib.h>#define maxsize 1024typedef int datatype;typedef struct node{datatype data;struct node * next;}linkList;int main(){linkList * CREATE();int INSERT(linkList *head, int value, int position);int DELETE(linkList *head, int position);int DISPLAY(linkList *head);linkList * COMBINE(linkList *head1, linkList *head2); linkList * head1;linkList * head2;linkList * head3;linkList * head;linkList * p1,* p2,* s1,* s2,* r1,* r2;int position, value, i;head1 = malloc(sizeof(linkList));r1 = head1;head2 = malloc(sizeof(linkList));r2 = head2;for(i = 0; i< 20; i++){s1 = malloc(sizeof(linkList));s1 ->data = i;r1 ->next = s1;r1 = s1;s2 = malloc(sizeof(linkList));s2 ->data = i + 2;r2 ->next = s2;r2 = s2;}r2 -> next = NULL;r1 -> next = NULL;while(1){printf("the program \n");printf("can realize to create,insert,delete,display,etc\n"); printf("1:create the ranked list\n");printf("2:insert a data\n");printf("3:delete a data\n");printf("4:display all the data\n");printf("5:Combine two link lists of operation\n"); printf("6:return,end of the program\n");printf("selection of operation\n");scanf("%d",&i);while ( i < 1 || i > 6 ){printf("please input again\n");scanf("%d",&i);}switch(i){case 1:head = CREATE();break;case 2:/*INSERT(p);*/printf("Please input insert place\n");scanf("%d",&position);printf("Please input insert value\n");scanf("%d",&value);INSERT(head, value, position);break;case 3:printf("Please input delete position\n");scanf("%d",&value);DELETE(head, position);break;case 4:DISPLAY(head);break;case 5:printf("The list 1:\n");DISPLAY(head1);printf("The list 2:\n");DISPLAY(head2);printf("The combine list:\n");head3 = COMBINE(head1, head2);DISPLAY(head3);break;case 6:exit(0);break;}}}linkList * CREATE(){int value;linkList * head,* s,* r;head = malloc(sizeof(linkList));r = head;printf("input the data of the number,input 55 over!");scanf("%d",&value);do{s = malloc(sizeof(linkList));s ->data = value;r ->next = s;r = s;printf("input the data of the number");scanf("%d",&value);}while(value != 55);r -> next = NULL;return head;}int INSERT(linkList *head,int value, int position){int j = 1;linkList *p,*s,*n;s = malloc(sizeof(linkList));s ->data = value;p = head;printf("Note:if the position is greater than the length of the table will be put in the final");while(j < position){if( (p -> next) != NULL ){p = p -> next;}j ++;}n = p -> next;s -> next =n;p -> next = s;return 0;}int DELETE(linkList *head, int position){int j;linkList *p;linkList *s;p = head;printf("Note:if the position is greater than the length of the table will be delete nothing!");for(j = 1;j < position; j ++){if( (p -> next) != NULL ){p = p -> next;}else{return 0;}}s = p -> next;if((s -> next) != NULL){(*p).next = (*s).next;}s = NULL;return 0;}int DISPLAY(linkList *head){linkList *p;int i;i = 0;p = head -> next;while(p != NULL){printf("%5d",(*p).data);p = p -> next;i ++;if(i % 5 == 0)printf("\n");}return 0;}linkList * COMBINE(linkList *head1, linkList *head2) {linkList *head,*r;linkList *p1, *p2,*s;head = malloc(sizeof(linkList));r = head;p1 = malloc(sizeof(linkList));p2 = malloc(sizeof(linkList));p1 = head1 -> next;p2 = head2 -> next;do{s = malloc(sizeof(linkList));if( (p1 != NULL) && (p2 != NULL) ){if(p1 -> data < p2 -> data ){s -> data = p1 -> data;p1 = p1 ->next;}else{s -> data = p2 -> data;p2 = p2 ->next;}}else if( (p1 != NULL) && (p2 == NULL) ){s -> data = p1 -> data;p1 = p1 ->next;}else if( (p2 != NULL) && (p1 == NULL) ){s -> data = p2 -> data;p2 = p2 ->next;}r ->next = s;r = s;}while( (p1 != NULL) || (p2 != NULL) );return head;}。
实验二 链表的基本操作
实验二链表的基本操作链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。
链表的基本操作包括插入、删除和查找节点，这些操作在实际编程中非常常见且重要。
我们来看链表的插入操作。
链表的插入操作可以将新节点插入到链表的任意位置，包括链表的头部、尾部或者中间位置。
插入操作的具体步骤如下：1. 创建一个新节点，并为新节点赋值。
2. 将新节点的指针指向原链表中要插入位置的前一个节点。
3. 将原链表中要插入位置的前一个节点的指针指向新节点。
4. 将新节点的指针指向原链表中要插入位置的后一个节点。
接下来是链表的删除操作。
链表的删除操作可以删除链表中的任意节点，包括链表的头部、尾部或者中间位置。
删除操作的具体步骤如下：1. 找到要删除的节点的前一个节点。
2. 将要删除的节点的前一个节点的指针指向要删除的节点的下一个节点。
3. 释放要删除的节点的内存空间。
最后是链表的查找操作。
链表的查找操作可以根据节点的值或者位置来查找节点。
查找操作的具体步骤如下：1. 遍历链表，依次比较节点的值或者位置，直到找到目标节点。
2. 返回目标节点的值或者位置。
除了基本的插入、删除和查找操作，链表还有一些其他的操作，如获取链表的长度、反转链表等。
获取链表的长度可以通过遍历链表并计数节点的数量来实现。
反转链表可以通过修改节点的指针的指向来实现，具体步骤如下：1. 遍历链表，依次修改每个节点的指针的指向，将指针指向上一个节点。
2. 最后将头节点的指针指向空。
链表的基本操作在实际编程中非常常见且重要。
它们可以用于实现各种功能和算法，如链表的排序、合并两个链表等。
在使用链表的过程中，我们需要注意链表为空或者操作位置无效的情况，以避免出现错误。
链表是一种常见的数据结构，具有灵活性和高效性。
了解链表的基本操作对于编程非常重要，它们可以帮助我们实现各种功能和算法。
通过学习和掌握链表的基本操作，我们可以更好地应用链表来解决实际问题。
实验2-链表的应用
实验2 链表的应用一、实验目的●了解并掌握链表的概念与定义●能够实现并运用链表●熟练运用链表的基本操作二、实验环境●个人计算机一台，CPU主频1GHz以上，1GB以上内存，2GB以上硬盘剩余空间。
●Windows2000、Windows XP或Win 7操作系统●Code::Blocks(版本12.11或近似版本，英文版)，或VC++ 6.0三、实验内容1 基本部分(必做)1．单向链表的创建与操作设单向链表中节点的数据域的数据类型为整型，编写函数实现以下操作：（1）实现单向链表的创建（包括初始化）与输出操作，节点的个数及节点的数据由用户输入。
（源代码：ds3-1.c）（2）查找给定的单链表中的第i个节点，并将其地址返回。
若不存在第i 个节点，则返回空地址。
（源代码：ds3-2.c）（3）查找给定的单链表中值为n的节点，并将其地址返回。
若不存在值为n的节点，则返回空地址。
同时，还应通过参数传回该节点的序号。
（源代码：ds3-3.c）（4）删除给定的单链表中的第i个节点，成功返回1，失败返回0。
（源代码：ds3-4.c）（5）删除给定的单链表中值为n的节点，成功返回1，失败返回0。
（源代码：ds3-5.c）（6）在给定的单链表的第i位上插入值为n的节点。
（源代码：ds3-6.c）（7）在给定单链表的值为m的节点的前面插入一个值为n的节点。
（源代码：ds3-7.c）2．双向循环链表的创建与操作设双向链表中节点的数据域的数据类型为整型，编写函数实现以下操作：（1）实现双向循环链表的创建（包括初始化）与输出操作，节点的个数及节点的数据可以在程序中直接确定。
（源代码：ds4-1.c）（2）删除给定的双向循环链表中值为n的节点，成功返回1，失败返回0。
（源代码：ds4-2.c）（3）在给定的双向循环链表中的第i位上插入值为n的节点，成功返回1，失败返回0。
（源代码：ds4-3.c）2 提高部分(选做)已知链表A和B中节点的值都按照从小到大的顺序排序，且任何两个节点的值都不相同。
数据结构-实验2-链表的基本操作
实验2链表的基本操作一、需求分析1，初始化链表2，调用插入函数建立一个链表3，链表的插入和删除4，链表元素的查找4，将链表分为奇链表和偶链表5，链表的逆置二、概要设计1.基础题1)编写链表基本操作函数typedefstruct list{Int data;Struct list* next}LIST;LIST* InitList() //初始化LIST* InsertList(LIST * L,int item,int re) //向链表指定位置插入元素LIST* InsertOrderList(LIST *L,int item) //向有序链表指定位置插入元素void FindList(LIST*L, int item)//查找链表中的元素void display(LIST *L)//显示链表void divide(LIST* La, LIST *Lb)//拆分链表LIST * turn(LIST *L)//转置链表2)调用上述函数实现下列操作，操作步骤如下。
A.初始化链表B.调用插入函数建立一个链表C.在链表中寻找指定的元素D.在链表中删除指定值的元素E.遍历并输出链表注意每完成一个步骤，必须及时输出顺序表元素，便于观察操作结果2.提高题a)将一个首结点指针为a的单链表A分解成两个单链表A和B，其首结点指针分别为a，b，使得链表A中含有原链表A中序号为奇数的元素，而链表B中含有原链表A中序号为偶数的元素，且保持原来的相对顺序。
解题思路将单链表A中含有序号为偶数的元素删除，并在删除时把这些结点链接起来构成单链表B即可。
b)将链接存储线性表逆置，即最后一个结点变成第一个结点原来倒数第二个结点变成第二个结点，如此等等。
解题思路依次遍历源链表，将每个元素依次赋给一个新链表并将新链表从后到前连接。
3.主函数void main(){LIST *L1,*L2,*L3;int i;L1=InitList();printf("创建链表L1:\n");for(i=1;i<=5;i++){L1=InsertList(L1,i*2,i);}display(L1);for(i=1;i<=9;i+=4){printf("在L1的%d位置插入3:\n",i);L1=InsertList(L1,3,i);display(L1);}//有序表L2 = InitList();printf("\n有序表实验:\n");printf("创建链表L2:\n");for (i = 1; i <= 5; i++){L2 = InsertList(L2, i * 2, i); }display(L2);for (i = 1; i <= 13; i +=6 ){printf("插入%d:\n",i);L2 = InsertOrderList(L2,i);display(L2);}//删除元素实验printf("\n删除元素实验:\n"); printf("L2插入1:\n", i);L2 = InsertList(L2,1,1);display(L2);for (i = 1; i < 12; i += 5){printf("删除L2中%d\n",i);L2 = DeleteList(L2, i);display(L2);}//查找printf("\n查找元素实验:\n"); printf("查找L2中%d\n", 13); FindList(L2,13);printf("查找L2中%d\n", 6); FindList(L2, 6);//分解printf("\n分解实验:\n");printf("L2:\n");display(L2);L3 = InitList();printf("将L2偶序数拆分到L3\n"); divide(L2,L3);printf("L2:\n");display(L2);printf("L3:\n");display(L3);printf("\n逆序实验:\n");printf("L2:\n");display(L2);L2 = turn(L2);printf("转置L2:\n");display(L2);}三、详细分析插入实验，函数能够在链表前、中、后插入元素，并判断插入位置是否超过链表长度，若超过则接入链尾。
实验2 单链表的实现与应用
实验报告课程名称数据结构实验项目单链表的实现及应用实验仪器PC机一台学院____ ____专业班级/学号_______________________学生姓名_______________________实验日期_______________________成绩_______________________指导教师________ _________（课程上机）实验报告实验课程名称: 数据结构专业: 班级:}}2、package ex2;public class SortedSinglyList<T extends Comparable <? super T>> extendsSinglyList<T>{//构造空排序单链表public SortedSinglyList(){super(); //默认调用父类构造方法SinglyList() }public SortedSinglyList(SinglyList<T> list){super(); //构造空单链表for (Node<T> p=list.head.next; p!=null; p=p.next)//直接插入排序，每趟插入1个元素this.insert(p.data); //排序单链表按值插入}//构造，将values数组中的所有对象按值插入public SortedSinglyList(T values[]){super();for(int i=0;i<values.length;i++)this.insert(values[i]);}public void set(int i, T x) //设置第i个元素值为x{throw new UnsupportedOperationException("set(int i, T x)"); ////不支持父类方public static void main(String[] args){new Del1(2,2);}}b、package ex2;public class Del2 {public Del2(int mink,int maxk){Integer[] values={1,3,9,17,34};SortedSinglyList<Integer> list = new SortedSinglyList<Integer>(values);System.out.println(list.toString());Node<Integer> p=list.head;int j=0;while(p.next!=null && p.next.data<=mink){p=p.next;j++;}while(p.next!=null &&p.next.data<maxk){list.remove(j);}System.out.println("list="+list.toString());}public static void main(String args[]){new Del2(2,18);}}public static void main(String args[]){new Meger();}}4、package Poly;public interface Subible<T> //可相加接口，T表示数据元素的数据类型{public void sub(T t); //+=加法，约定两元素相加规则public boolean removable(); //约定删除元素条件}package Poly;//项类，一元多项式的一项，实现可比较接口和可相加接口public class TermX implements Comparable<TermX>, Subible<TermX>{protected int coef, xexp; //系数，x指数（可为正、0）public TermX(int coef, int xexp) //构造一项{this.coef = coef;this.xexp = xexp;}public TermX(TermX term) //拷贝构造方法{this(term.coef, term.xexp);}//以“系数x^指数”的省略形式构造一元多项式的一项。
实验二 链表及其应用
实验二链表及其应用一、实验目的及要求1、实验目的(1)熟悉VC++上机环境，进一步掌握C语言的结构特点。
(2)掌握线性表的链式存储结构即单链表的定义及C语言实现。
(3)掌握线性表在链式存储结构即单链表中的各种基本操作。
(4)掌握栈和队列的链式存储结构的表示和实现。
2、实验要求(1)用链式存储结构实现单链表（和单向循环链表）的建立、查找和删除等运算。
(2)编写完整程序完成下面的实验内容并上机运行。
(3)整理并上交实验报告。
二、实验内容1.约瑟夫环的问题：设有n个人围坐在圆桌周围，现从某个位置 i 上的人开始报数，数到 m 的人就站出来。
下一个人，即原来的第m+1个位置上的人，又从1开始报数，再是数到m的人站出来。
依次重复下去，直到全部的人都站出来，按出列的先后又可得到一个新的序列。
由于该问题是由古罗马著名的史学家Josephus提出的问题演变而来，所以通常称为Josephus 问题。
例如：当n=8,m=4,i=1时，得到的新序列为：4，8，5，2，1，3，7，6用单向循环链表存储结构模拟此过程。
三.主要仪器设备PC机，Windows XP操作平台，Visual C++四．实验步骤1.理解约瑟夫环的内容以及定义2.用链表实现约瑟夫环的过程包含两方面，第一，链表建立约瑟夫环。
第二，链表中进行报数人数的循环以及删除3.流程图如下：五．程序源代码#include<iostream> using namespace std;struct Node{ int data;Node *next;};int main(){int n,m;cout<<"人数：";cin>>n;cout<<"报数：";cin>>m;int k=0;Node *p,*q,*r;p=q=new Node; //创建第一个节点p->data=1;for(int i=2; i<=n; i++) //建立链表{ r=new Node;r->data=i;q->next=r;q=r;}q->next=p; //构成一个"环"q=p;while(q->next!=q){ k++; //k为1,2,3...报数if(k==m) //报到m时，删除q所指结点 {p->next=q->next;cout<<q->data<<endl;delete q;q=p->next;k=0;}else{ p=q; q=q->next; }}cout<<q->data<<endl;}六．讨论与结论在进行链表建立的约瑟夫环过程中，环的建立遇到一些困难，比如指针总是没有很好的指向下一个节点，在赋值的过程中也出现了一些问题，不过在同学和老师的帮助下，解决了这个问题。
实验二 链表的基本操作
实验二链表的基本操作学号：姓名：实验日期：1、实验目的（1）学会单链表结点的定义（2）掌握单链表的基本运算，熟悉对单链表的一些基本操作和具体函数的定义。
（3）加深对链表的理解，逐步培养解决实际问题的编程能力。
2、实验要求（1）熟练掌握链表的存储结构及其基本操作。
（2）理解所给出的算法，掌握链表在实际中的应用。
（3）将上机程序调试通过，并能独立完成一至两个拓展题目。
3、实验内容从键盘输入数据，创建一个初始链表。
通过调用定义的基本操作函数来实现单链表上的插入、删除元素等操作。
调试程序并对相应的输出作出分析；修改输入数据，预期输出并验证输出的结果。
加深对有关算法的理解。
4、实验方法第一步:定义单链表的存储结构。
第二步：编写单链表操作的具体函数定义。
第三步：使用定义的单链表并调用单链表的一些操作，实现具体运算。
具体函数的定义有：1）insert(L,i,x)在单链表的第i个元素之前插入一个新元素x.2）deletet(L,i) 删除单链表的第i个元素。
3）listprint(L) 输出单链表。
5、实验步骤所给实例程序经调试修改如下：#include "stdio.h"#include "malloc.h" /*包含动态分配内存函数*/#define NULL 0#define TRUE 1#define FALSE 0typedef int elemtype;typedef struct node /*链表结点类型定义*/{elemtype data; /*结点数据域*/struct node *next; /*结点的指针域*/}linklist;linklist *creatlist() /*创建链表函数-以按下任意建开始创建，以输入字符'？'表示结束标志*/{char ch;int x;linklist *head,*r,*p;p=(linklist*)malloc(sizeof(linklist));head=p;r=p;ch=getchar();while(ch!='?'){scanf("%d",&x);p=(linklist*)malloc(sizeof(linklist));p->data=x;p->next=NULL;r->next=p;r=r->next;ch=getchar();}return (head);}int locate(linklist *head,elemtype k) /*定位检索函数-如链表中存在值为k的结点，则返回真，否则返回假*/{linklist *s;s=head->next;while(s!=NULL)if(s->data!=k)s=s->next;elsereturn TRUE;return FALSE;}void insert(linklist *head,int i,elemtype x) /*在链表head的第i个位置插入元素x*/{linklist *s,*p;int j;p=head;j=0;while(p->next&&j<i-1){p=p->next;j++;}if(!p||j>i-1) printf("error!");s=(linklist *)malloc(sizeof(linklist));if(!s) printf("overflow!");s->data=x;s->next=p->next;p->next=s;}void delete1(linklist *head,int i) /*删除链表的第i个结点*/{int j=0;linklist *p,*s,*q;p=head;j=0;while((p->next!=NULL)&&(j<i-1))j++;}if(p->next!=NULL){q=p->next;p->next=p->next->next;free(q);}else printf("illegal delete position,delete failed!");}void print(linklist *head) /*打印出链表head中各个结点的值*/{linklist *p;p=head->next;while(p!=NULL){printf("%d ",p->data);p=p->next;}printf("\n");}void main() /*主函数*/{linklist *head; /*定义指向链表的指针head*/int x;int i,j;printf("please input the initial node and start by any key('?'execpt)end with '?'\n");head=creatlist();printf("we have created a linklist as follow:\n");print(head);printf("now start search,please input the search value:");scanf("%d",&x);printf("\n");if(locate(head,x)) printf("exsist!\n");elseprintf("not exsist!\n");printf("start insert operation,please input insert position:");scanf("%d",&i);insert(head,i,x);printf("after insertion:\n");print(head);printf("now start delete operation,input the delete position please:");scanf("%d",&j);delete1(head,j);printf("after deletion:\n");print(head);}6、思考题调试好上述程序，拓展内容：（1）定义一个逆置函数diverse(L),把链表进行逆置。
实验二链表操作实现
实验⼆链表操作实现实验⼆链表操作实现实验⽇期：2017 年 3 ⽉16 ⽇实验⽬的及要求1. 熟练掌握线性表的基本操作在链式存储上的实现；2. 以线性表的各种操作（建⽴、插⼊、删除、遍历等）的实现为重点；3. 掌握线性表的链式存储结构的定义和基本操作的实现；4. 通过本实验加深对C语⾔的使⽤（特别是函数的参数调⽤、指针类型的应⽤）。
实验内容已知程序⽂件已给出学⽣⾝⾼信息链表的类型定义和基本运算函数定义。
（1）链表类型定义typedef struct {int xh; /*学号*/float sg; /*⾝⾼*/int sex; /*性别，0为男⽣，1为⼥⽣*/} datatype;typedef struct node{datatype data; /*数据域*/struct node *next; /*指针域*/} LinkNode, *LinkList;（2）带头结点的单链表的基本运算函数原型LinkList initList();/*置⼀个空表（带头结点）*/void createList_1(LinkList head);/*创建单链表*/void createList_2(LinkList head);/* 创建单链表*/void sort_xh(LinkList head);/*单链表排序*/void reverse(LinkList head);/*对单链表进⾏结点倒置*/void Error(char *s);/*⾃定义错误处理函数*/void pntList(LinkList head);/*打印单链表*/void save(LinkList head,char strname[]);/*保存单链表到⽂件*/任务⼀创建程序⽂件，其代码如下所⽰，理解LinkList类型和基本运算函数后回答下列问题。
#include <>#include <>/*单链表结点类型*/typedef struct {int xh; /*学号*/float sg; /*⾝⾼*/int sex; /*性别，0为男⽣，1为⼥⽣*/} datatype;typedef struct node{datatype data; /*数据域*/struct node *next; /*指针域*/} LinkNode, *LinkList;/*带表头的单链表的基本运算函数*/LinkList initList();/*置⼀个空表（带头结点）*/void createList_1(LinkList head);/*创建单链表*/void createList_2(LinkList head);/*创建单链表*/void sort_xh(LinkList head);/*单链表排序*/void reverse(LinkList head);/*单链表倒置*/void Error(char *s);/*⾃定义错误处理函数*/void pntList(LinkList head);/*打印单链表*/void save(LinkList head,char strname[]);/*保存单链表到⽂件*/ /*置⼀个空表*/LinkList initList(){ LinkList p;p=(LinkList)malloc(sizeof(LinkNode));p->next=NULL;return p;}/*创建单链表*/void createList_1(LinkList head){ FILE *fp;int xh;float sg;int sex;LinkList p;if((fp=fopen("","r"))==NULL){ Error("can not open file !");return ;}while(!feof(fp)){ fscanf(fp,"%d%f%d",&xh,&sg,&sex); p=(LinkList)malloc(sizeof(LinkNode)); p->=xh;p->=sg;p->=sex;p->next=head->next;head->next=p;}fclose(fp);}/*创建单链表*/void createList_2(LinkList head) { FILE *fp;int xh;float sg;int sex;LinkList p,rear;if((fp=fopen("","r"))==NULL){ Error("can not open file !");return ;}rear=head;while(!feof(fp)){ fscanf(fp,"%d%f%d",&xh,&sg,&sex); p=(LinkList)malloc(sizeof(LinkNode)); p->=xh;p->=sg;p->=sex;p->next=NULL;rear->next=p;rear=p;}fclose(fp);}/*单链表排序*/void sort_xh(LinkList head){LinkList q,p,u;p=head->next;head->next=NULL;/*利⽤原表头结点建新的空表*/ while(p){ q=p; /*q为被插⼊的结点*/p=p->next;/*⽤p记录后继结点*//*遍历新链表查找插⼊位置*/u=head;while(u->next!=NULL)/*查找插⼊位置*/{ if(u->next->>q->break;u=u->next;}/*插⼊在u结点的后⾯*/q->next=u->next;u->next=q;}}/*单链表倒置*/void reverse(LinkList head){ LinkList p, r;p=head->next;head->next=NULL;while(p){ r=p;p=p->next;/*r指向结点头插到链表*/r->next=head->next;head->next=r;}}/*输出单链表*/void pntList(LinkList head){ LinkList p;p=head->next;while(p!=NULL){printf("%2d: %.2f %d\n",p->,p->,p->data .sex);p=p->next;}}/*⾃定义错误处理函数*/void Error(char *s){ printf("\n %s", s);exit(1); /*返回OS,该函数定义在中*/}/*保存单链表到⽂件*/void save(LinkList head,char strname[]){ FILE *fp;LinkList p;if((fp=fopen(strname,"w"))==NULL){ printf("can not open file !");return ;}p=head->next;while(p!=NULL){ fprintf(fp,"%2d %5.2f %2d\n",p->,p->,p->;p=p->next;}fclose(fp);}请回答下列问题：（1）由单链表结点类型定义可知，该链表结点类型名为 LinkNode ，结点的指针类型为 LinkList ，向系统申请⼀个学⽣结点空间并把起始地址存于上述结点指针变量new 中的语句是： p=(LinkList)malloc(sizeof(LinkNode)); 。
数据结构实验二链表
数据结构实验二1、实验目的∙熟练掌握线性表的链式存储结构定义及基本操作∙理解循环链表和双链表的特点和基本运算2、实验内容：建立单链表，完成链表（带表头结点）的基本操作：建立链表、插入、删除、查找、输出、求前驱、求后继、两个有序链表的合并操作。
其他基本操作还有销毁链表、将链表置为空表、求链表的长度、获取某位置结点的内容、搜索结点。
1．问题描述：利用线性表的链式存储结构,设计一组输入数据（假定为一组整数），能够对单链表进行如下操作：∙初始化一个带表头结点的空链表;∙创建一个单链表是从无到有地建立起一个链表，即一个一个地输入各结点数据，并建立起前后相互链接的关系。
又分为逆位序(插在表头)输入n 个元素的值和正位序(插在表尾)输入n 个元素的值;∙插入结点可以根据给定位置进行插入（位置插入），也可以根据结点的值插入到已知的链表中（值插入），且保持结点的数据按原来的递增次序排列，形成有序链表。
∙删除结点可以根据给定位置进行删除（位置删除），也可以把链表中查找结点的值为搜索对象的结点全部删除（值删除）;∙输出单链表的内容是将链表中各结点的数据依次显示，直到链表尾结点;∙求前驱结点是根据给定结点的值，在单链表中搜索其当前结点的后继结点值为给定的值，将当前结点返回;∙求后继结点是根据给定结点的值，在单链表中搜索其当前结点的值为给定的值，将后继结点返回;∙两个有序链表的合并是分别将两个单链表的结点依次插入到第3 个单链表中，继续保持结点有序;编写主程序，实现对各不同的算法调用。
其它的操作算法描述略。
2．实现要求：对链表的各项操作一定要编写成为C（C++）语言函数，组合成模块化的形式，还要针对每个算法的实现从时间复杂度和空间复杂度上进行评价。
∙“初始化算法”的操作结果：构造一个空的线性表L，产生头结点,并使L 指向此头结点;∙“建立链表算法”初始条件：空链存在;操作结果：选择逆位序或正位序的方法，建立一个单链表，并且返回完成的结果;∙“链表（位置）插入算法”初始条件：已知单链表L 存在;操作结果：在带头结点的单链线性表L 中第i 个位置之前插入元素e;∙“链表（位置）删除算法”初始条件：已知单链表L 存在;操作结果：在带头结点的单链线性表L 中，删除第i 个元素,并由e 返回其值;∙“输出算法”初始条件：链表L 已存在;操作结果：依次输出链表的各个结点的值;∙“求前驱算法”初始条件: 线性表L 已存在;操作结果: 若cur_e 是L 的数据元素,且不是第一个,则用pre_e 返回它的前驱;∙“求后继算法”初始条件: 线性表L 已存在;操作结果: 若cur_e 是L 的数据元素,且不是最后一个,则用next_e 返回它的后继;∙“两个有序链表的合并算法”初始条件: 线性表单链线性表La 和Lb 的元素按值非递减排列;操作结果:归并La 和Lb 得到新的单链表。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
（三）实验结果；
（四）心得体会
实验二 链表、栈及其运算
一、实验目的
1, 定义单链表的结点类型。
2． 熟悉对单链表的一些基本操作和具体的函数定义。
3． 通过单链表的定义掌握线性表的链式存储结构的特点。
4． 掌握循环链表和双链表的定义和构造方法。
和双链表的特点和基本运算
三、实验内容
1．单链表的操作
1) 键盘输入n，建立长度为n的单链表并输出；（头插、尾插 均可） 2）键盘输入x，在单链表中查找值为x的结点并删除后，输出 链表。 测试数据 1． 测试数据一 1） Input：5，这里的5表示链表长度； 2） Input：25 12 78 34 52，输出：25 12 78 34 52； 3） Input：34，输出：25 12 78 52。 2． 测试数据二 1） Input：5，这里的5表示链表长度； 2） Input：25 12 78 34 52，输出：25 12 78 34 52； 3） Input：50，输出：50 can’t found!
2．创建单链表并实现就地逆置
建立单链表时输入链表数据以‘#’号结束； 测试数据： 请输入char型数据： Abced# 逆序：d数x转换为二进制、八进 制或十六进制数。
测试数据 1）请输入x： 10 请输入数制： 2 1010 2）请输入x： 10 请输入数制： 8 12 3）请输入x： 10 请输入数制： 16 A
• 四、实验要求
– 按要求编写实验程序，将实验程序上机调试运 行，给出输出的结果，并提交实验报告，写出 调试运行程序的分析和体会。 – 注意main函数的详细设计 – 注意main函数和各操作算法函数之间的调用关 系。 – 注意各算法函数的入口参数、出口参数，
实验报告格式：
（一）题目 ；
（二）源码；