实验2 链表的基本操作

合集下载

实验2 链表基本操作

实验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("其他键退出。

链表实验报告

链表实验报告

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<stdio.h>#include<stdlib.h>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));//生成头结点 声明函数 主函数 main 创建链表函数定义CreateList 定义链表遍历函数TraverseList定义链表查询函数FindList 定义链表插入函数在链表位置第pos 节点前插入包含数据val 的节点InsertList(PNode List, int pos, int val) 插入节点 定义删除整个链表函数 DeleteTheList定义删除链表元素函数删除链表中的第pos 节点DeleteList(PNode List, int pos) 删除节点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(j<i-1 && p){p=p->next;++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(j<i-1 && p->next){p=p->next;++j;}if(!p->next || j>i-1)return -1;else{q=p->next;p->next=q->next;e=q->data;free(q);return 1;}}void combine(linklist la,linklist lb)//合并单链表{node *pa,*pb,*pc;linklist lc;pa=la->next;pb=lb->next;lc=pc=la;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;free(lb);}Status GetElem(linklist l,int i,Elemtype &e )//查找操作 {linklist p;int j;p=l->next;j=1;while(p && j<i){p=p->next;++j;}if(!p || j>i)return -2;e=p->data;return e;}void main(){linklist la,lb;int n;int i,j;Elemtype e;printf("请输入第一个链表:\n");printf("输入链表元素的个数:\n");scanf("%d",&n);la=creat(n);printf("输出链表:\n");output(la);printf("请输入要查找元素的位置:\n");scanf("%d",&i);j=GetElem(la,i,e);printf("所要查找的元素是%d\n",j);printf("请输入插入位置和元素:\n");scanf("%d%d",&i,&e);insert(la,i,e);printf("插入后的链表:\n");output(la);printf("请输入要删除的位置:\n");scanf("%d",&i);delect(la,i,e);printf("删除的那个元素是:%d\n",e);printf("输出删除后的顺序表:\n");output(la);printf("请输入第一个非递减链表:\n");printf("输入链表元素的个数:\n");scanf("%d",&n);la=creat(n);printf("输出链表:\n");output(la);printf("请输入第二个非递减链表:\n");printf("输入链表元素的个数:\n");scanf("%d",&n);lb=creat(n);printf("输出链表:\n");output(lb);combine(la,lb);printf("输出合并后的链表:\n");output(la);六.运行结果七.心得体会通过本次实验我对链表有了更深的了解,对链表的插删操作、遍历、查找等基本上掌握了。

北工大实验报告

北工大实验报告

一、实验名称数据结构实验二:链表的基本操作二、实验目的1. 理解链表的基本概念和结构。

2. 掌握链表的创建、插入、删除、查找等基本操作。

3. 提高编程能力,巩固数据结构知识。

三、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发环境:Visual Studio 2019四、实验原理链表是一种常见的线性数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。

链表具有以下特点:1. 无固定长度,可以根据需要动态地添加或删除节点。

2. 链接方式灵活,便于实现各种操作。

3. 适合存储具有动态变化的数据。

本实验主要实现以下功能:1. 创建链表:根据用户输入的数据,创建一个单链表。

2. 插入节点:在链表的指定位置插入一个新节点。

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

4. 查找节点:在链表中查找一个指定的节点。

5. 打印链表:遍历链表并打印所有节点数据。

五、实验步骤1. 创建链表```cppstruct ListNode {int data;ListNode next;ListNode(int x) : data(x), next(nullptr) {}};ListNode createList() {ListNode head = nullptr, tail = nullptr;int data;cout << "请输入链表数据(输入-1结束):" << endl; while (cin >> data && data != -1) {ListNode node = new ListNode(data);if (head == nullptr) {head = node;tail = node;} else {tail->next = node;tail = node;}}return head;}```2. 插入节点```cppvoid insertNode(ListNode head, int data, int position) { ListNode node = new ListNode(data);if (position == 0) {node->next = head;head = node;} else {ListNode current = head;for (int i = 0; i < position - 1; ++i) {if (current == nullptr) {cout << "插入位置超出链表长度!" << endl; return;}current = current->next;}node->next = current->next;current->next = node;}}```3. 删除节点```cppvoid deleteNode(ListNode head, int position) {if (head == nullptr) {cout << "链表为空!" << endl;return;}if (position == 0) {ListNode temp = head;head = head->next;delete temp;} else {ListNode current = head;for (int i = 0; i < position - 1; ++i) {if (current == nullptr) {cout << "删除位置超出链表长度!" << endl; return;}current = current->next;}if (current->next == nullptr) {cout << "删除位置超出链表长度!" << endl;return;}ListNode temp = current->next;current->next = temp->next;delete temp;}}```4. 查找节点```cppListNode findNode(ListNode head, int data) { ListNode current = head;while (current != nullptr) {if (current->data == data) {return current;}current = current->next;}return nullptr;}```5. 打印链表```cppvoid printList(ListNode head) {ListNode current = head;while (current != nullptr) {cout << current->data << " ";current = current->next;}cout << endl;}```六、实验结果与分析通过以上步骤,成功实现了链表的基本操作。

链表的基础操作

链表的基础操作

链表的基础操作链表是一种常用的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。

链表的操作包括插入、删除、查找等,下面将详细介绍链表的基础操作。

一、链表的创建链表的创建可以通过逐个节点的方式进行,首先创建一个头节点,然后创建其他节点,并将它们的指针串联起来即可。

代码如下:```pythonclass Node:def __init__(self, data):self.data = dataself.next = Nonehead = Node(1)node2 = Node(2)node3 = Node(3)head.next = node2node2.next = node3```二、链表的插入链表的插入操作包括在链表的开头、中间和末尾插入节点。

具体操作如下:1. 在链表的开头插入节点:```pythonnew_node = Node(0)new_node.next = headhead = new_node```2. 在链表的中间插入节点:假设要在node2和node3之间插入一个新的节点new_node:```pythonnew_node = Node(2.5)new_node.next = node3node2.next = new_node```3. 在链表的末尾插入节点:假设要在链表末尾插入一个新的节点new_node:```pythonnew_node = Node(4)node3.next = new_node```三、链表的删除链表的删除操作可以删除链表中的任意一个节点,具体操作如下:1. 删除链表的头节点:```pythonhead = head.next```2. 删除链表的中间节点:假设要删除node2节点:```pythonnode2.next = node3.next```3. 删除链表的末尾节点:需要遍历链表,找到倒数第二个节点,将其指针指向None即可。

c语言数据结构链表基本操作

c语言数据结构链表基本操作

c语言数据结构链表基本操作C语言数据结构链表基本操作链表是一种常见的数据结构,用于存储和操作一系列的数据元素。

在C语言中,链表的实现通常使用指针来连接各个节点,每个节点包含数据和指向下一个节点的指针。

本文将介绍链表的基本操作,包括创建链表、插入节点、删除节点和遍历链表。

1. 创建链表创建链表的第一步是定义一个指向链表头节点的指针。

链表头节点是链表的起始位置,通常不存储数据,只用于指向第一个真正存储数据的节点。

可以使用malloc函数动态分配内存空间来创建链表节点,并将头指针指向该节点。

2. 插入节点在链表中插入节点分为两种情况:在链表头部插入和在链表中间或尾部插入。

在链表头部插入节点时,只需要创建一个新节点,并将新节点的指针指向原来的头节点,然后更新头指针指向新节点即可。

在链表中间或尾部插入节点时,需要先找到插入位置的前一个节点,然后创建新节点,并将新节点的指针指向原来的下一个节点,再将前一个节点的指针指向新节点。

3. 删除节点删除链表中的节点需要找到要删除节点的前一个节点,然后修改前一个节点的指针指向要删除节点的下一个节点,最后释放要删除节点的内存空间。

4. 遍历链表遍历链表是指依次访问链表中的每个节点,并对节点进行操作。

可以使用循环结构和指针来实现链表的遍历。

从链表头节点开始,通过指针指向下一个节点,直到指针为空或指向链表尾部。

链表的基本操作是在实际编程中经常使用的,它可以灵活地插入、删除和修改节点,适用于各种场景。

例如,可以使用链表来实现栈、队列等数据结构,也可以用于在内存中动态存储数据。

在使用链表时,需要注意以下几点:- 确保链表的头指针始终指向链表的起始位置,避免丢失链表的引用。

- 在插入和删除节点时,要注意更新链表的指针,以保持链表的正确性。

- 在释放链表内存空间时,要遍历链表并依次释放每个节点的内存空间,防止内存泄漏。

链表是一种重要的数据结构,灵活性和可扩展性使其在实际应用中具有广泛的用途。

实验二 链表的基本操作

实验二 链表的基本操作

实验二链表的基本操作链表是一种常见的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。

链表的基本操作包括插入、删除和查找节点,这些操作在实际编程中非常常见且重要。

我们来看链表的插入操作。

链表的插入操作可以将新节点插入到链表的任意位置,包括链表的头部、尾部或者中间位置。

插入操作的具体步骤如下:1. 创建一个新节点,并为新节点赋值。

2. 将新节点的指针指向原链表中要插入位置的前一个节点。

3. 将原链表中要插入位置的前一个节点的指针指向新节点。

4. 将新节点的指针指向原链表中要插入位置的后一个节点。

接下来是链表的删除操作。

链表的删除操作可以删除链表中的任意节点,包括链表的头部、尾部或者中间位置。

删除操作的具体步骤如下:1. 找到要删除的节点的前一个节点。

2. 将要删除的节点的前一个节点的指针指向要删除的节点的下一个节点。

3. 释放要删除的节点的内存空间。

最后是链表的查找操作。

链表的查找操作可以根据节点的值或者位置来查找节点。

查找操作的具体步骤如下:1. 遍历链表,依次比较节点的值或者位置,直到找到目标节点。

2. 返回目标节点的值或者位置。

除了基本的插入、删除和查找操作,链表还有一些其他的操作,如获取链表的长度、反转链表等。

获取链表的长度可以通过遍历链表并计数节点的数量来实现。

反转链表可以通过修改节点的指针的指向来实现,具体步骤如下:1. 遍历链表,依次修改每个节点的指针的指向,将指针指向上一个节点。

2. 最后将头节点的指针指向空。

链表的基本操作在实际编程中非常常见且重要。

它们可以用于实现各种功能和算法,如链表的排序、合并两个链表等。

在使用链表的过程中,我们需要注意链表为空或者操作位置无效的情况,以避免出现错误。

链表是一种常见的数据结构,具有灵活性和高效性。

了解链表的基本操作对于编程非常重要,它们可以帮助我们实现各种功能和算法。

通过学习和掌握链表的基本操作,我们可以更好地应用链表来解决实际问题。

实现双向链表的基本操作

一、什么是双向链表双向链表,也称双向链式线性表,是一种常见的数据结构,它由多个节点组成,每个节点都包含指向前一个节点和后一个节点的指针。

与单向链表不同的是,双向链表的每个节点都有两个指针,这样可以在不遍历整个链表的情况下,方便地访问任何一个节点。

二、基本操作1. 初始化初始化双向链表需要定义一个头节点,该节点不存储实际数据,只用于标记链表的开始位置。

头节点的前驱指针和后继指针都指向NULL ,表示链表为空。

2. 插入节点插入节点是双向链表最常见的操作,它分为三种情况:在链表头部插入、在链表尾部插入和在链表中间插入。

头部插入:先创建一个新节点,并将该节点的后继指针指向当前头节点,将头节点的前驱指针指向新节点,再将链表的头节点指向新节点,完成插入。

尾部插入:先找到链表的尾节点,再创建一个新节点,并将新节点的前驱指针指向当前尾节点,将尾节点的后继指针指向新节点,再将新节点的后继指针指向 NULL ,完成插入。

中间插入:先找到要插入节点的位置,即该节点前一个节点的后继指针和后一个节点的前驱指针,分别指向新节点。

新节点的前驱指针指向前一个节点,后继指针指向后一个节点,完成插入。

3. 删除节点删除节点也分为三种情况:删除头节点、删除尾节点和删除中间节点。

头节点删除:将头节点的后继节点作为新的头节点,将新头节点的前驱指针指向 NULL ,完成删除。

尾节点删除:将尾节点的前驱节点作为新的尾节点,将新尾节点的后继指针指向 NULL ,完成删除。

中间节点删除:先找到要删除节点的位置,即该节点前一个节点的后继指针和后一个节点的前驱指针,分别指向该节点的前一个节点和后一个节点,完成删除。

4. 查找节点查找节点可以通过遍历链表来实现,在双向链表中,由于每个节点都有前驱和后继指针,因此可以从前向后或从后向前进行查找。

需要注意的是,由于双向链表的查找操作需要遍历整个链表,因此效率较低,不适用于大规模数据的查找。

5. 输出链表输出链表可以通过遍历链表来实现,从头节点开始,依次输出每个节点的数据。

数据结构-实验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);}三、详细分析插入实验,函数能够在链表前、中、后插入元素,并判断插入位置是否超过链表长度,若超过则接入链尾。

实验二 单链表基本操作

实验二单链表基本操作一、实验目的1.掌握握单链表的基本操作:新建、插入、删除、查找等运算。

二、实验要求1.认真阅读和掌握本实验的程序。

2.上机运行本程序。

3.保存和打印出程序的运行结果,并结合程序中的问题进行分析。

三、实验内容单链表基本操作的实现,这个程序中演示了单链表的创建、插入、删除和查找。

程序如下:#include<malloc.h>typedef struct node{int data;struct node *next;} NODE;/******************************************/NODE *Create()//问题1:该函数创建的带头结点的单链表,还是不带头结点的单链表?{NODE *p,*head;int x;head=(NODE *)malloc(sizeof(NODE));head->next=NULL;printf("Input data,-1 to End!\n");scanf("%d",&x);while(x!=-1){p=(NODE *)malloc(sizeof(NODE));p->data=x;p->next=head->next;head->next=p;scanf("%d",&x);}return(head);}/******************************************/void Output(NODE *head){NODE *p;p=head;printf("Begin to dump the LinkList...\n");while(p->next!=NULL){printf("->%d",p->next->data);p=p->next;}printf("\nThe LinkList ended!\n");}/******************************************/int Listlen(NODE *head){int i=0;NODE *p=head;while(p->next!=NULL){i++;p=p->next;}return(i);}/******************************************/int Get(NODE *head,int i)//问题2:将该函数修改成返回第i个元素的指针,若不存在,返回空{int j=0;NODE *p=head;while(p->next&&j<i){j++;p=p->next;}if(!p->next||j>i) return(0);else return(p->data);}/******************************************/void Del(NODE *head,int i){NODE *p=head;int j=0;while(p->next&&j<i-1){j++;p=p->next;}if(!p->next||j>i-1) printf("the position is wrong\n");elsep->next=p->next->next;}/******************************************/void Ins(NODE *head,int i,int e){NODE *p=head,*q;int j=0;while(p->next&&j<i-1){j++;p=p->next;}if(!p->next&&j>i-1) printf("Wrong position\n" );else{q=(NODE *)malloc(sizeof(NODE));q->data=e;q->next=p->next;p->next=q;}}/******************************************/main(){NODE *head;int length;int i,element;head=Create();Output(head);//以下函数调用(求长度、插入、删除、查找)能否改成菜单形式?如何改?length=Listlen(head);printf("the length of the link is %d\n",length);printf("input the order :\n");scanf("%d",&i);element=Get(head,i);printf("the element of the order is %d\n",element);printf("input the del position \n");scanf("%d",&i);Del(head,i);Output(head);printf("Input the insert posion and element:\n");scanf("%d%d",&i,&element);Ins(head,i,element);Output(head);}}。

实验二 链表的基本操作

实验二链表的基本操作学号:姓名:实验日期: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),把链表进行逆置。

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

实验目的:
熟悉链表的逻辑特性、存储表示方法的特点和链式表的基本操作。

实验要求:
了解并熟悉链式表的逻辑特性、存储表示方法和链式表的基本操作的实现和应用。

实验内容:
1、编写一个程序建立存放学生成绩的有序链表并实现相关操作,要求如下:
(1)设学生成绩表中的数据元素由学生姓名和学生成绩字段组成,实现这样的线性表的链式存储表示。

(2)键盘输入10个(或若干个,特殊数据来标记输入数据的结束)数据元素,利用链表的基本操作建立学生成绩单链表,要求该表为有序表并带有头结点。

(用于
比较的字段为分数)。

(3)输入关键字值x,打印出表中所有关键字值<=x的结点。

(用于比较的关键字字段为分数)。

(4)输入关键字值x,删除表中所有关键字值<=x的结点。

(用于比较的关键字字段为分数)。

实验实现
#include "stdio.h"
#include "malloc.h"
#include "string.h"
typedef struct LNode
{
char nam e[10];
int cj;
struct LNode *next;
}student;
void creatLink(student *head)
{
student *p;
char nam e[10];
printf("请输入学生姓名成绩(输入end结束)\n");
while(1)
{
scanf("%s",name);
if(nam e[0]=='e'&&nam e[1]=='n'&&name[2]=='d') break;
p=(student*)m alloc(sizeof(student));
strcpy(p->name,name);
scanf("%d",&p->cj);
p->next=head->next;
head->next=p;
} }
void printLink(student *head)
{ student *p=head;
if(head->next==NULL) printf("此链表为空\n");
while(p->next!=NULL)
{
p=p->next;
printf("%s %d\n",p->name,p->cj);
} }
void printLessLink(student *head,int x)
{ int b=1;
student *p=head;
if(head->next==NULL) printf("此链表为空\n");
while(p->next!=NULL)
{ p=p->next;
if(p->cj<=x)
{ printf("%s %d\n",p->name,p->cj);
b=0;
} }
if(b) printf("此链表没有成绩<=%d的结点\n",x);
}
void delLessLink(student *head,int x)
{ student *p=head,*temp;
if(head->next==NULL) printf("此链表为空\n"); while(p->next!=NULL)
{ if(p->next->cj<=x)
{ temp=p->next;
p->next=tem p->next;
free(tem p);
}
else
{ p=p->next;
} } }
void main()
{ int x,b=0;
student *head;
head=(student*)malloc(sizeof(student));
head->next=NULL;
creatLink(head);
while(1)
{ printf("1:输出所有结点\n");
printf("2:输出分数小于等于X的结点\n");
printf("3:删除分数小于等于X的结点\n");
printf("0:退出\n");
scanf("%d",&x);
switch(x)
{ case 1:
{ printLink(head);
break;
}
case 2:
{ printf("X=");
scanf("%d",&x);
printLessLink(head,x);
break;
}
case 3:
{ printf("X=");
scanf("%d",&x);
delLessLink(head,x);
break;
}
case 0: b=1;
}
if(b) break;
}
}。

相关文档
最新文档