单链表的各种操作

合集下载

单链表的基本操作

单链表的基本操作

10)调用头插法的函数,分别输入10,20,分别回车:
11)调用尾插法的函数,分别输入30,40
12)查找单链表的第四个元素:
13)主函数中传入参数,删除单链表的第一个结点:
14)主函数传入参数,删除第0个未位置的元素,程序报错:
15)最后,输出单链表中的元素:
return 0;
}
6)编译,连接,运行源代码:
7)输入8,回车,并输入8个数,用空格分隔开,根据输出信息,可以看出,链表已经拆分为两个
五、实验总结
1.单链表采用的是数据+指针的表示形式,指针域总是指向下一个结
点(结构体)的地址,因此,在内存中的地址空间可以是不连续的,操作比顺序存储更加的方便
2.单链表使用时,需要用malloc函数申请地址空间,最后,删除元
素时,使用free函数释放空间。

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

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

数据结构实验报告--单链表数据结构实验报告--单链表1.引言1.1 研究目的本实验旨在通过实践的方式,深入了解单链表的数据结构以及相关操作,提升对数据结构的理解和应用能力。

1.2 实验内容本实验主要包括以下几个方面的内容:●单链表的基本定义和实现●单链表的插入、删除、遍历操作●单链表的逆置操作●单链表的查找和修改操作2.理论基础2.1 单链表的定义单链表是一种常见的线性数据结构,它由一系列的节点组成,每个节点包含数据和指向下一个节点的指针。

2.2 单链表的基本操作①单链表的插入操作在单链表中,可以通过插入操作在指定位置插入一个新节点,该操作主要包括以下步骤:●创建一个新的节点,并为其赋值●将新节点的next指针指向插入位置的后一个节点●将插入位置的前一个节点的next指针指向新节点②单链表的删除操作在单链表中,可以通过删除操作删除指定位置的节点,该操作主要包括以下步骤:●将删除位置的前一个节点的next指针指向删除位置的后一个节点●释放删除节点的内存③单链表的遍历操作单链表的遍历操作主要是依次访问链表中的每一个节点,并执行相应的操作。

④单链表的逆置操作单链表的逆置操作可以将一个单链表中的节点顺序进行颠倒。

⑤单链表的查找操作在单链表中,可以通过查找操作找到指定值的节点。

⑥单链表的修改操作在单链表中,可以通过修改操作修改指定位置的节点的值。

3.实验过程3.1 实验环境本次实验使用C语言进行编程,需要先安装相应的编程环境,如gcc编译器。

3.2 实验步骤①单链表的创建和初始化首先创建一个空链表,并初始化链表的头指针。

②单链表的插入操作按照需求,在链表的指定位置插入一个新节点。

③单链表的删除操作按照需求,删除链表中的指定位置的节点。

④单链表的遍历操作依次访问链表中的每一个节点,并输出其值。

⑤单链表的逆置操作将单链表中的节点顺序进行逆置。

⑥单链表的查找操作按照需求,在链表中查找指定值的节点。

3.2.7 单链表的修改操作按照需求,修改链表中指定位置的节点的值。

实现单链表的各种基本运算

实现单链表的各种基本运算

实现单链表的各种基本运算一、实验目的了解单链表表的结构特点及有关概念,掌握单链表的各种基本操作算法思想及其实现。

二、实验内容编写一个程序,实现顺序表的各种基本运算:1、初始化单链表;2、单链表的插入;3、单链表的输出;4、求单链表的长度5、判断单链表是否为空;6、输出单链表的第i位置的元素;7、在单链表中查找一个给定元素在表中的位置;8、单链表的删除; 9、释放单链表三、算法思想与算法描述简图四、实验步骤与算法实现#include<stdio.h>#include<malloc.h>typedef char ElemType;typedef struct LNode//定义单链表{ ElemType data;struct LNode *next;}LinkList;void InitList(LinkList*&L){ L=(LinkList*)malloc(sizeof(LinkList));//创建头结点L->next=NULL;//头结点赋值为空}void DestroyList(LinkList*&L)//销毁单链表(释放单链表L占用的内存空间即逐一释放全部结点的空间){ LinkList*p=L,*q=p->next;while(q!=NULL){free(p);p=q;q=p->next;}free(p);}int ListEmpty(LinkList*L)//判线性表是否为空表ListEmpty(L){ return(L->next==NULL);}//若单链表L没有数据结点,则返回真,否则返回假。

int ListLength(LinkList*L)//求线性表的长度ListLength(L){ LinkList*p=L;int i=0;while(p->next!=NULL){i++;p=p->next;}return(i);//返回单链表L中数据结点的个数}void DispList(LinkList*L)//输出线性表DispList(L){LinkList*p=L->next;while (p!=NULL)//逐一扫描单链表L的每个数据结点,并显示各结点的data域值。

写出单链表存储结构的 c 语言描述

写出单链表存储结构的 c 语言描述

写出单链表存储结构的 c 语言描述一、单链表的概述单链表是一种常见的数据结构,它由若干个节点组成,每个节点包含一个数据元素和一个指向下一个节点的指针。

单链表的特点是插入和删除操作效率高,但查找操作效率较低。

二、单链表的存储结构单链表的存储结构采用动态分配内存的方式,每个节点都是一个独立的内存区域,通过指针将它们连接在一起。

下面是单链表存储结构的 c 语言描述:```typedef struct Node{int data; // 数据域struct Node *next; // 指针域} ListNode, *LinkedList;```上面代码中,ListNode 表示节点类型,LinkedList 表示链表类型。

其中 data 是数据域,next 是指针域,用于存放下一个节点的地址。

三、单链表的基本操作1. 初始化操作初始化操作用于创建一个空链表。

```void InitList(LinkedList *L){*L = (ListNode*)malloc(sizeof(ListNode)); // 创建头结点(*L)->next = NULL; // 头结点指针域为空}```2. 插入操作插入操作用于在链表中插入新节点。

```int Insert(LinkedList L, int i, int x)int j = 0;ListNode *p = L;while (p && j < i - 1) // 找到第 i-1 个节点{p = p->next;j++;}if (!p || j > i - 1) // 判断 i 的范围是否合法{return 0;}ListNode *s = (ListNode*)malloc(sizeof(ListNode)); // 创建新节点s->data = x; // 赋值数据域s->next = p->next; // 新节点指向下一个节点p->next = s; // 前一个节点指向新节点 return 1;```3. 删除操作删除操作用于删除链表中的某个节点。

单链表基本操作的实现

单链表基本操作的实现

单链表基本操作的实现单链表是一种常见的数据结构,它由多个节点组合而成,每个节点包含一个数据元素和一个指向下一个节点的指针。

通过指针,我们可以方便地在单链表中进行插入、删除和遍历等操作。

以下是关于单链表基本操作的实现。

1. 单链表的创建单链表的创建需要定义一个空的头结点,它的作用是方便在链表的头部进行添加和删除节点操作。

一个空的头节点可以在链表初始化的过程中进行创建。

```typedef struct Node{int data;struct Node *next;}Node;Node *createList(){Node *head = (Node*)malloc(sizeof(Node)); //创建空的头节点head->next = NULL;return head; //返回头节点的地址}```2. 单链表的插入单链表的插入可以分为在链表头部插入、在链表尾部插入和在链表中间插入三种情况。

a. 在链表头部插入节点:```void insertAtHead(Node *head, int data){Node *node = (Node*)malloc(sizeof(Node));node->data = data;node->next = head->next;head->next = node;}```b. 在链表尾部插入节点:```void insertAtTail(Node *head, int data){Node *node = (Node*)malloc(sizeof(Node));node->data = data;node->next = NULL;Node *p = head;while(p->next != NULL){p = p->next;}p->next = node;}```c. 在链表中间插入节点:```void insertAtMid(Node *head, int data, int pos){ Node *node = (Node*)malloc(sizeof(Node)); node->data = data;node->next = NULL;Node *p = head;int count = 0;while(p->next != NULL && count < pos-1){ p = p->next;count++;}if(count == pos-1){node->next = p->next;p->next = node;}else{printf("插入位置错误!");}}```3. 单链表的删除单链表的删除可以分为在链表头部删除、在链表尾部删除和在链表中间删除三种情况。

单链表求集合的并、交和差运算

单链表求集合的并、交和差运算

单链表求集合的并、交和差运算单链表是一种常用的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。

在计算机科学中,我们经常需要对集合进行操作,包括求并集、交集和差集。

在本文中,我们将介绍如何使用单链表来实现这些集合操作。

我们需要定义一个单链表的数据结构。

每个节点包含一个数据元素和一个指向下一个节点的指针。

我们可以使用类来实现这个数据结构,例如:```class Node:def __init__(self, data):self.data = dataself.next = Noneclass LinkedList:def __init__(self):self.head = None```接下来,我们需要实现集合的并、交和差运算。

首先是并运算,它将两个集合中的所有元素合并为一个新的集合。

我们可以使用两个指针分别遍历两个链表,将两个链表中的元素逐个比较,并将不重复的元素添加到结果链表中。

具体代码如下:```def union(l1, l2):result = LinkedList()p1 = l1.headp2 = l2.headwhile p1 is not None:result.append(p1.data)p1 = p1.nextwhile p2 is not None:if not result.contains(p2.data):result.append(p2.data)p2 = p2.nextreturn result```接下来是交运算,它将两个集合中共有的元素提取出来组成一个新的集合。

同样地,我们可以使用两个指针分别遍历两个链表,将相同的元素添加到结果链表中。

具体代码如下:```def intersection(l1, l2):result = LinkedList()p1 = l1.headwhile p1 is not None:if l2.contains(p1.data):result.append(p1.data)p1 = p1.nextreturn result```最后是差运算,它将第一个集合中不属于第二个集合的元素提取出来组成一个新的集合。

数据结构单链表实验报告

数据结构单链表实验报告

数据结构单链表实验报告一、实验目的1、深入理解单链表的数据结构及其基本操作。

2、掌握单链表的创建、插入、删除、查找等操作的实现方法。

3、通过实际编程,提高对数据结构和算法的理解和应用能力。

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

指针域用于指向下一个节点,从而形成链表的链式结构。

单链表的基本操作包括:1、创建链表:通过动态分配内存创建链表的头节点,并初始化链表为空。

2、插入节点:可以在链表的头部、尾部或指定位置插入新的节点。

3、删除节点:根据给定的条件删除链表中的节点。

4、查找节点:在链表中查找满足特定条件的节点。

四、实验内容(一)单链表的创建```cinclude <stdioh>include <stdlibh>//定义链表节点结构体typedef struct Node {int data;struct Node next;} Node;//创建单链表Node createList(){Node head =(Node)malloc(sizeof(Node));if (head == NULL) {printf("内存分配失败!\n");return NULL;}head>data = 0;head>next = NULL;return head;}int main(){Node list = createList();//后续操作return 0;}```在创建单链表时,首先为头节点分配内存空间。

若内存分配失败,则提示错误信息并返回`NULL`。

成功分配内存后,初始化头节点的数据域和指针域。

(二)单链表的插入操作插入操作分为三种情况:头部插入、尾部插入和指定位置插入。

1、头部插入```cvoid insertAtHead(Node head, int data) {Node newNode =(Node)malloc(sizeof(Node));if (newNode == NULL) {printf("内存分配失败!\n");return;}newNode>data = data;newNode>next = head>next;head>next = newNode;}```头部插入时,创建新节点,将新节点的数据域赋值,并将其指针域指向原头节点的下一个节点,然后更新头节点的指针域指向新节点。

单链表数据操作.doc

单链表数据操作.doc

#include "stdafx.h"#define N -1#include <malloc.h>#define LEN sizeof(struct student)struct student{int num;struct student * next;};struct student *head(){struct student *p1;p1=(struct student*)malloc(sizeof(struct student));p1->next=NULL;return p1;}void get(struct student *p1) //前插法{struct student *p2,*h;int x;p2=p1; //p2相当于单链表的头结点printf("请输入你的数据,并在末尾输入-1以示结束\n");scanf("%d",&x );while(x!=N){h=(struct student*)malloc(sizeof(struct student));h->num=x;h->next =p2->next;p2->next=h; //生成新结点,将读入数据存放到新结点的数据域中,将该新结点插入到链表的前端scanf("%d",&x );}}void put(struct student *p1){struct student *p3;p3=p1;printf("链表中的数据有:\n");while(p3->next!=NULL){printf("%d",p3->next->num );p3=p3->next;if(p3->next!=NULL){printf("->");}}printf("\n");}void locateelem(struct student *p1) //单链表的按值查找{struct student *p4;int x;p4=p1;printf("查找数据的位置\n");scanf("%d",&x);while(p4->num !=x&&p4->next !=NULL){p4=p4->next ;}printf("要查找数据的地址是%d\n",p4);}void listinsert(struct student *p1) //单链表的插入{struct student *p5,*n,*p;p5=p1;p=p1;int i=2,j=0;printf("请输入需要插入的数据\n");while(j<i){p5=p5->next ;j++;}n=(struct student*)malloc(sizeof(struct student));scanf("%d",&n->num);n->next=p5->next ;p5->next =n;while(p->next!=NULL){printf("%d",p->next->num );p=p->next;if(p->next!=NULL){printf("->");}}printf("\n");}void listdelete(struct student *p1) //删除链表的一个结点{struct student *p6,*e,*p;p6=p1;p=p1;int i,j=0;printf("输入要删除的结点\n");scanf("%d",&i);while(j<i){p6=p6->next ;j++;}e=p6->next ;p6->next =e->next;delete e;while(p->next!=NULL){printf("%d",p->next->num );p=p->next;if(p->next!=NULL){printf("->");}}printf("\n");}int main(){struct student *a;a=head();get(a); //前插法put(a); //输出链表的数据locateelem(a); //单链表的按值查找listinsert(a); //单链表的插入listdelete(a); //删除链表的一个结点return 0;}。

数据结构课件单链表

数据结构课件单链表
删除节点
删除链表中的节点需要遍历至指定位置,时间复杂度为 O(n)。
查找节点
在链表中查找一个节点需要遍历整个链表,时间复杂度为 O(n)。
空间复杂度
空间占用
单链表的空间占用主要取决于链表中的 节点数,因此空间复杂度为O(n)。
VS
内存分配
每个节点需要分配内存空间存储数据和指 针,因此内存分配的空间复杂度也为O(n) 。
需要根据数据元素顺 序进行遍历的场景, 如排序算法等。
需要频繁插入、删除 操作的场景,如动态 规划、图算法等。
02
单链表的实现
创建单链表
定义节点结构体
首先需要定义一个节点结构体,包含 数据域和指针域两个部分,数据域用 于存储数据,指针域用于指向下一个 节点。
初始化头节点
创建一个头节点,并将其指针域指向 NULL,表示单链表的起始位置。
05
单链表常见问题与解决方 案
循环链表
总结词
循环链表是一种特殊类型的单链表,其中尾节点的指针指向头节点,形成一个闭环。
详细描述
在循环链表中,由于尾节点的指针指向头节点,因此遍历链表时需要特别注意,以避免无限循环。常见的解决方 法是在遍历时记录已经访问过的节点,避免重复访问。
链表中的重复元素
总结词
链表中可能存在重复元素的问题,这会影响数据处理的正确性。
详细描述
为了解决这个问题,可以在插入节点时检查新元素是否已存在于链表中。如果存在,则不进行插入操 作。另外,也可以使用哈希表等数据结构来快速查找重复元素。
链表的排序
总结词
对链表进行排序是常见的需求,但链表的排 序算法通常比数组的排序算法复杂。
合并单链表
总结词
将两个已排序的单链表合并为一个新的已排序的单链表。

单链表的 基本操作

单链表的 基本操作

单向链表单向链表的基本操作,创建一个由6个节点组成的单向链表,显示链表中每个节点的数据,并且做增加、删除、查找节点以及计算单链表的长度等处理。

➢需求分析:1.功能(1)用尾插法创建一带头结点的由6个节点组成的单向链表:从键盘读入一组整数,作为单链表中的元素,输入完第6个结点后结束;将创建好的单链表元素依次输出到屏幕上。

(2)显示链表中每个节点的数据(3)从键盘输入一个数,查找在以上创建的单链表中是否存在该数;如果存在,显示它的位置,即第几个元素;如果不存在,给出相应提示如“No found node!”。

(4)在上述的单链表中的指定位置插入指定数据,并输出单链表中所有数据。

(5)删除上述单链表中指定位置的结点,并输出单链表中所有数据。

(6)求单链表的长度并输出.2.输入要求先输入单链表中结点个数n,再输入单链表中所有数据,在单链表中需查找的数据,需插入的数据元素的位置、值,要删除的数据元素的位置。

3。

测试数据单链表中所有数据:12,23,56,21,8,10在单链表中需查找的数据:56;24插入的数据元素的位置、值:1,28;7,28;0,28要删除的数据元素的位置:6➢概要设计:1.算法思想:由于在操作过程中要进行插入、删除等操作,为运算方便,选用带头结点的单链表作数据元素的存储结构.对每个数据元素,由一个数据域和一个指针域组成,数据域放输入的数据值,指针域指向下一个结点。

2.数据结构:单链表结点类型:typedef struct Liistnode {int data;struct Listnode *next;}NODE;3.模块划分:a)用尾插法建立带头结点的单链表*CreateList函数;b)显示链表中每个结点的数据PrintList函数;c)从键盘输入一个数,查找单链表中是否存在该数FoundList函数;d)在单链表中指定位置插入指定数据并输出单链表中所有数据InsertList函数;e)删除单链表中指定位置的结点并输出单链表中所有数据DeleteList函数;f)计算单链表的长度并在屏幕上输出LengthList函数;g)主函数main(),功能是给出测试数据值,建立测试数据值的带头结点的单链表,调用PrintList函数、FoundList函数、InsertList函数、DeleteList函数、LengthList函数实现问题要求。

实验二 单链表基本操作

实验二 单链表基本操作

实验二单链表基本操作一实验目的1.学会定义单链表的结点类型,实现对单链表的一些基本操作和具体的函数定义,了解并掌握单链表的类定义以及成员函数的定义与调用。

2.掌握单链表基本操作及两个有序表归并、单链表逆置等操作的实现。

二实验要求1.预习C语言中结构体的定义与基本操作方法。

2.对单链表的每个基本操作用单独的函数实现。

3.编写完整程序完成下面的实验内容并上机运行。

4.整理并上交实验报告。

三实验内容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逆置。

(即最后一个结点变成第一个结点,原来倒数第二个结点变成第二个结点,如此等等。

)四思考与提高1.如果上面实验内容2中合并的表内不允许有重复的数据该如何操作?2.如何将一个带头结点的单链表La分解成两个同样结构的单链表Lb,Lc,使得Lb中只含La表中奇数结点,Lc中含有La表的偶数结点?1.编写程序完成单链表的下列基本操作:(1)初始化单链表La。

(2)在La中第i个元素之前插入一个新结点。

(3)删除La中的第i个元素结点。

(4)在La中查找某结点并返回其位置。

(5)打印输出La中的结点元素值。

#include<stdio.h>#include<stdlib.h>#include <malloc.h>#define OK 1#define ERROR 0typedef int Status;typedef int ElemType;//定义存储结构typedef struct Lnode{int data; /*每个元素数据信息*/struct Lnode *next; /*存放后继元素的地址*/} LNode,*LinkList;int main(){void Create_L(LinkList &L,int n);void Print_L(LinkList L);Status ListInsert_L(LinkList &L,int i,ElemType e);Status ListDelete_L(LinkList &L,int i,ElemType &e);Status Find_L(LinkList L,int e);LinkList La;//创建单链表Laint n;printf("请输入链表La中的元素个数:\n");scanf("%d",&n);Create_L(La,n);//初始化单链表printf("现在La中的元素为:\n");Print_L(La);printf("-------------------------------------\n\n");printf("现在准备插入元素,请输入插入位置及所插入元素的值\n");int i,e;scanf("%d %d",&i,&e);ListInsert_L(La,i,e);printf("插入后La中的元素为:\n");Print_L(La);printf("-------------------------------------\n\n");printf("现在准备删除元素,请输入删除位置\n");scanf("%d",&i);ListDelete_L(La,i,e);printf("删除后La中的元素为:\n");Print_L(La);printf("-------------------------------------\n\n");printf("请输入所要查找元素的值:\n");scanf("%d",&e);Find_L(La,e);printf("所要查找元素的位置为:%d\n",Find_L(La,e)); }void Create_L(LinkList &L,int n){int j=1;L=(LinkList)malloc(sizeof(Lnode));L->next =NULL;//先建立一个带头结点的单链线性表L for(int i=n;i>0;--i){LinkList p=(LinkList)malloc(sizeof(Lnode));printf("请输入链表La中的第%d个元素:\n",j++);scanf("%d",&p->data);p->next=L->next;L->next =p;}//(逆序实现)/*LinkList q=L;for(int i=1;i<=n;i++){LinkList p=(LinkList)malloc (sizeof(Lnode));q->next=p;p->next=NULL;q=q->next ;printf("请输入链表La中的第%d个元素:\n",i);scanf("%d",&p->data);}//(正序实现)*/}//初始化单链表//输出单链表void Print_L(LinkList L){LinkList p;p=L->next;while(p){printf("%d ",p->data );p=p->next;}printf("\n");}//在单链表L的第i个位置前插入元素eStatus ListInsert_L(LinkList &L,int i,ElemType e) {LinkList p=L;int j=0;while(p&&j<i-1){p=p->next; ++j;}if(!p||j>i-1) return ERROR;LinkList s=(LinkList)malloc(sizeof(LNode));s->data=e; s->next=p->next;p->next=s;return OK;} //ListInsert_L//删除单链表L中第i个位置上的元素Status ListDelete_L(LinkList &L,int i,ElemType &e) {LinkList p=L;int j=0;while( p->next && j<i-1){p=p->next; ++j;}if(!p->next||j>i-1) return ERROR;LinkList q=p->next; p->next=q->next;e=q->data;free(q);return OK;}//LinkDelete_L/*查找元素并返回位置*/Status Find_L(LinkList L,int e){LinkList p=L->next;int j=1;while(p->data!=e&&p->next){p=p->next;j++;}if(p->data==e) return j;else{printf("无当前元素\n");return ERROR;}if(!p){printf("无当前元素\n");return ERROR;}}//定位2 .构造两个带有表头结点的有序单链表La、Lb,编写程序实现将La、Lb合并成一个有序单链表Lc。

【头歌】单链表的基本操作

【头歌】单链表的基本操作

【头歌】单链表的基本操作
单链表是一种线性数据结构,由一系列节点组成,每个节点包含数据元素和一个指向下一个节点的指针。

以下是单链表的基本操作:
1. 插入操作:在单链表的指定位置插入一个新节点。

具体步骤如下:
找到要插入的位置的前一个节点;
将新节点插入到前一个节点和当前节点之间;
修改新节点的指针,使其指向当前节点;
修改前一个节点的指针,使其指向新节点。

2. 删除操作:删除单链表中的指定节点。

具体步骤如下:
找到要删除的节点的前一个节点;
将前一个节点的指针指向要删除的节点的下一个节点;
释放要删除的节点的内存。

3. 查找操作:在单链表中查找指定元素。

具体步骤如下:
从头节点开始遍历单链表;
找到与指定元素相等的节点;
返回该节点的位置。

4. 遍历操作:从头节点开始,依次访问单链表中的每个节点。

具体步骤如下:创建一个指针指向头节点;
依次访问指针所指向的每个节点,直到指针为空。

5. 打印操作:打印单链表中的所有元素。

具体步骤如下:
创建一个指针指向头节点;
依次打印指针所指向的每个节点的数据元素,直到指针为空。

以上是单链表的基本操作,通过这些操作可以对单链表进行各种操作,如插入元素、删除元素、查找元素等。

单链表操作实验报告

单链表操作实验报告

线性表一、实验目的1. 了解线性表的逻辑结构特征,以及这种特性在计算机内的两种存储结构。

2. 掌握线性表的顺序存储结构的定义及其C语言实现。

3. 掌握线性表的链式村粗结构——单链表的定义及其C语言实现。

4. 掌握线性表在顺序存储结构即顺序表中的各种基本操作。

5. 掌握线性表在链式存储结构——单链表中的各种基本操作。

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

2. 上机运行本程序。

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

4. 按照对顺序表和单链表的操作需要,重新改写主程序并运行,打印出文件清单和运行结果三、实验内容请编写C程序,利用链式存储方式来实现线性表的创建、插入、删除和查找等操作。

具体地说,就是要根据键盘输入的数据建立一个单链表,并输出该单链表;然后根据屏幕菜单的选择,可以进行数据的插入或删除,并在插入或删除数据后,再输出单链表;然后在屏幕菜单中选择0,即可结束程序的运行。

四、解题思路本实验要求分别写出在带头结点的单链表中第i(从1开始计数)个位置之后插入元素、创建带头结点的单链表中删除第i个位置的元素、顺序输出单链表的内容等的算法。

五、程序清单#include<>#include<>#include<>typedef int ElemType;~typedef struct LNode{ ElemType data;struct LNode *next;}LNode;LNode *L;LNode *creat_L();void out_L(LNode *L);void insert_L(LNode *L,int i,ElemType e);ElemType delete_L(LNode *L,int i);int locat_L(LNode *L,ElemType e);$void main(){ int i,k,loc;ElemType e,x;char ch;do{ printf("\n");printf("\n 1.建立单链表");printf("\n 2.插入元素");printf("\n 3.删除元素");printf("\n 4.查找元素");printf("\n 0.结束程序运行");.printf("\n======================================");printf("\n 请输入您的选择(1,2,3,4,0)");scanf("%d",&k);switch(k){ case 1:{ L=creat_L();out_L(L);}break;case 2:{ printf("\n请输入插入位置:");scanf("%d",&i);printf("\n请输入要插入元素的值:");scanf("%d",&e);&insert_L(L,i,e);out_L(L);}break;case 3:{ printf("\n请输入要删除元素的位置:");scanf("%d",&i);x=delete_L(L,i);out_L(L);if(x!=-1){printf("\n删除的元素为:%d\n",x);printf("删除%d后的单链表为:\n",x);out_L(L);|}else printf("\n要删除的元素不存在!");}break;case 4:{ printf("\n请输入要查找的元素值:");scanf("%d",&e);loc=locat_L(L,e);if(loc==-1) printf("\n为找到指定元素!"); else printf("\n已找到,元素位置是%d",loc);}break;}printf("\n----------------");)}while(k>=1&&k<5);printf("\n 按回车键,返回...\n");ch=getchar();}LNode *creat_L(){ LNode *h,*p,*s; ElemType x;h=(LNode *)malloc(sizeof(LNode));h->next=NULL;p=h;printf("\n请输入第一个数据元素:");,scanf("%d",&x);while(x!=-999){ s=(LNode *)malloc (sizeof(LNode));s->data=x; s->next=NULL;p->next=s; p=s;printf("请输入下一个数据:(输入-999表示结束。

单链表的基本操作代码

单链表的基本操作代码

单链表的基本操作代码单链表是一种常用的数据结构,它具有优秀的插入和删除性能,在数据存储和处理方面具有广泛的应用。

单链表的基本操作包含创建链表、插入节点、删除节点、查找节点等,下面是单链表的基本操作代码:1. 定义单链表结构体:typedef struct ListNode {int val;struct ListNode *next;} ListNode;2. 创建单链表:ListNode *createList(int arr[], int n) {ListNode *head = NULL, *tail = NULL, *p = NULL;for(int i = 0; i < n; i++) {p = (ListNode *)malloc(sizeof(ListNode));p->val = arr[i];p->next = NULL;if(head == NULL) {head = tail = p;} else {tail->next = p;tail = p;}}return head;}3. 插入节点:void insertNode(ListNode **head, int val, int pos) {ListNode *p = (ListNode *)malloc(sizeof(ListNode)); p->val = val;p->next = NULL;if(*head == NULL) {if(pos != 0) {printf("Invalid position\n");return;} else {*head = p;return;}}if(pos == 0) {p->next = *head;*head = p;} else {int i = 0;ListNode *q = *head;while(q != NULL && i < pos - 1) {q = q->next;i++;}if(q == NULL || i != pos - 1) {printf("Invalid position\n");return;}p->next = q->next;q->next = p;}}4. 删除节点:void deleteNode(ListNode **head, int pos) {if(*head == NULL) {printf("List is empty\n");return;}if(pos == 0) {ListNode *p = *head;*head = (*head)->next;free(p);} else {int i = 0;ListNode *p = *head, *q = NULL; while(p != NULL && i < pos) { q = p;p = p->next;i++;}if(p == NULL || i != pos) {printf("Invalid position\n");return;}q->next = p->next;free(p);}}5. 查找节点:ListNode *findNode(ListNode *head, int val) {ListNode *p = head;while(p != NULL) {if(p->val == val) {return p;}p = p->next;}return NULL;}单链表的基本操作是数据结构中最基础的部分,掌握好这些代码对于往后的学习和应用都会有很大的帮助。

单链表实验总结

单链表实验总结

单链表实验总结单链表是一种常见的数据结构,用于存储有序的数据元素。

在这个实验中,我通过实现单链表的基本操作,如插入、删除和查找等,加深了对单链表的理解。

在实验中,我首先创建了一个单链表的类,并实现了构造函数。

然后,我实现了向链表中插入节点的操作。

插入节点时,我需要将新的节点的指针指向当前节点的下一个节点,然后将前一个节点的指针指向新的节点,从而完成节点的插入。

在实现删除节点的操作时,我需要找到要删除的节点的前一个节点,然后将前一个节点的指针指向要删除节点的下一个节点,从而将要删除的节点排除在链表之外。

我还实现了通过索引查找节点的操作。

在这个操作中,我需要从链表的头节点开始迭代,直到找到要查找的索引位置的节点。

通过实践,我发现单链表的插入和删除操作的时间复杂度都是O(n),其中n表示链表的长度。

在查找操作中,时间复杂度是O(n)。

总之,通过这个实验,我对单链表的原理和基本操作有了更深的理解。

我也学到了如何使用单链表来解决实际问题。

这个实验让我更加熟悉了链表的概念和操作,为我进一步深入学习数据结构和算法打下了基础。

除了实现基本的插入、删除和查找操作,我还尝试了一些其他的操作来进一步加深对单链表的理解。

首先,我实现了获取链表长度的操作。

通过遍历整个链表,我可以统计节点的数量来得到链表的长度。

这个操作的时间复杂度是O(n)。

接下来,我尝试实现了链表的反转操作。

通过调整节点的指针指向,我可以将链表的顺序颠倒过来。

这个操作的时间复杂度是O(n)。

另外,我实现了链表的判空和清空操作。

判空操作可以判断链表是否为空,即链表的头节点是否为空。

清空操作可以将链表中的所有节点都删除,使链表变为空链表。

最后,我尝试了一些高级操作,如链表的排序和链表的合并。

排序操作可以将链表中的节点按照一定的顺序重新排列,通常使用冒泡排序、选择排序或插入排序等算法实现。

合并操作可以将两个有序链表合并成一个更大的有序链表,通常使用归并排序的思想实现。

数据结构单链表实验报告

数据结构单链表实验报告

数据结构单链表实验报告数据结构单链表实验报告1. 引言数据结构是计算机科学中的重要基础,它研究数据的组织、存储和管理方式。

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

本实验旨在通过实践操作单链表,加深对数据结构的理解。

2. 实验目的本实验的主要目的是掌握单链表的基本操作,包括创建链表、插入节点、删除节点和遍历链表。

通过实践操作,加深对链表的理解,提高编程能力和解决问题的能力。

3. 实验环境和工具本实验使用C语言进行编程实现,可以选择任何C语言开发环境,如Dev-C++、Code::Blocks等。

在编程过程中,可以使用任何文本编辑器编写代码。

4. 实验步骤4.1 创建链表首先,需要定义一个节点结构体,包含数据和指向下一个节点的指针。

然后,通过动态内存分配来创建链表的第一个节点,并将其地址赋给头指针。

接下来,可以通过输入数据的方式,逐个创建链表的其他节点。

4.2 插入节点在链表中插入节点是一种常见的操作。

可以在链表的任意位置插入一个新节点,只需要修改相应节点的指针即可。

首先,需要找到插入位置的前一个节点,然后将新节点的指针指向原来的下一个节点,再将前一个节点的指针指向新节点。

4.3 删除节点删除链表中的节点也是一种常见的操作。

可以根据节点的值或位置来删除节点。

首先,需要找到要删除的节点的前一个节点,然后将前一个节点的指针指向要删除节点的下一个节点,最后释放要删除节点的内存空间。

4.4 遍历链表遍历链表是一种查看链表中所有节点的操作。

可以通过循环遍历链表中的每个节点,输出节点的值或进行其他操作。

需要注意的是,遍历链表时需要使用一个临时指针来指向当前节点,以便于移动到下一个节点。

5. 实验结果与分析通过实验,我们成功实现了单链表的创建、插入、删除和遍历操作。

在实际应用中,单链表可以用于实现各种数据结构和算法,如栈、队列和图等。

它具有灵活性和高效性的特点,可以方便地进行节点的插入和删除操作。

数据结构 实验二:单链表的基本操作

数据结构 实验二:单链表的基本操作

数据结构实验二:单链表的基本操作数据结构实验二:单链表的基本操作实验二:单链表的基本操作一、【实验目的】1、理解和掌握单链表的类型定义方法和结点生成方法。

2、掌握建立单链表和显示单链表元素的算法。

3、掌握单链表的查找、插入和删除算法二、【实验内容】1、建立一个整形数的单链表,手动输入10个数,并从屏幕显示单链表元素列表。

2、从键盘输入一个数,查找在以上创建的单链表中是否存在该数;如果存在,显示它的位置;如果不存在,给出相应提示。

3、删除上述单链表中指定位置的元素。

以下就是程序部分代码,恳请调试并补足并使之恰当运转:1.linlist.htypedefstructnode{datatypedata;structnode*next;}slnode;voidlistinitiate(slnode**head)/*初始化*/{/*如果有内存空间,申请头结点空间并使头指针head指向头结点*/if((*head=(slnode*)malloc(sizeof(slnode)))==null)exit(1);(*head)->next=null;/*置链尾标记null*/}intlistlength(slnode*head){slnode*p=head;/*p指向首元结点*/intsize=0;/*size初始为0*/while(p->next!=null)/*循环计数*/{p=p->next;size++;}returnsize;}intlistinsert(slnode*head,inti,datatypex)/*在带头结点的单链表head的数据元素ai(0≤i≤size)结点前*//*填入一个存放数据元素x的结点*/{slnode*p,*q;intj;p=head;/*p指向首元结点*/j=-1;/*j起始为-1*/while(p->next!=null&&j<i-1)/*最终让指针p指向数据元素ai-1结点*/{p=p->next;j++;}if(j!=i-1){printf(\填入边线参数弄错!\return0;}/*生成新结点由指针q指示*/if((q=(slnode*)malloc(sizeof(slnode)))==null)exit(1);q->data=x;q->next=p->next;/*给指针q->next赋值*/p->next=q;/*给指针p->next重新赋值*/return1;}intlistdelete(slnode*head,inti,datatype*x)/*删除带头结点的单链表head的数据元素ai(0≤i≤size-1)结点*//*删除结点的数据元素域值由x带回。

数据结构单链表实验报告

数据结构单链表实验报告

数据结构单链表实验报告实验目的:本实验的目的是通过实现单链表数据结构,加深对数据结构的理解,并掌握单链表的基本操作和算法。

实验内容:1、单链表的定义单链表由若干个节点组成,每个节点包含数据域和指针域,数据域存储具体数据,指针域指向下一个节点。

单链表的头指针指向链表的第一个节点。

2、单链表的基本操作2.1 初始化链表初始化链表时,将头指针置空,表示链表为空。

2.2 插入节点插入节点可以分为头插法和尾插法。

- 头插法:将新节点插入链表头部,新节点的指针域指向原头节点,头指针指向新节点。

- 尾插法:将新节点插入链表尾部,新节点的指针域置空,原尾节点的指针域指向新节点。

2.3 删除节点删除节点可以分为按位置删除和按值删除两种方式。

- 按位置删除:给定要删除节点的位置,修改前一节点的指针域即可。

- 按值删除:给定要删除节点的值,遍历链表找到对应节点,修改前一节点的指针域即可。

2.4 遍历链表遍历链表即按顺序访问链表的每个节点,并输出节点的数据。

2.5 查找节点查找节点可以分为按位置查找和按值查找两种方式。

- 按位置查找:给定节点的位置,通过遍历链表找到对应节点。

- 按值查找:给定节点的值,通过遍历链表找到第一个匹配的节点。

实验步骤:1、根据实验目的,定义单链表的结构体和基本操作函数。

2、实现初始化链表的函数,将头指针置空。

3、实现头插法或尾插法插入节点的函数。

4、实现按位置删除节点的函数。

5、实现按值删除节点的函数。

6、实现遍历链表的函数,输出节点的数据。

7、实现按位置查找节点的函数。

8、实现按值查找节点的函数。

9、设计实验样例,测试单链表的各种操作。

实验结果与分析:通过测试实验样例,我们可以验证单链表的各种操作是否正确。

如果出现异常情况,可通过调试找出问题所在,并进行修改。

单链表的操作时间复杂度与操作的位置有关,对于查找操作,时间复杂度为O(n);对于插入和删除操作,时间复杂度也为O(n)。

附件:1、单链表的定义和基本操作的源代码文件。

单链表的类型定义与基本操作

单链表的类型定义与基本操作

• 基本思想
• 找到第i个结点 • 从单链表上摘除该结点(修改某些结点的指针域)
L
a1
… ai-1
× ai
ai+1

a NULL
n
L
a1
… ai-1
ai+1

a NULL
n
12
• 算法
void delete_lklist(lklist &l , int i)
{ lklist p,q;
p=find_lklist(l, i-1);
• C语言类型描述
typedef struct node{
datatype
data; /*数据元素类型*/
struct node *next; /*指针类型*/
} node, * lklist; /*结点类型*/
• node是结点类型 • lklist是指向node类型的指针
1
二、一些基本操作
1. 初始化 initiate_lklist(l)
else printf("不存在第i个结点");
}
13
}
return (j); }
3
3. 按序号查找 find_lklist(l, i) • 定义
• 查找单链表第i个元素,否则返回NULL
• 基本思想
• 从头指针出发,顺链域next逐个往下搜索,直到 找到第i个结点为止
4
• 算法
node *find_lklist(lklist l, int i)
{ lklist p=l;
e
ai

a1n0 NULL
• 算法
void insert_lklist(lklist &l , datatype x, int i)

链表基本操作实验报告

链表基本操作实验报告

实验2链表基本操作实验一、实验目的1. 定义单链表的结点类型。

2. 熟悉对单链表的一些基本操作和具体的函数定义。

3. 通过单链表的定义掌握线性表的链式存储结构的特点。

二、实验内容与要求该程序的功能是实现单链表的定义和主要操作。

女口:单链表建立、输出、插入、删除、查找等操作。

该程序包括单链表结构类型以及对单链表操作的具体的函数定义和主函数。

程序中的单链表(带头结点)结点为结构类型,结点值为整型。

要求:同学们可参考指导书实验2程序、教材算法及其他资料编程实现单链表相关操作。

必须包括单链表创建、输出、插入、删除操作,其他操作根据个人情况增减。

三、算法分析与设计。

1•创建单链表:头结点LA1 A2An A2.单链表插入void LinkedListlnsert(LinkedList L,int i,ElemType x) 链表插入函数(L头指针,i插入位置,x插入兀素)LinkedList p,s;疋义结构体类型指针p,sj=1;p=L;疋义整型j计数,寻找插入位置,p指针指向头结点p=p->next;j++; 满足条件时p指针后移,j自加1while(p&&j<i) 当p为真且j<i时循环j 〜____ p=NULL||j<i一一printf("插入位置不正确\n");s=(LNode *)malloc(sizeof(LNode));使用malloc函数动态分配存储空间,指针s指向新开辟的结点,并将插入元素x存放到新开辟结点s的数据域,将结点s指向i+1 结点位置,第i个结点指向s,实现了链表元素插入。

by1s->data=x; s->n ext=p->n ext; p->n ext=s;3.单链表的删除:p->n ext=p->n ext- >n ext;15 x=表 -俞弹i tl 度 書翁的琴素汕6.从链表中查找元素四、运行结果1.单链表初始化骨选择夷进行的操作、遍历链表 J 从链表中査找元素1.如程輕巴章兰与竽疋匹菇值里同門元素在顺序aw 位置 迥链五Fs 已元壽上也库吏卬删除更10^5^性表 毒他键退出。

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

//这是一个带头节点的单链表的插入删除输出反转操作
#include<iostream.h>
template<class Elem> class Link
{
public:
Elem element;
Link *next;
Link(const Elem&it,Link* nextval=NULL) //节点的构造函数{
element=it;
next=nextval;
}
Link(Link* nextval=NULL)
{
next=nextval;
}
};
template<class Elem>class LList:public Link<Elem>
{
private:
Link<Elem> *head;
Link<Elem> *tail;
Link<Elem> *fence;
intleftcnt;
intrightcnt;
voidinit()
{
fence=head=tail=new Link<Elem>;
leftcnt=rightcnt=0;
}
public:
LList() {init();}
void display() const;
bool append(const Elem&);
boolsetfence(intpos);
bool insert(const Elem& item);
void remove(const Elem& item);
voidprev();
void reverse();
void print() const;
};
template <class Elem> void LList<Elem>::display() const //打印链表
{
Link<Elem>* temp=head;
cout<<"<";
while(temp!=fence)
{
cout<<temp->next->element<<" "; //这是一个带头节点的链表,因此打印的第一个元素是第二个节点!
temp=temp->next;
}
cout<<"|";
while(temp->next!=NULL)
{
cout<<temp->next->element<<" ";
temp=temp->next;
}
cout<<">\n";
}
template<class Elem> void LList<Elem>::print() const
{
Link<Elem>* temp=head;
while(temp->next!=NULL)
{
cout<<temp->next->element<<" ";
temp=temp->next;
}
cout<<"\n";
}
template <class Elem>boolLList<Elem>::append(const Elem& item) //在链表末尾增加元素
{
tail=tail->next=new Link<Elem>(item,NULL);
rightcnt++;
return true;
}
template <class Elem>boolLList<Elem>::setfence(intpos)//让fence指针指向第pos个元素,并把fence放在第pos个元素的右边
{
if((pos<0)||(pos>rightcnt+leftcnt))
return false;
fence=head;
rightcnt=leftcnt+rightcnt;
leftcnt=0;
for(int i=0;i<pos;i++)
{
fence=fence->next;
leftcnt++;
rightcnt--;
}
return true;
}
template <class Elem>boolLList<Elem>::insert(const Elem& item) //在fence处加入一个新元素{
fence->next=new Link<Elem>(item,fence->next);
if(tail==fence)
tail=fence->next;
rightcnt++;
return true;
}
template <class Elem> void LList<Elem>::remove(const Elem& item) //删除链表中值为item的元素
{
int i=0;
Link<Elem>* Itemp=head->next;
while(item!=Itemp->element)
{
Itemp=Itemp->next;
i++;
}
setfence(i);
fence->next=Itemp->next;
if(tail==Itemp)
tail=fence;
deleteItemp;
rightcnt--;
}
template <class Elem> void LList<Elem>::prev() //把fence指针向前移动一格
{
if(fence==head)
cout<<"the fence already the front"<<endl;
else
{
Link<Elem>* temp=head;
while(temp->next!=fence)
temp=temp->next;
fence=temp;
leftcnt--;rightcnt++;
}
}
template <class Elem> void LList<Elem>::reverse() //指针单链表的指针全部反转{
tail=tail->next=new Link<Elem>(NULL);
Link<Elem> *Itemp=tail;
fence=tail;
prev();
while(fence!=head)
{
Itemp->next=fence;
Itemp=fence;
prev();
}
Itemp->next=NULL;
head=tail;
tail=Itemp;
fence=head;
}
void main()
{
LList<int> a;
a.append(12);
a.append(34);
a.append(24);
a.append(56);
a.display();
a.reverse();
a.display();
}。

相关文档
最新文档