单链表的初始化,建立,插入,查找,删除
C语言之单链表的插入、删除与查找
C语⾔之单链表的插⼊、删除与查找单链表是⼀种链式存取的数据结构,⽤⼀组地址任意的存储单元存放线性表中的数据元素。
要实现对单链表中节点的插⼊、删除与查找的功能,就要先进⾏的单链表的初始化、创建和遍历,进⽽实现各功能,以下是对单链表节点的插⼊、删除、查找功能的具体实现:#include<stdio.h>#include<stdlib.h>#include<string.h>typedef int ElemType;/***链表通⽤类型*ElemType 代表⾃定义的数据类型*struct Node *next 代表结构体指针(指向下⼀个结构体,完成链表动作)*/typedef struct Node{ElemType data;struct Node *next;}Node;/*==========单链表的初始化================*//**头结点指针数据域设置为空*/void initList(Node **pNode){*pNode=NULL;}/*===========单链表的创建=================*//**功能实现:通过⽤户不断输⼊数据,创建链表*利⽤游标俩个指针(p1,p2),将申请下的数据块(存⼊⽤户输⼊数据),链接起来*/Node *create(Node *pHead){Node *p1;Node *p2;p1=p2=(Node *)malloc(sizeof(Node)); //申请内存空间memset(p1,0,sizeof(Node)); //存⼊数据域清空scanf("%d",&p1->data);p1->next=NULL;while(p1->data>0){ //输⼊负数结束if(pHead==NULL)pHead=p1;elsep2->next=p1;p2=p1;p1=(Node *)malloc(sizeof(Node));memset(p1,0,sizeof(Node));scanf("%d",&p1->data);p1->next=NULL;}return pHead;}/*=================链表的遍历==================*//***从头结点开始,不断遍历出数据域的内容将表遍历*/void printList(Node *pHead){if(NULL==pHead)printf("链表为空\n");else{while(pHead!=NULL){printf("%d ",pHead->data);pHead=pHead->next;}}printf("\n");}/*===============插⼊节点==================*//***Node **pNode 传⼊头结点空间地址*int i 传⼊要插⼊的结点位置*/void insert_data(Node **pNode,int i){Node *temp;Node *target;Node *p;int item;int j=1;printf("输⼊要插⼊的节点值:");scanf("%d",&item);target=*pNode;for(;j<i-1;target=target->next,++j); //不断移动target位置,到要插⼊结点位置,temp=(Node *)malloc(sizeof(Node)); //申请内存空间temp->data=item; //存⼊要存⼊的数据位置p=target->next;target->next=temp;temp->next=p;}/*===============删除节点====================*//***删除结点后,释放内存空间free(temp)*/void delete_data(Node **pNode,int i){Node *target;Node *temp;int j=1;target=*pNode;for(;j<i-1;target=target->next,++j);temp=target->next;target->next=temp->next;free(temp);}/*===============查找结点====================*/int search_data(Node *pNode,int elem){Node *target;int i=1;for(target=pNode;target->data!=elem && target->next!=NULL;++i,target=target->next); if(target->next==NULL)return 0;elsereturn i;}int main(){int i;Node *pHead=NULL;initList(&pHead);pHead=create(pHead);printList(pHead);printf("输⼊插⼊节点位置\n");scanf("%d",&i);insert_data(&pHead,i);printList(pHead);printf("输⼊删除节点位置\n");scanf("%d",&i);delete_data(&pHead,i);printList(pHead);printf("输⼊查找节点\n");scanf("%d",&i);printf("节点所在位置:%d",search_data(pHead,i));return 0;}通过以上各功能的实现,希望对⼤家单链表的学习有所帮助。
单链表的实验报告总结
单链表的实验报告总结单链表是一种常用的数据结构,它由一系列节点组成,每个节点包含了数据和指向下一个节点的指针。
在实验中,我们对单链表进行了操作和实现,通过此次实验,我深刻理解了单链表的特点和应用。
以下是我对此次实验的总结和体会。
在实验中我们实现了单链表的创建和初始化。
通过创建一个头节点,并将头节点的指针指向空,我们成功地初始化了一个空的单链表。
这为后续的操作打下了基础。
接着,我们实现了单链表的插入操作。
通过指定要插入的位置和值,我们可以在单链表的任意位置插入一个新的节点。
这个操作非常灵活,让我感受到了单链表的动态性和可变性。
通过插入操作,我们可以在单链表中任意位置插入新的元素,从而灵活地调整单链表的结构和内容。
在实验中,我们还实现了单链表的删除操作。
通过指定要删除的节点位置,我们可以将该节点从单链表中删除。
这个操作也非常重要,可以帮助我们对单链表中的数据进行动态管理。
通过删除操作,我们可以方便地删除单链表中的某个元素,从而保持单链表的整洁和有序。
除了插入和删除操作,我们还实现了单链表的查找操作。
通过指定要查找的值,我们可以在单链表中查找到对应的节点。
这个操作非常实用,可以帮助我们快速定位和访问单链表中的数据。
通过查找操作,我们可以方便地获取单链表中特定元素的值,从而满足我们对数据的需求。
在实验中,我们还实现了单链表的修改操作。
通过指定要修改的节点位置和新的值,我们可以将单链表中某个节点的值进行修改。
这个操作也非常有用,可以帮助我们对单链表中的数据进行更新和改进。
通过修改操作,我们可以方便地对单链表中的某个元素进行数值的调整,从而满足我们对数据的要求。
通过本次实验,我对单链表的原理和操作有了更深入的理解。
单链表是一种非常灵活和实用的数据结构,可以应用于各种场景和问题。
它的特点是插入和删除操作的效率很高,但查找和修改操作的效率较低。
因此,在实际应用中,我们需要根据具体的需求和场景选择合适的数据结构。
数据结构 单链表基本操作代码
数据结构单链表基本操作代码```一、单链表基本概念单链表是一种常见的线性存储结构,由一系列节点组成。
每个节点包括数据域和指针域,数据域存储具体的数据,指针域指向下一个节点。
二、单链表基本操作2.1 创建链表创建一个空链表,即没有任何节点。
可以选择初始化一个头节点,也可以直接初始化为空。
2.2 在链表头部插入节点在链表头部插入新节点。
将新节点的指针域指向原头节点,然后更新头节点指针,使其指向新节点。
2.3 在链表尾部插入节点在链表尾部插入新节点。
遍历链表找到尾节点,然后将尾节点的指针域指向新节点。
2.4 在指定位置插入节点在链表的指定位置插入新节点。
遍历链表找到指定位置的节点,然后将新节点的指针域指向下一个节点,再将指定位置的节点的指针域指向新节点。
2.5 删除链表头节点删除链表头节点,即将头节点的指针指向下一个节点,然后删除原头节点。
2.6 删除链表尾节点删除链表尾节点,即遍历链表找到尾节点的上一个节点,将其指针域置空,然后删除尾节点。
2.7 删除指定位置的节点删除链表的指定位置节点,即遍历链表找到指定位置节点的上一个节点,将其指针域指向下一个节点,然后删除指定位置节点。
2.8查找链表中是否存在某个元素遍历链表,逐个比较节点的数据域与目标元素,直到找到匹配或遍历到链表末尾。
2.9获取链表长度遍历链表,计数节点的个数,直到遍历到链表末尾。
三、附件暂无附件。
四、法律名词及注释本文档未涉及任何法律名词及其注释。
```。
单链表基本操作的实现
单链表基本操作的实现单链表是一种常见的数据结构,它由多个节点组合而成,每个节点包含一个数据元素和一个指向下一个节点的指针。
通过指针,我们可以方便地在单链表中进行插入、删除和遍历等操作。
以下是关于单链表基本操作的实现。
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. 单链表的删除单链表的删除可以分为在链表头部删除、在链表尾部删除和在链表中间删除三种情况。
数据结构单链表实验报告
数据结构单链表实验报告一、实验目的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;}```头部插入时,创建新节点,将新节点的数据域赋值,并将其指针域指向原头节点的下一个节点,然后更新头节点的指针域指向新节点。
数据结构课程设计-单链表的插入、删除、查找等
单链表的插入、删除、合并等基本操作一、实验目的1、理解数据结构中单链表的定义和建立。
2、掌握单链表中结点结构的C语言描述。
3、熟练掌握单链表的插入、删除和修改等算法的设计与C语言实现。
4、将理论与实际相结合,切实提高自己的逻辑能力和动手能力。
二、设计内容1、输入单链表长度,创建一个单链表。
2、对建立好的单链表进行插入操作。
3、对建立好的单链表进行删除操作。
4、对建立好的单链表进行合并操作。
三、概要设计抽象数据类型线性表的定义如下:ADTA List{数据对象:D={ai I ai∈ElemSet , i=1 ,2 , … , n n>=0 }数据关系:R1={<ai-1 , ai> I ai-1 , ai∈D , i=2 , … , n }基本操作:Creates( &L )操作结果:构建一个空的线性表L。
Insertsl( &L , k ,i)初始条件:线性表L已存在。
操作结果:在带有头结点单链表的第k个元素之前插入元素i。
Deletesl( &L , i, j )初始条件:线性表L已存在。
操作结果:删除指定位置j元素i。
Hebing( &L )初始条件:线性表L已存在。
操作结果:清除新链表中相同的元素。
}ADT List四、算法流程图五、算法源代码#include <stdio.h> #include <malloc.h>typedef struct node {int data;struct node *next; }node;node *head;int k;node * creates(){node *p,*s,*h;int j=1,x, n;p=h=(node*)malloc(sizeof(node));h->next=NULL;printf("请输入链表长度:");scanf("%d",&n);printf("请输入 %d 个数字创建链表:",n);while(j<=n){scanf("%d",&x);s=(node*)malloc(sizeof(node));s->data=x;p->next=s;p=s;j++;}p->next=NULL;return h;}void insertsl(node *head, int k, int i){/*在带有头结点单链表的第k个元素之前插入元素i*/ int j;node *p, *t;p=head;j=0;while ( p&&j<k-1 ) /*若p不指向空,并且没有找到合适位置则继续循环*/ {p = p->next;j++;}if (!p||j>k-1) /*k小于1或大于表长*/printf("插入位置不对。
单链表基本操作
单链表基本操作在计算机科学里,链表是一种常见的数据结构,它可以用来解决各种复杂的问题。
其中,单链表是最常见的一种,它由一系列节点组成,每个节点包含了一个数据元素和一个指针,指向下一个节点。
这篇文章将介绍单链表的基本操作,包括创建、插入、删除和遍历等。
创建单链表创建单链表是基本操作之一,它有两种方法:头插法和尾插法。
头插法是从链表的头节点开始,逐个将新节点插入。
具体来说,创建一个空链表,设置一个头节点,将头节点的指针指向空;依次输入新节点,将新节点的指针指向表头,将表头的指针指向新节点。
这样,每插入一个新节点就成为了新的表头,即最后插入的节点为新的表头。
尾插法则是从链表的尾节点开始,逐个将新节点插入。
具体来说,创建一个空链表,设置一个头节点,将头节点的指针指向空;依次输入新节点,将新节点的指针指向空,将最后一个节点的指针指向新节点。
这样,最后插入的节点为尾节点,它的指针值为空。
插入节点插入节点是指在单链表的任意位置插入一个新节点。
插入节点的前提是找到插入位置,可以通过遍历单链表来查找插入位置。
插入新节点的基本步骤如下:1、创建新节点;2、将新节点的指针指向待插入节点的后继节点;3、将待插入节点的指针指向新节点。
删除节点删除节点是指删除单链表中的任意节点。
删除节点的前提是找到删除的节点位置,可以通过遍历单链表来查找删除位置。
删除节点的基本步骤如下:1、找到要删除的节点;2、将该节点的前驱节点的指针指向该节点的后继节点;3、删除该节点。
遍历节点遍历节点是指按照链表的顺序依次访问链表中的各个节点。
遍历节点的基本步骤如下:1、从链表的头节点开始遍历;2、依次访问每个节点的数据元素;3、通过指针访问下一个节点,直到遇到尾节点。
优缺点单链表的优点是简单,灵活,易于实现和扩展,可以方便地进行插入和删除等操作。
其缺点是存在指针开销,查找元素时需要遍历整个链表,不能直接访问链表中任意位置的节点。
总结单链表是一种最常用的数据结构,它是由一系列节点组成,每个节点包含一个数据元素和一个指针,指向下一个节点。
带头节点的循环单链表
带头节点的循环单链表带头节点的循环单链表是一种特殊的链表结构,它在普通的循环单链表的基础上增加了一个头节点。
本文将详细介绍带头节点的循环单链表的特点、操作以及应用场景。
一、带头节点的循环单链表的特点带头节点的循环单链表与普通的循环单链表相比,多了一个头节点,头节点不存储任何数据,仅作为链表的标志和辅助作用。
头节点的存在使得链表的插入、删除等操作更加方便,同时也能避免一些特殊情况的处理。
1. 初始化链表:创建一个头节点,并将头节点的指针指向自身,表示链表为空。
2. 判断链表是否为空:通过判断头节点的指针是否指向自身,即可判断链表是否为空。
3. 插入节点:在链表的指定位置插入一个新节点。
首先找到插入位置的前一个节点,然后将新节点的指针指向前一个节点的下一个节点,再将前一个节点的指针指向新节点。
4. 删除节点:删除链表中指定位置的节点。
首先找到要删除节点的前一个节点,然后将前一个节点的指针指向要删除节点的下一个节点,最后释放被删除节点的内存空间。
5. 遍历链表:从头节点开始,按照指针的方向遍历链表,直到回到头节点为止,输出每个节点的数据。
三、带头节点的循环单链表的应用场景带头节点的循环单链表在实际应用中有着广泛的应用场景,以下是几个典型的应用场景:1. 约瑟夫环问题:约瑟夫环是一种数学问题,通过使用带头节点的循环单链表可以很方便地解决该问题。
2. 循环队列:循环队列是一种常见的队列结构,使用带头节点的循环单链表可以实现循环队列的操作。
3. 循环链表:带头节点的循环单链表本身就是一种循环链表,可以用于解决一些需要循环访问的问题。
总结:带头节点的循环单链表是一种特殊的链表结构,通过增加一个头节点,使得链表的操作更加方便,并且能够避免一些特殊情况的处理。
带头节点的循环单链表可以用于解决一些需要循环访问的问题,例如约瑟夫环问题和循环队列等。
掌握带头节点的循环单链表的基本操作,对于理解和应用链表结构具有重要的意义。
pta 单链表基本操作
pta 单链表基本操作
单链表是一种常见的数据结构,由一个个节点组成,每个节点包含一个数据元素和一个指向下一个节点的指针。
基本操作包括以下几种:
1. 创建链表:创建一个空链表,即创建一个头节点。
2. 插入节点:在链表的任意位置插入一个节点。
- 头部插入:将新节点作为新的头节点,其指针指向原头节点。
- 中间插入:将新节点插入到指定位置的节点之前,其指针指向指定位置的节点。
- 尾部插入:找到链表尾部节点,将新节点插到尾部节点的后面。
3. 删除节点:在链表中删除指定节点。
- 头部删除:将头节点删除,将头节点的下一个节点作为新的头节点。
- 中间删除:找到指定节点的前驱节点,将前驱节点的指针指向指定节点的后继节点。
- 尾部删除:找到尾部节点的前驱节点,将前驱节点的指针设为NULL。
4. 查找节点:在链表中查找指定数据的节点。
- 遍历链表,逐个比较节点的数据元素,直到找到指定数据或遍历到末尾节点。
5. 修改节点:在链表中修改指定节点的数据。
- 遍历链表,找到指定节点,修改其数据元素。
6. 遍历链表:按顺序遍历链表中的所有节点,进行相应操作。
这些是单链表的基本操作,可以根据需求进行组合和扩展。
单链表的操作实验报告
单链表的操作实验报告《单链表的操作实验报告》在计算机科学领域,数据结构是非常重要的基础知识之一。
而单链表作为一种常见的数据结构,经常被用来存储和操作数据。
在本次实验中,我们将对单链表的操作进行实验,并撰写实验报告以总结和分享我们的实验结果。
实验目的:1. 了解单链表的基本概念和操作方法。
2. 掌握单链表的插入、删除、查找等操作。
3. 通过实际操作加深对单链表的理解和掌握。
实验环境:1. 编程语言:C/C++2. 开发环境:Visual Studio Code3. 实验工具:GCC编译器实验步骤:1. 定义单链表的结构体,并实现初始化、插入、删除、查找等操作的函数。
2. 编写测试用例,对单链表的各种操作进行测试。
3. 分析实验结果,总结操作的时间复杂度和空间复杂度。
4. 撰写实验报告,分享实验过程和结果。
实验结果:经过实验,我们成功实现了单链表的初始化、插入、删除、查找等操作,并对这些操作进行了充分的测试。
我们发现单链表的插入和删除操作的时间复杂度为O(1),而查找操作的时间复杂度为O(n),其中n为链表的长度。
这些结果与我们的预期相符合,说明我们对单链表的操作有了较好的掌握。
实验总结:通过本次实验,我们不仅加深了对单链表的理解,还提高了编程能力和数据结构的应用能力。
我们对单链表的操作有了更深入的了解,为以后在实际项目中应用单链表打下了良好的基础。
结语:单链表作为一种常见的数据结构,在实际应用中具有重要的作用。
通过本次实验,我们对单链表的操作有了更深入的了解,相信在以后的学习和工作中能够更好地应用和运用单链表。
希望本次实验报告能够对读者有所帮助,也欢迎大家对实验结果进行讨论和交流。
单链表的基本操作(查找,插入,删除)
单链表的基本操作(查找,插⼊,删除)这周⽼师给的作业跟上周貌似差不多。
只是⽤了单链表。
完成单链表的基本操作函数。
1) 初始化单链表2) 给定的数据元素存放在⼀维数组中,分别完成头插法和尾插法建⽴单链表3) 将数据元素从键盘依次输⼊,分别完成头插法和尾插法建⽴单链表4) 输出单链表的长度5) 实现按位查找和按值查找6) 实现插⼊和删除操作7) 实现遍历单链表操作#include <cstdio>#include <cstring>#include <cstdlib>//查找1.内容2.序号//插⼊//删除typedef struct student{int num;char name[10];}STU;typedef struct Node{STU data;struct Node * next;}Node;void denglu(Node *L);//登录函数void chazhao(Node *L);//查找函数void Printf(Node *L);//输出函数void CreateFromHead(Node *L);//头插法void CreateFormTail(Node *L);//尾插法void panduan(Node *L);//判断头插还是尾插void Get(Node *L);//按序号结点查找void Locate(Node *L);//按内容查找(值)void Inslist(Node *L);//插⼊void Dellist(Node *L);//删除void Dellist(Node *L)//删除{system("CLS");int n;printf("请输⼊要删除的结点\n");scanf("%d",&n);if(n<=0){printf("输⼊的数据不合法,请重新输⼊\n");Dellist(L);}Node *pre,*r;int k=0;pre=L;while(pre->next !=NULL&&k<n-1){pre=pre->next;k=k+1;}if(pre->next==NULL){printf("没有找到该结点,请重新输⼊\n");Dellist(L);}r=pre->next;pre->next=r->next;free(r);printf("删除成功!\n");denglu(L);}void Inslist(Node *L)//插⼊{system("CLS");int n;printf("请输⼊在第⼏个位置插⼊数据\n");scanf("%d",&n);printf("请输⼊插⼊的学号,姓名\n");int num1;char name1[10];scanf("%d %s",&num1,name1);Node *pre,*s;int k=0;if(n<=0){printf("输⼊的数据不合法,请重新输⼊\n");Inslist(L);}pre=L;while(pre!=NULL&&k<n-1){pre=pre->next;k=k+1;}if(pre==NULL){printf("⽆法找到该节点,请重新输⼊\n");Inslist(L);}s=(Node*)malloc(sizeof(Node));strcpy(s->data .name ,name1);s->data.num=num1;s->next =pre->next ;pre->next =s;printf("插⼊成功!\n");denglu(L);}void Locate(Node *L)//按内容查找(值){system("CLS");int n;printf("请输⼊要查找的学号\n");scanf("%d",&n);Node *p;p=L->next;while(p!=NULL){if(p->data.num!=n){p=p->next;}elsebreak;}printf("你要查找的学号所对应的信息为%d %s\n",p->data.num,p->);denglu(L);}void Get(Node *L)//按序号结点查找{system("CLS");int n;printf("请输⼊你要查找的结点\n");scanf("%d",&n);if(n<=0){printf("输⼊的数据不合法,请重新输⼊\n");Get(L);}Node *p;p=L;int j=0;while((p->next!=NULL)&&(j<n)){p=p->next;j++;}if(n==j){printf("你要查找的结点的储存位置的数据为%d %s\n",p->data.num,p->); }denglu(L);}void Printf(Node *L){int q=0;Node *p=L->next;while(p!=NULL){q++;printf("%d %s\n",p->data.num,p->); p=p->next;}printf("单链表长度为%d\n",q);denglu(L);}void chazhao(Node *L){printf("1.按序号查找\n");printf("2.按内容查找\n");printf("3.返回主界⾯\n");int aa;scanf("%d",&aa);switch(aa){case 1:Get(L);case 2:Locate(L);case 3:denglu(L);break;default:printf("输⼊错误请重新输⼊\n");chazhao(L);}}void denglu(Node *L){int a;printf("请选择你要做什么\n");printf("1.查找\n");printf("2.插⼊\n");printf("3.删除\n");printf("4.打印现有的学⽣信息及单链表长度\n"); printf("5.退出\n");scanf("%d",&a);switch(a){case 1:chazhao(L);case 2:Inslist(L);case 3:Dellist(L);case 4:Printf(L);case 5:printf("谢谢使⽤\n");exit(0);default:printf("输⼊错误请重新输⼊\n");denglu(L);}}void CreateFromHead(Node *L)//头插法{Node *s;int n;//n为元素个数printf("请输⼊元素个数\n");scanf("%d",&n);printf("请输⼊学号姓名\n");for(int i=1;i<=n;i++){s=(Node *)malloc(sizeof(Node));scanf("%d %s",&s->data.num,s->); s->next=L->next;L->next=s;}}void CreateFormTail(Node *L)//尾插法{Node *s,*r;r=L;int n;//n为元素个数printf("请输⼊元素个数\n");scanf("%d",&n);printf("请输⼊学号姓名\n");for(int i=1;i<=n;i++){s=(Node *)malloc(sizeof(Node));scanf("%d %s",&s->data.num,s->);r->next=s;r=s;if(i==n){r->next=NULL;}}}Node *InitList(Node *L)//初始化单链表{L=(Node *)malloc(sizeof(Node));L->next=NULL;return L;}void panduan(Node *L){int q;printf("请选择⽤哪种⽅式建⽴链表\n");printf("1.头插法\n");printf("2.尾插法\n");scanf("%d",&q);switch(q){case (1):CreateFromHead(L);printf("输⼊成功!\n");break;case (2):CreateFormTail(L);printf("输⼊成功!\n");break;default:printf("输⼊错误请重新输⼊\n");panduan(L);}}int main(){Node *L=NULL;L=InitList(L);panduan(L);denglu(L);return 0;}ps.贴上来的代码空格有点⼩奇怪啊。
链表的常见操作
链表的常见操作
链表是一种常见的数据结构,其存储元素的个数是不受限定的,当要添加更多元素时,存储的个数会随之增加。
链表的操作包括但不限于以下几种:
1. 创建:链表的创建包括初始化链表、分配内存空间等操作。
2. 插入:在链表的指定位置插入一个元素。
3. 删除:删除链表中的指定元素或删除链表的指定位置的元素。
4. 查找:查找链表中是否存在指定的元素,并返回该元素的位置或指针。
5. 修改:修改链表中指定位置的元素的值。
6. 遍历:按照某种顺序遍历链表,并对每个元素进行操作。
7. 排序:按照某种规则对链表中的元素进行排序。
8. 合并:将两个已排序的链表合并成一个新的已排序链表。
9. 反转:将链表中的元素顺序反转。
10. 判断:判断链表是否为空、是否为循环链表等。
以上是链表的一些常见操作,具体实现方式会因编程语言和具体需求而有所不同。
单链表的查找、插入与删除
《数据结构》实验报告一题目:单链表的查找、插入与删除班级:电子0802学号:姓名:日期:2011.03.08 程序名:cqq1.c一、上机实验的问题和要求:单链表的查找、插入与删除。
设计算法,实现线性结构上的单链表的产生以及元素的查找、插入与删除。
具体实现要求:1.从键盘输入20个整数,产生不带表头的单链表,并输入结点值。
2.从键盘输入1个整数,在单链表中查找该结点的位置。
若找到,则显示“找到了”;否则,则显示“找不到”。
3.从键盘输入2个整数,一个表示欲插入的位置i,另一个表示欲插入的数值x,将x插入在对应位置上,输出单链表所有结点值,观察输出结果。
4.从键盘输入1个整数,表示欲删除结点的位置,输出单链表所有结点值,观察输出结果。
5.将单链表中值重复的结点删除,使所得的结果表中个结点值均不相同,输出单链表所有结点值,观察输出结果。
6.删除其中所有数据值为偶数的结点,输出单链表所有结点值,观察输出结果。
7.把单链表变成带表头结点的循环链表,输出循环单链表所有结点值,观察输出结果。
8.(★)将单链表分解成两个单链表A和B,使A链表中含有原链表中序号为奇数的元素,而B链表中含有原链表中序号为偶数的元素,且保持原来的相对顺序,分别输出单链表A和单链表B的所有结点值,观察输出结果。
二、程序设计的基本思想,原理和算法描述:1、基本操作函数link * get(link *l, int i);//创建链表link * ins (link *l, int a,int i) //在链表内插入值link * find(link *l, int a);//在链表内查找值link * del(link *l, int i); //在链表内删除值link * delrepeat( link *l); //在链表内删除重复值link * deleven(link *l); //删除链表内偶数值link * rotate(link *l); //形成循环链表void divide(link *l); //分解成两个链表cout<<endl;2、基本操作cout<<"请选择您要的操作:";cout<<" 1、插入";cout<<" 2、查找";cout<<" 3、删除";cout<<" 4、删除重复结点";cout<<" 5、删除偶数结点";cout<<" 6、构建循环链表";cout<<" 7、分解为两个链表";cout<<" 0、退出";三、源程序及注释:#include <iostream>using namespace std;typedef struct node{int data;struct node *next;}link;void print1(link *l);link * get(link *l, int i){link *p;int j=0;p=l;while((j<i) && (p->next!=NULL)){p=p->next;j++;}if(j==i)return p;elsereturn NULL;}link * ins (link *l, int a,int i){link *p,*s;p=get(l,i-1);if(p==NULL)cout<<"输入有误"<<endl;else{s=(link *)malloc(sizeof(link));s->data=a;s->next=p->next;p->next=s;}return l;}link * find(link *l, int a){link *p;int i=0;int j=0;p=l;while(p!=NULL){i++;if(p->data!=a)p=p->next;else{cout<<"您查找的数据在第"<<i-1<<"个位置."<<endl;j=1;p=p->next;}}if(j!=1)cout<<"您查找的数据不在线性表中."<<endl;return l;}link * del(link *l, int i){link *p,*s;p=get(l,i-1);if(p==NULL)cout<<"输入有误"<<endl;else{s=p->next;p->next=s->next;free(s);}return l;}link * delrepeat( link *l) // 删除相同元素并释放内存{link *s, *r, *t;if ( l-> next == NULL )return l;s = l-> next;while ( s-> next ){t = s; r = s-> next;while ( t-> next ){if ( s-> data == r-> data ){t-> next = r-> next;free(r);r = t-> next;}else{t = t-> next;r = t-> next;}}s = s-> next;if ( !s )return l;}return l;}link * deleven(link *l){link *q=l;link *p=l->next;while(p){if(p->data%2==0){link *r=p;q->next=p->next;p=p->next;free(r);}{p=p->next;q=q->next;}}return l;}link * rotate(link *l){link * p=l;while(p->next)p=p->next;p->next=l;link * t=l->next;while(t!=l){t=t->next;}cout<<"已经变为循环链表,其他操作将受影响,程序结束!"<<'\n';return l;}void divide(link *l){link * a=l;link * b=(link *)malloc(sizeof(node));b->next=NULL;link *Lb=b;int i=1;link * La=l;link * p=l->next;while(p){if(i++%2==0){La->next=p->next;p->next=NULL;Lb->next=p;Lb=Lb->next;p=La->next;}{p=p->next;La=La->next;}}cout<<"链表a";print1(a);cout<<"链表b";print1(b);}void print1(link *l){int i,k;int a;link *p,*q;cout<<"当前线性表为:"<<endl;p=l;p=p->next;if(l!=NULL)do{cout<<p->data<<" ";p=p->next;}while(p!=NULL);cout<<endl;}link * print(link *l){int i,k;int a;link *p,*q;cout<<"当前线性表为:"<<endl;p=l;p=p->next;if(l!=NULL)do{cout<<p->data<<" ";p=p->next;}while(p!=NULL);cout<<endl;cout<<"请选择您要的操作:";cout<<" 1、插入";cout<<" 2、查找";cout<<" 3、删除";cout<<" 4、删除重复结点";cout<<" 5、删除偶数结点";cout<<" 6、构建循环链表";cout<<" 7、分解为两个链表";cout<<" 0、退出";cout<<endl;cin>>k;if(k==1){cout<<"请输入您要插入的数据值:";cin>>a;cout<<"请输入您要插入的位置:";cin>>i;p=ins(l,a,i);q=print(l);}else if(k==2){cout<<"请输入您要查找的数据值:";cin>>a;p=find(l,a);q=print(l);}else if(k==3){cout<<"请输入您要删除的数据的位置:";cin>>i;p=del(l,i);q=print(l);}else if(k==4){cout<<"删除重复结点后的";p=delrepeat(l);q=print(l);}else if(k==5){cout<<"删除偶数结点后的";p=deleven(l);q=print(l);}else if(k==6){p=rotate(l);q=print(l);}else if(k==7){divide(l);}else if(k==0);else{cout<<"输入错误!"<<endl;}return l;}int main(){cout<<"请输入20个整数:"<<endl;int ch[20];int i;//link *head;link *r,*p,*q,*l;l=(link *)malloc(sizeof(link));l->next=NULL;r=l;for(i=0;i<20;i++){cin>>ch[i];p=(link *)malloc(sizeof(link));p->data=ch[i];p->next=NULL;r->next=p;r=r->next;}q=print(l);return 0;}四、运行输出结果:五、调试和运行程序过程中产生的问题及采取的措施:1、本次实验采用C++语言,程序基本能实现实验所要求的操作功能,但是首次使用C++来完成所有链表的操作,有很多小细节不够注意,比如定义结点与结点的使用,需要多操作,多熟悉语。
单链表的建立、增加元素、删除元素、查找元素算法
单链表的建立、增加元素、删除元素、查找元素算法
单链表是一种常用的数据结构,由一个个节点构成,每个节点包含一个数据域和一个指向下一个节点的指针。
本文将介绍单链表的建立、增加元素、删除元素、查找元素算法。
一、单链表的建立
单链表的建立需要创建一个头结点,它不存储数据,只有一个指针域指向第一个节点。
接下来,我们用一个循环语句不断读入数据,创建新节点并将其插入到链表中。
二、单链表的增加元素
单链表的增加元素有两种情况,一种是在链表头插入新节点,另一种是在链表尾插入新节点。
在头部插入新节点时,需要先创建新节点,将它的指针域指向原来的头结点,再让头结点指向新节点;在尾部插入新节点时,需要先遍历整个链表找到最后一个节点,再将新节点插入到最后一个节点的后面。
三、单链表的删除元素
单链表的删除元素也有两种情况,一种是删除链表头的节点,另一种是删除链表中指定位置的节点。
在删除头结点时,需要先找到头结点的下一个节点,将其指针域赋给头结点,然后释放原来的头结点;在删除指定位置的节点时,需要先找到该节点的前一个节点,将前一个节点的指针域指向该节点的下一个节点,然后释放要删除的节点。
四、单链表的查找元素
单链表的查找元素有两种情况,一种是查找指定位置的节点,另
一种是查找指定数据域的节点。
在查找指定位置的节点时,需要遍历整个链表找到该位置的节点;在查找指定数据域的节点时,需要遍历整个链表找到数据域与目标值相等的节点。
Java链表(LinkNode)的简单操作:初始化,遍历,插入,删除等
Java链表(LinkNode)的简单操作:初始化,遍历,插⼊,删除等由于java中没有结构体,所以⽤⼀个类来定义链表,代码如下主要包括⼀个data,还有⼀个指向后⾯⼀个节点的next重写了toString函数,返回你想要的数据定义链表的类:package LinkNode;public class LinkNode {public String data;public LinkNode next;public String getData(){return data;}public void setData(String data){this.data=data;}public LinkNode getNext(){return next;}public void setNext(LinkNode next){this.next=next;}public LinkNode(String data,LinkNode next){super();this.data=data;this.next=next;}public LinkNode(){super();}@Overridepublic String toString(){return "data:"+data+" next->"+next;}}1.初始化链表:public static void initLinkNode(LinkNode L){L.setData("#");L.setNext(null);}2.遍历链表,返回链表的长度public static int traverse(LinkNode L){LinkNode p = L;int count = 1;while(p.next!=null){p = p.next;count++;}return count;}3.把链表L的data转化为StringBuffer输出,输出结果为字符串public static StringBuffer outputLinkNode(LinkNode L){StringBuffer str = new StringBuffer("");LinkNode p = L;for(@SuppressWarnings("unused")int i=0;;){str.append(p.data);if(p.next!=null){p = p.next;}else{break;}}return str;}4.在链表L的尾部插⼊⼀个节点,值为datapublic static void insertLinkNode(LinkNode L,String data){LinkNode p = L;LinkNode q = new LinkNode();for(@SuppressWarnings("unused")int i=0;;){if(p.next==null){q.setData(data);q.setNext(null);p.setNext(q);System.out.println("Insert "+data+" success.");break;}else{p = p.next;}}}5.删除第n个节点(从0开始)public static void deleteLinkNode(LinkNode L,int n){int count = 1;LinkNode p = L;for(@SuppressWarnings("unused")int i;;){if(count == n){p.setNext(p.next.next);break;}else{count++;p = p.next;}}}6.从index=n开始遍历,如果后⾯出现str,则返回true否则返回false public static int lastIndex(LinkNode L,String str){LinkNode p = L;int flag = 0;for(int i=0;i<traverse(L);i++){if(p.data==str){//System.out.println(i);flag = i;}p = p.next;}return flag;}测试程序:package LinkNode;public class Quarrel extends Method{public static void main(String[] args){LinkNode L = new LinkNode();System.out.println("初始化:");initLinkNode(L);System.out.println(L.toString());System.out.println("插⼊节点:"); insertLinkNode(L,"R");insertLinkNode(L,"R");insertLinkNode(L,"L");insertLinkNode(L,"L");insertLinkNode(L,"R");insertLinkNode(L,"L");System.out.println(L.toString());int count = traverse(L);System.out.println("节点个数:"+count); StringBuffer str = outputLinkNode(L);System.out.println(str);//最后⼀个L的位置int lastindex = lastIndex(L,"L");System.out.println("最后⼀个L的位置:"+lastindex); System.out.println("删除⼀个节点"); deleteLinkNode(L,2);count = traverse(L);System.out.println("节点个数:"+count);str = outputLinkNode(L);System.out.println(str);System.out.println(L.toString());}}结果如下:。
单链表以及单链表的建立、清空、插入、删除、查找、修改等运算
int size=sizeof(struct lian_node); struct lian_node *llist,*tail,*p; llist=tail=NULL; printf("请输入链表长度 n="); scanf("%d",&n); printf("请输入链表的各个值:"); for(i=1;i<=n;i++){
return llist;
}
/*查找值*/ void SearchDoc_num(struct lian_node*llist,int num) { struct lian_node *ptr; if(llist==NULL){
printf("\n 无结果!\n"); return; } for(ptr=llist;ptr;ptr=ptr->link){ if(ptr->num==num){ printf("输出序号为 : %d\n\n",ptr->n); break; }
#include<stdio.h> #include<stdlib.h> #include<string.h>
struct lian_node{ int n; int num; struct lian_node*link; };
/*单个链表节点的结构体*/
struct lian_node*Create_Lian_Doc(); 一个只有 6 个结点的单链表,并输出该链表*/ void SearchDoc_n(struct lian_node*link,int n); 序号为 n 的结点,并输出*/ void SearchDoc_num(struct lian_node*link,int num); 为 x 的结点,并输出*/ void InsertDoc(struct lian_node*llist,struct lian_node*p,int n); 和值 x。在序号为 n 的结点后插入 x,并输出该链表*/ void DeleteDoc(struct lian_node*llist,int n); 号 n,删除序号为 n 的结点,并输出该链表*/ void Print_Lian_Doc(struct lian_node*llist);
单链表的基本操作代码
单链表的基本操作代码单链表是一种常用的数据结构,它具有优秀的插入和删除性能,在数据存储和处理方面具有广泛的应用。
单链表的基本操作包含创建链表、插入节点、删除节点、查找节点等,下面是单链表的基本操作代码: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;}单链表的基本操作是数据结构中最基础的部分,掌握好这些代码对于往后的学习和应用都会有很大的帮助。
单链表创建、删除、查找、插入之C语言实现
单链表创建、删除、查找、插⼊之C语⾔实现本⽂将详细的介绍C语⾔单链表的创建、删除、查找、插⼊以及输出功能⼀、创建#include<stdio.h>#include<stdlib.h>typedef int ElemType;/*结构体部分*/typedef struct Node{ElemType data; //数值域struct Node *next; //指针域}Linklist;Linklist *InitList(Linklist *L) //初始化单链表{L = (Linklist *) malloc(sizeof(Linklist));L->next = NULL;return L;}Linklist *CreateList(int n){/*通过输⼊n个数据,创建⼀个单链表*/int x,i;Linklist *L,*r,*p;L = InitList(L); //构造头结点r = L;printf("input %d value: ",n);for(i=0;i<n;i++){scanf("%d",&x);p = (Linklist *)malloc(sizeof(Linklist));p -> data = x;p -> next = NULL;r->next = p;r = r->next; //指针r始终指向链表中末数据元素所在位置}return L;}⼆、插⼊int InsItem1(Linklist *L,ElemType item,int x) /*给定的序号来插⼊*/{int i = 1;Linklist *p,*t;p = L;t = (Linklist *)malloc(sizeof(Linklist));t ->data = item;if(L->next==NULL){ /*若L为空表且要求将新结点插⼊到第0个位置*/if(x==1){L->next=t;t->next=NULL;return1;}/*若L为空表且要求将新结点插⼊到第⾮0个位置,则操作失败*/else{printf("wrong!\n");return0;}}while(p->next!=NULL&&i<x)/*查找第i个节点*/{p = p->next;i++;}if(p->next==NULL&&i<x)/*在表中不存在插⼊位置i ,找不到,则插⼊操作失败*/{printf("The node %d is not exist\n",x);return0;}elset->next = p->next;p->next = t;return1;}}int InsItem2(Linklist *L,ElemType item,ElemType k) /*插⼊给定值在链表中的位置*/ {Linklist *q,*p,*t;t = (Linklist *)malloc(sizeof(Linklist));t->data = item;if(L->next==NULL){printf("The linklist is empty\n");return0;}else{q = L;p = L->next;while(p->next!=NULL)/*查找值为k的结点*/{if(p->data!=k){q = p;p = p->next;}elsebreak;}if(p==NULL)/*如p= =NULL,则没有值为k的结点,插⼊操作失败*/{printf("The node %d is not exist\n",k);return0;}else{q->next = t;t->next = p;return1;}}}三、删除int DelItem(Linklist *L,int x)//在单链表中删除数据元素{int i = 1;Linklist *p,*q;p = L;if(L->next==NULL) /*L为空表,⽆结点可删除*/{printf("The linklist is empty!\n");return0;}while(p->next!=NULL&&i<x){p = p->next;i++;}if(p->next==NULL)/*若没有第i个结点,则删除操作失败*/{printf("The node %d is not exist\n",x);return0;}else{q = p->next;p->next = p->next->next;free(q);return1;}}四、查找int LocItem(Linklist *L,ElemType x)//查找给定值的结点位置Linklist *p,*q,*r;int i = 1;if(L->next==NULL){printf("The linklist is empty\n");return0;}else{p = L->next;while(p!=NULL){if(p->data!=x){i++;p = p->next;}elsebreak;}if(p==NULL)/*如p= =NULL,则没有值为item的结点,删除操作失败*/ {printf("The node %d is not exist\n",x);return0;}/*若找到该节点返回该节点的位置*/elsereturn i;}}五、输出void output(Linklist *L) //输出{Linklist *p;p = L->next;printf("output element: \n");for(;p!=NULL;p=p->next){printf(" %d ",p->data);}printf("\n");}六、主函数部分int main(){ElemType x = 5;Linklist *L;L = CreateList(x);output(L);InsItem1(L,3,2);output(L);InsItem1(L,3,4);output(L);DelItem(L,3);output(L);printf("3的位置是: %d",LocItem(L,3));}。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
单链表的初始化,建立,插入,查找,删除。
#include <stdio.h>
#include <stdlib.h>
typedef int ElemType;
//定义结点类型
typedef struct Node
{
ElemType
data;
//单链表中的数据域
struct Node
*next;
//单链表的指针域
}Node,*LinkedList;
//单链表的初始化
LinkedList LinkedListInit() {
Node
*L;
L = (Node
*)malloc(sizeof(Node));
//申请结点空间
if(L ==
NULL)
//判断是否有足够的内存空间
printf("申请内存空间失败\n");
L->next =
NULL;
//将next设置为NULL,初始长度为0的单链表return L;
}
//单链表的建立1,头插法建立单链表
LinkedList LinkedListCreatH()
{
Node
*L;
L = (Node
*)malloc(sizeof(Node));
//申请头结点空间
L->next =
NULL;
//初始化一个空链表
ElemType
x;
//x为链表数据域中的数据
while(scanf("%d",&x) != EOF) {
Node *p;
p = (Node
*)malloc(sizeof(Node));
//申请新的结点
p->data =
x;
//结点数据域赋值
p->next =
L->next;
//将结点插入到表头L-->|2|-->|1|-->NULL L->next = p;
}
return
L;
}
//单链表的建立2,尾插法建立单链表
LinkedList LinkedListCreatT() {
Node
*L;
L = (Node
*)malloc(sizeof(Node));
//申请头结点空间
L->next =
NULL;
//初始化一个空链表
Node
*r;
r =
L;
//r始终指向终端结点,开始时指向头结点
ElemType
x;
//x为链表数据域中的数据
while(scanf("%d",&x) != EOF)
{
Node *p;
p = (Node
*)malloc(sizeof(Node));
//申请新的结点
p->data =
x;
//结点数据域赋值
r->next =
p;
//将结点插入到表头L-->|1|-->|2|-->NULL r = p;
}
r->next = NULL;
return
L;
}
//单链表的插入,在链表的第i个位置插入x的元素
LinkedList LinkedListInsert(LinkedList L,int i,ElemType x) {
Node
*pre;
//pre为前驱结点
pre =
L;
int tempi =
0;
for (tempi =
1; tempi < i; tempi++)
pre =
pre->next;
//查找第i个位置的前驱结点
Node
*p;
//插入的结点为p
p = (Node
*)malloc(sizeof(Node));
p->data = x;
p->next = pre->next;
pre->next = p;
return
L;
}
//单链表的删除,在链表中删除值为x的元素
LinkedList LinkedListDelete(LinkedList L,ElemType x) {
Node
*p,*pre;
//pre为前驱结点,p为查找的结点。
p =
L->next;
while(p->data !=
x)
//查找值为x的元素
{
pre = p;
p = p->next;
}
pre->next =
p->next;
//删除操作,将其前驱next指向其后继。
free(p);
return
L;
}
int main()
{
LinkedList
list,start;
printf("请输入单链表的数据:");
list =
LinkedListCreatH();
for(start =
list->next; start != NULL; start = start->next)
printf("%d ",start->data);
printf("\n");
int
i;
ElemType
x;
printf("请输入插入数据的位置:"); scanf("%d",&i);
printf("请输入插入数据的值:"); scanf("%d",&x); LinkedListInsert(list,i,x);
for(start =
list->next; start != NULL; start =
start->next)
printf("%d ",start->data);
printf("\n");
printf("请输入要删除的元素的值:"); scanf("%d",&x); LinkedListDelete(list,x);
for(start =
list->next; start != NULL; start = start->next)
printf("%d ",start->data); printf("\n");
return
0;
}。