单链表的建立及插入删除操作-c语言
数据结构-单链表元素的删除与插入
单链表的删除与插入源程序如下：#include<stdio.h>#include<malloc.h>#include<windows.h>typedef int elemtype;typedef struct LNode //定义单链表存储类型{elemtype data;struct LNode *next;}linklist;void creatlistf(linklist *&L ) //建立链表{linklist *s;int i;elemtype a[10];printf("请输入10个数:\n");for(i=0;i<10;i++)scanf("%d",&a[i]);L=(linklist *)malloc(sizeof(linklist));L->next=NULL;for(i=0;i<10;i++){s=(linklist *)malloc(sizeof(linklist));s->data=a[i];s->next=L->next;L->next=s;}}void displist(linklist *L) //输出单链表{linklist *s;s=L->next;while(s!=NULL){printf(" %d",s->data);s=s->next;}printf("\n");}void listinsert(linklist *L) //插入元素{int i=0,j,m;linklist *s,*p;printf("请输入插入位置:");scanf("%d",&j);printf("请输入需插入元素:");scanf("%d",&m);s=L;while(i<j-1 && s!=NULL){s=s->next;i++;}if(s==NULL)printf("输入错误!\n");else{p=(linklist *)malloc(sizeof(linklist)); p->data=m;p->next=s->next;s->next=p;}}void listdelete(linklist *&L)//删除元素{int i,j=0,e;printf("请输入需删除第几个元素:"); scanf("%d",&i);linklist *s;s=L;while(j<i-1&&s!=NULL){s=s->next;j++;}if(s->next==NULL)printf("输入错误!\n");else{if(s->next->next!=NULL){e=s->next->data;s->next->data=s->next->next->data;s->next->next=s->next->next->next;printf("成功删除元素%d\n",e);}else if(s->next!=NULL&&s->next->next==NULL){printf("成功删除元素%d\n",s->next->data);free(s->next);s->next=NULL;}else{printf("&&&&&&&&&");printf("输入错误!\n");}}}void main(){printf(" ***************欢迎使用单链表基本运算系统********************\n"); linklist *p;int m;creatlistf(p); //建立链表printf("单链表已建立完毕\n");while(1){printf("请选择:");printf(" 1.输出链表\n");printf(" 2.插入元素\n");printf(" 3.删除元素\n");printf(" 4.退出\n");scanf("%d",&m);switch(m){case 1:displist(p);break;case 2:listinsert(p);break;case 3:listdelete(p);break;case 4:exit(0);default:printf("输入错误\n");}}}运行效果如下：。
单链表基本操作的实现
单链表基本操作的实现单链表是一种常见的数据结构，它由多个节点组合而成，每个节点包含一个数据元素和一个指向下一个节点的指针。
通过指针，我们可以方便地在单链表中进行插入、删除和遍历等操作。
以下是关于单链表基本操作的实现。
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. 单链表的删除单链表的删除可以分为在链表头部删除、在链表尾部删除和在链表中间删除三种情况。
c语言数据结构之单链表的插入和删除操作
c语⾔数据结构之单链表的插⼊和删除操作1，定义⼀个单链表基础定义先了解⼀下：struct LNode{ //定义单链表结点类型ElemType data; //每个节点存放⼀个数据元素struct LNode *next; //指针指向下⼀个节点}LNode,*LinkList;/*struct LNode *p=(struct LNode*)malloc(sizeof(struct LNode)); //增加⼀个新的结点，在内存中申请⼀个结点所需的空间，并⽤指针p 指向这个结点*/LNode *GetElem(LinkList L,int i){int j=1;LNode *p=L->next;if(i==0)return L;if(i<1)return NULL;while(p!=NULL&&j<i){p=p->next;j++;}return p;}上述代码*LNode GetElem(LinkList L,int i)中需要注意的是：若强调这是⼀个单链表，使⽤ LinkList；若强调这是⼀个结点，则使⽤LNode *。
1，不带头结点的单链表struct LNode{ //定义单链表结点类型ElemType data; //每个节点存放⼀个数据元素struct LNode *next; //指针指向下⼀个节点}LNode,*LinkList;bool InitList(LinkList &L){ //初始化⼀个单链表L=NULL; //空表，防⽌脏数据return true;}void test(){LinkList L; //声明⼀个指向单链表的指针//初始化⼀个空表InitList(L);//.....}2，带头结点的单链表struct LNode{ //定义单链表结点类型ElemType data; //每个节点存放⼀个数据元素struct LNode *next; //指针指向下⼀个节点}LNode,*LinkList;//初始化⼀个单链表bool InitList(LinkList &L){L=(LNode *)malloc(sizeof(LNode)); //分配⼀个头结点if(L==NULL) //内存不⾜，分配失败return false;L->next=NULL; //头结点之后暂时还没有结点return true;}//判断单链表是否为空（带头结点）bool Empty(LinkList L){if(L-next==NULL)return true;elsereturn false;}void test(){LinkList L; //声明⼀个指向单链表的指针//初始化⼀个空表InitList(L);//.....2，单链表的基本操作1，插⼊1，按位序插⼊（ListInsert(&L,i,e)）在第i 个位置插⼊元素e （带头结点）bool ListInsert(LinkList &L,int i,ElemType e){if(i<1)return false;LNode *p; //指针p 指向当前扫描到的节点int j=0; //当前p指向的是第⼏个结点p=L; //L指向头结点，头结点是第0 个结点（不存数据）while(p!=NULL&&j<i-1){ //循环找到第i-1个结点p=p->next;j++;}if(p==NULL) //i 值不合法return false;LNode *s=(LNode *)malloc(sizeof(LNode));s->data=e;s->next=p->next;p->next=s; //将结点s 连到p 之后return true； //插⼊成功}不带头结点的：（不存在 “第0个“ 结点）实现代码如下：bool ListInsert(LinkList &L,int i,ElemType e){if(i<1)return false;if(i==1){ //插⼊第1个结点的操作与其他结点操作不同LNode *s=(LNode *)malloc(sizeof(LNode));s->data=e;s->next=L;L=s; //头指针指向新结点return true;}LNode *p; //指针p指向当前扫描到的节点int j=1; //当前p 指向的是第⼏个结点p=L; //p指向第1个结点（注意：不是头结点）while(p!=NULL&&j<i-1){ //循环找到第i-1个结点p=p->next;j++;}if(p==NULL) //i 值不合法return false;LNode *s=(LNode *)malloc(sizeof(LNode));s->data=e;s->next=p->next;p->next=s; //将结点s 连到p 之后return true； //插⼊成功}2，指定结点的后插操作（InsertNextNode(LNode *p,ElemType e)在p 结点之后插⼊元素e ：bool InsertNextNode(LNode *p,ElemType e){if(p==NULL)return false;LNode *s=(LNode *)malloc(sizeof(LNode));if(s==NULL) //内存分配失败return false;s->data=e; //⽤结点s保存数据元素es->next=p->next;p->next=s;}3，指定结点的前插操作在p 结点之前插⼊**元素e **：bool InsertPrioNode(LNode *p,ElemType e){if(p==NULL)return false;LNode *s=(LNode *)malloc(sizeof(LNode));if(s==NULL) //内存分配失败return false;s->next=p->next;p->next=s; //新结点s 连接到p 之后s->data=p->data; //将p 中元素复制到s 中p->data=e; //p 中元素覆盖为ereturn true;}结合下图在体会⼀下：下⾯再看⼀下在p 结点之前插⼊**结点s **：bool InsertPrioNode(LNode *p,ElemType e){if(p==NULL||s==NULL)return false;s->next=p->next;p->next=s; //s 连接到p 之后ElemType temp=p->data; //交换数据域部分p->data=s->data;s->data=temp;return true;}这招偷天换⽇结合下图好好体会⼀下：2，删除1，按位序删除（带头结点）删除表L 中第i 个位置的元素，并⽤e 返回删除元素的值。
单链表的基本操作c语言
单链表的基本操作(C语言)什么是单链表单链表（Singly Linked List）是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。
每个节点只能访问其后继节点，而无法直接访问前驱节点。
单链表的特点是可以动态地插入和删除节点，相比于数组，具有更好的灵活性和扩展性。
在C语言中，我们可以使用指针来实现单链表。
单链表的基本操作1. 定义单链表结构体在C语言中，我们首先需要定义一个表示单链表的结构体。
结构体包含两个成员：数据元素和指向下一个节点的指针。
typedef struct Node {int data; // 数据元素struct Node *next; // 指向下一个节点的指针} Node;2. 创建单链表创建一个空的单链表需要进行以下步骤：•定义头节点，并初始化为NULL。
•向链表中插入新的节点。
Node* createLinkedList() {Node *head = NULL; // 头节点初始化为NULLint n; // 节点数量printf("请输入要创建的节点数量：");scanf("%d", &n);for (int i = 0; i < n; i++) {int data;printf("请输入第%d个节点的值：", i + 1);scanf("%d", &data);Node *newNode = (Node*)malloc(sizeof(Node)); // 创建新节点newNode->data = data;newNode->next = NULL;if (head == NULL) {head = newNode; // 如果是第一个节点，将其设置为头节点 } else {Node *temp = head;while (temp->next != NULL) {temp = temp->next; // 移动到链表末尾}temp->next = newNode; // 将新节点插入到链表末尾}}return head;}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、通过指针访问下一个节点，直到遇到尾节点。
优缺点单链表的优点是简单，灵活，易于实现和扩展，可以方便地进行插入和删除等操作。
其缺点是存在指针开销，查找元素时需要遍历整个链表，不能直接访问链表中任意位置的节点。
总结单链表是一种最常用的数据结构，它是由一系列节点组成，每个节点包含一个数据元素和一个指针，指向下一个节点。
单链表（建立、插入、删除、打印）
单链表（建⽴、插⼊、删除、打印）单向链表创建链表是动态分配存储空间的链式存储结构。
其包括⼀个“头指针”变量，其中第0个结点称为整个链表的头结点，头结点中存放⼀个地址，该地址指向⼀个元素，头结点⼀般不存放具体数据，只是存放第⼀个结点的地址。
链表中每⼀个元素称为“结点”，每个结点都由两部分组成：存放数据元素的数据域和存储直接后继存储位置的指针域。
指针域中存储的即是链表的下⼀个结点存储位置，是⼀个指针。
多个结点链接成⼀个链表。
最后⼀个结点的指针域设置为空(NULL)，作为链表的结束标志，表⽰它没有后继结点。
使⽤结构体变量作为链表中的结点，因为结构体变量成员可以是数值类型，字符类型，数组类型，也可以是指针类型，这样就可以使⽤指针类型成员来存放下⼀个结点的地址，使其它类型成员存放数据信息。
当⼀个序列中只含有指向它的后继结点的链接时，就称该链表为单链表。
单链表的⽰意图如下：Head指针为单链表的头指针，单链表L：L既是单链表的名字，也是其头指针。
链表中的最后⼀个结点的指针域定义为空指针(NULL)。
在创建列表时要动态为链表分配空间，C语⾔的库函数提供了⼏种函数实现动态开辟存储单元。
malloc()函数实现动态开辟存储单元：malloc函数原型为：void *malloc(unsigned int size);其作⽤是在内存的动态存储区中分配⼀个长度为size的连续空间，函数返回值是⼀个指向分配域起始地址的指针（类型为void）。
如果分配空间失败（如，内存空间不⾜），则返回空间指针（NULL）1.单链表的初始化，即建⽴⼀个空链表。
//不带头结点的单链表的初始化void LinkedListInit1(LinkedList L){L=NULL;}//带头结点的单链表的初始化void LinkedListInit2(LinkedList L){L=(LNode *)malloc(sizeof(LNode));if(L==NULL){printf("申请空间失败！");exit(0);}L->next=NULL;}2.单链表的求表长操作单链表的求表长操作需要设定当前指针p和⼀个计数器j，初始时p指向链表中的第⼀个结点，p每向下移动⼀个结点时，j就加1，直到到达p 链表的尾部。
「C语言」单链表双向链表的建立遍历插入删除
「C语⾔」单链表双向链表的建⽴遍历插⼊删除最近临近期末的C语⾔课程设计⽐平时练习作业⼀下难了不⽌⼀个档次，第⼀次接触到了C语⾔的框架开发，了解了View（界⾯层）、Service（业务逻辑层）、Persistence（持久化层）的分离和耦合，⼀种⾯向过程的MVC的感觉。
⽽这⼀切的基础就在于对链表的创建、删除、输出、写⼊⽂件、从⽂件读出......本篇⽂章在于巩固链表的基础知识（整理⾃《C语⾔程序设计教程--⼈民邮电出版社》第⼗章——指针与链表），只对链表的概念及增删改查作出探讨，欢迎指教。
⼀、链表结构和静态/动态链表⼆、单链表的建⽴与遍历三、单链表的插⼊与删除四、双向链表的概念五、双向链表的建⽴与遍历六、双向链表的元素查找七、循环链表的概念⼋、合并两个链表的实例九、链表实战拓展思维、拉到最后去看看 (•ᴗ•)و⼀、链表结构和静态/动态链表链表是⼀种常见的数据结构——与数组不同的是：1.数组⾸先需要在定义时声明数组⼤⼩，如果像这个数组中加⼊的元素个数超过了数组的长度时，便不能正确保存所有内容；链表可以根据⼤⼩需要进⾏拓展。
2.其次数组是同⼀数据类型的元素集合，在内存中是按⼀定顺序连续排列存放的；链表常⽤malloc等函数动态随机分配空间，⽤指针相连。
链表结构⽰意图如下所⽰：在链表中，每⼀个元素包含两个部分；数据部分和指针部分。
数据部分⽤来存放元素所包含的数据，指针部分⽤来指向下⼀个元素。
最后⼀个元素的指针指向NULL，表⽰指向的地址为空。
整体⽤结构体来定义，指针部分定义为指向本结构体类型的指针类型。
静态链表需要数组来实现，即把线性表的元素存放在数组中。
数组单元存放链表结点，结点的链域指向下⼀个元素的位置，即下⼀个元素所在数组单元的下标。
这些元素可能在物理上是连续存放的，也有可能是不连续的，它们之间通过逻辑关系来连接——这就要涉及到数组长度定义的问题，实现⽆法预知定义多⼤的数组，动态链表随即出现。
动态链表指在程序执⾏过程中从⽆到有地建⽴起⼀个链表，即⼀个⼀个地开辟结点和输⼊各结点的数据，并建⽴起前后相连的关系。
单链表插入和删除节点的代码
单链表插入和删除节点的代码单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。
在实际应用中，我们经常需要对单链表进行插入和删除操作，以便动态地修改和管理数据。
1. 单链表的定义首先，我们需要定义一个单链表的数据结构。
在这个例子中，我们将使用C++语言来实现。
#include <iostream>// 定义单链表节点struct ListNode {int val; // 节点的值ListNode* next; // 指向下一个节点的指针// 构造函数ListNode(int x) : val(x), next(nullptr) {}};// 定义单链表类class LinkedList {private:ListNode* head; // 头指针public:LinkedList() : head(nullptr) {}// 插入节点到链表尾部void insertNode(int val) {ListNode* newNode = new ListNode(val);if (head == nullptr) {head = newNode;} else {ListNode* curr = head;while (curr->next != nullptr) {curr = curr->next;}curr->next = newNode;}}// 删除指定值的节点void deleteNode(int val) {if (head == nullptr) {return;}if (head->val == val) {ListNode* temp = head;head = head->next;delete temp;return;}ListNode* curr = head;while (curr->next != nullptr) {if (curr->next->val == val) {ListNode* temp = curr->next;curr->next = curr->next->next;delete temp;return;}curr = curr->next;}}// 打印链表void printList() {ListNode* curr = head;while (curr != nullptr) {std::cout << curr->val << " ";curr = curr->next;}std::cout << std::endl;}};2. 单链表插入节点在单链表中插入节点通常有两种情况：插入到链表的头部和插入到链表的尾部。
单链表的插入和删除
#include "stdlib.h"#include "stdio.h"#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEAIBLE -1#define OVERFLOW -2typedef int Status;typedef int ElemType;typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;void GreaeList(LinkList &L,int n){int i; LNode *p;L=(LinkList)malloc(sizeof(LNode));L->next=NULL; printf(" 请输入元素的值:\n");for(i=n;i>0;--i){p=(LinkList)malloc(sizeof(LNode));scanf("%d",&p->data);p->next=L->next;L->next=p;}}Status ListInsert(LinkList &L,int i,ElemType e){LNode *p,*s;int j;p=L;j=0;while(p&&j<i-1){p=p->next;++j;}if(!p||j>i-1) return ERROR;s=(LinkList)malloc(sizeof(LNode));s->data=e;s->next=p->next;p->next=s;return OK;}Status ListDelete(LinkList &L,int i){LNode *p,*q;int j;ElemType e;p=L;j=0;while(p->next&&j<i-1){p=p->next;++j;}if(!(p->next)||j>i-1)return ERROR;q=p->next;p->next=q->next;e=q->data; free(q);return OK;}void print(LinkList &L){LNode *p;p=L->next;while(p){printf(" %d",p->data);p=p->next ;}printf("\n");}void main(){LinkList L;int i;GreaeList(L,10);printf(" 单链表的插入和删除\n");printf(" 实现插入按1\n");printf(" 实现删除按2\n");printf(" 请输入1或2\n");scanf("%d",&i);while(i!=1&&i!=2){printf(" 输入错请重新输入\n");scanf("%d",&i);}switch(i){case 1: {printf(" 插入后的线性表为:");ListInsert(L,2,9);print(L);break;}case 2: {printf(" 删除后的线性表为:");ListDelete(L,3);print(L);}}}。
单链表的建立、增加元素、删除元素、查找元素算法
单链表的建立、增加元素、删除元素、查找元素算法
单链表是一种常用的数据结构，由一个个节点构成，每个节点包含一个数据域和一个指向下一个节点的指针。
本文将介绍单链表的建立、增加元素、删除元素、查找元素算法。
一、单链表的建立
单链表的建立需要创建一个头结点，它不存储数据，只有一个指针域指向第一个节点。
接下来，我们用一个循环语句不断读入数据，创建新节点并将其插入到链表中。
二、单链表的增加元素
单链表的增加元素有两种情况，一种是在链表头插入新节点，另一种是在链表尾插入新节点。
在头部插入新节点时，需要先创建新节点，将它的指针域指向原来的头结点，再让头结点指向新节点；在尾部插入新节点时，需要先遍历整个链表找到最后一个节点，再将新节点插入到最后一个节点的后面。
三、单链表的删除元素
单链表的删除元素也有两种情况，一种是删除链表头的节点，另一种是删除链表中指定位置的节点。
在删除头结点时，需要先找到头结点的下一个节点，将其指针域赋给头结点，然后释放原来的头结点；在删除指定位置的节点时，需要先找到该节点的前一个节点，将前一个节点的指针域指向该节点的下一个节点，然后释放要删除的节点。
四、单链表的查找元素
单链表的查找元素有两种情况，一种是查找指定位置的节点，另
一种是查找指定数据域的节点。
在查找指定位置的节点时，需要遍历整个链表找到该位置的节点；在查找指定数据域的节点时，需要遍历整个链表找到数据域与目标值相等的节点。
实验二 单链表的插入和删除
实验二 单链表的插入和删除1.实验目的：了解单链表的基本概念、结构的定义及在单链表上的基本操作(插入、删除、查找以及线性表合并)，通过在VC 实现以上操作更好的了解书本上的内容并体会线性表的两种存储结构的区别。
2.实验预备知识：⑴ 复习C 语言中指针的用法，特别是结构体的指针的用法；⑵ 了解单链表的概念，单链表的定义方法；单链表是线性表的链式存储表示，是用一组任意的存储单元依次存储线性表的数据元素。
因此，为了表示每个数据元素a i 与其直接后继元素a i+1之间的逻辑关系，对数据元素ai 来说，，除了存储其本身的信息之外，还需存储一个指示其直接后继的信息（即直接后继的存储位置），而这部分就是用指针来完成的。
⑶ 掌握线性表在链式存储结构上实现基本操作：查找、插入、删除的算法； 在实现这些算法的时候，要注意判断输入数据的合法性，除此之外还要要注意以下内容：在实现查找的时候，首先要判断该顺序表是否为空，其次要判断查找后的结果(查到时输出查到的数据，未查到时给出错误提示)。
在实现插入的时候，由于是链式存储，它可以随机产生和回收存储空间，所以它不要判断线性表是否为满，但仍需判断要插入的位置是否合法，原因同实验一，其次要注意插入的时候语句的顺序不可颠倒，否则出错。
例如：s 所指向结点要插入在p 所指向的结点之后，则：正确形式：s->next=p->nextp->next=s错误形式：p->next=ss->next=p->next(因为此时p->next 已经指向s 了)在实现删除的时候，首先要判断线性表是否为空，为空则不能删除； 其次在删除后要回收空间。
例如：删除如上图所示s 所指向的结点p->next=p->next->nextfree s3.实验内容：⑴ 单链表的插入算法⑵ 单链表的删除算法⑶循环链表的插入和删除算法4.部分实验代码：⑴单链表的结构定义：#include <stdio.h>typedef int elemtype;typedef struct lnode{ elemtype data;struct lnode *next;}*linklist;⑵建立单链表的算法int n; /*n作为整个程序的全局变量*/linklist *creat(void){ linklist *head, *p1, *p2;n=0;p1=p2=(linklist *)malloc(sizeof(linklist));scanf(“%d”,&p1->data);head=null;while(p1->data!=0){ n=n+1;if(n==1) head=p1;else p2->next=p1;p2=p1;p1=(linklist *)malloc(sizeof(linklist));scanf(“%d”,&p1->data);}p2->next=null;return(head);}⑶单链表的插入算法int insert(linklist *head, int i,elemtype e) { linklist *p, *s;int j;p=head; j=0;while(p && j<i-1){ p=p->next;++j;}if(!p||j>i-1){ printf(“无法插入”)；return 0;}s=(linklist *)malloc(sizeof(lnode));s->data=e;s->next=p->next;p->next=s;return 1;}⑷单链表的删除算法int deltree(linklist *head,int i,elemtype e){ linklist *p, *q;int j;lp=head; j=0;while(p->next && j<i-1){ p=p->next;++j;}if(!(p->next)||j>i-1){ printf(“无法删除”);return 0;}q=p->next;p->next=q->next;e=q->data;free(q);return 1;}。
【头歌】单链表的基本操作
【头歌】单链表的基本操作
单链表是一种线性数据结构，由一系列节点组成，每个节点包含数据元素和一个指向下一个节点的指针。
以下是单链表的基本操作：
1. 插入操作：在单链表的指定位置插入一个新节点。
具体步骤如下：
找到要插入的位置的前一个节点；
将新节点插入到前一个节点和当前节点之间；
修改新节点的指针，使其指向当前节点；
修改前一个节点的指针，使其指向新节点。
2. 删除操作：删除单链表中的指定节点。
具体步骤如下：
找到要删除的节点的前一个节点；
将前一个节点的指针指向要删除的节点的下一个节点；
释放要删除的节点的内存。
3. 查找操作：在单链表中查找指定元素。
具体步骤如下：
从头节点开始遍历单链表；
找到与指定元素相等的节点；
返回该节点的位置。
4. 遍历操作：从头节点开始，依次访问单链表中的每个节点。
具体步骤如下：创建一个指针指向头节点；
依次访问指针所指向的每个节点，直到指针为空。
5. 打印操作：打印单链表中的所有元素。
具体步骤如下：
创建一个指针指向头节点；
依次打印指针所指向的每个节点的数据元素，直到指针为空。
以上是单链表的基本操作，通过这些操作可以对单链表进行各种操作，如插入元素、删除元素、查找元素等。
单链表的创建,插入删除以及读取记录
#include<stdio.h>#include<stdlib.h>#include<string.h>#include<malloc.h>int n,id;//int fd;FILE *fp;struct student{long num;int age;float score;struct student *next;};struct student *head;//struct student *f,*sp;struct student *create(){struct student *p,*q;n=0,head=NULL;p=(struct student *)malloc(sizeof(struct student));q=(struct student *)malloc(sizeof(struct student));printf("please input the records:\n");scanf("%ld %d %f",&q->num,&q->age,&q->score);if(q->num!=0){if((fp=fopen("/home/linux/shiyan/listfile.c","ab+"))==NULL){printf("can not open the file.\n");return;}if(fwrite(q,sizeof(struct student),1,fp)!=1){printf("can not write file!\n");}printf("ok!\n");fclose(fp);}else{printf("over write records into file.\n");}while(q->num!=0){n+=1;if(n==1){head=q;}else{p->next=q;}p=q;q=(struct student *)malloc(sizeof(struct student));printf("please input more records:\n");scanf("%ld %d %f",&q->num,&q->age,&q->score);if(q->num!=0){if((fp=fopen("/home/linux/shiyan/listfile.c","ab+"))==NULL){printf("can not open the file.\n");return;}if(fwrite(q,sizeof(struct student),1,fp)!=1){printf("can not write file!\n");}printf("ok!\n");fclose(fp);}else{printf("over write records into file.\n");}}p->next=NULL;return head;}void print(){struct student *l;printf("the numbers of list are:%d\n",n);l=head;if(head!=NULL){do{printf("num:%ld age:%d score:%.1f\n",l->num,l->age,l->score);l=l->next;}while(l!=NULL);}else{printf("the list is null.\n");}struct student *insert(){struct student *e,*t,*x,*into;t=head;printf("please input the insert record:\n");into=(struct student *)malloc(sizeof(struct student));scanf("%ld %d %f",&into->num,&into->age,&into->score);if(into->num!=0){if((fp=fopen("/home/linux/shiyan/listfile.c","ab+"))==NULL){ printf("can not open the file.\n");return;}if(fwrite(into,sizeof(struct student),1,fp)!=1){printf("can not write file!\n");}printf("ok!\n");fclose(fp);}else{printf("over write records into file.\n");}while(into->num!=0){e=into;if(head==NULL){head=e;e->next=NULL;}else{while((e->num>t->num)&&t->next!=NULL){x=t;t=t->next;}if(e->num<=t->num){if(t==head){head=e;e->next=t;}elsex->next=e;e->next=t;}}else{t->next=e;e->next=NULL;}}n+=1;printf("please input the insert record:\n");into=(struct student *)malloc(sizeof(struct student));scanf("%ld %d %f",&into->num,&into->age,&into->score);if(into->num!=0){if((fp=fopen("/home/linux/shiyan/listfile.c","ab+"))==NULL){ printf("can not open the file.\n");return;}if(fwrite(into,sizeof(struct student),1,fp)!=1){printf("can not write file!\n");}printf("ok!\n");fclose(fp);}else{printf("over write records into file.\n");}}return head;}struct student *delete(){struct student *s,*c;long num;printf("please input the delete record:\n");scanf("%ld",&num);while(num!=0){if(head==NULL){printf("the list is null.\n");return head;}s=head;while((num!=s->num)&&(s->next!=NULL)) {c=s;s=s->next;}if(num==s->num){if(s==head){head=s->next;free(s);}else{c->next=s->next;s=s->next;free(s);}printf("delete %ld is success.\n",num);n-=1;}else{printf("can not found %ld\n",num);}printf("please input the delete record:\n");scanf("%ld",&num);}return head;}struct student *refer(){struct student *r,*m;long rnum;printf("please input to refer num:\n");scanf("%ld",&rnum);r=head;if(rnum!=0){while(m->next!=NULL&&r->num!=rnum){m=r;r=m->next;}if(m->next==NULL){printf("the record is not exist.\n");return head;}if(rnum==r->num){printf("the record find:\n");printf("num:%ld age:%d score:%.1f\n",r->num,r->age,r->score);}}else{printf("the inputer is error.\n");}return head;}/*struct student *save(){FILE *fp;struct student *l1;if((fp=fopen("/home/linux/shiyan/listx","ab+"))==NULL){printf("can not open the file.\n");return;}l1=head;for(id=0;id<n;id++){if(fwrite(l1,sizeof(struct student),1,fp)!=1){printf("can not write file!\n");}l1+=1;printf("ok!\n");}fclose(fp);return head;}*/struct student *load(){FILE *fp;struct student *f1;f1=(struct student *)malloc(sizeof(struct student));if((fp=fopen("/home/linux/shiyan/listfile.c","rb"))==NULL){printf("can not open the file!\n");return;}while(!feof(fp)){if(fread(f1,sizeof(struct student),1,fp)!=NULL){printf("num:%ld age:%d score:%.1f\n",f1->num,f1->age,f1->score); //sp=(struct student *)malloc(sizeof(struct student));// f1=f1->next;n+=1;}}fclose(fp);return f1;}/*void load(){fd=open("/home/linux/shiyan/list.txt",O_RDONLY);for(id=0;id<n;id++){read(fd,buffer,sizeof(buffer));printf("num:%ld age:%d score:%.1f\n",f->num,f->age,f->score);f=f->next;buffer=f;}close(fd);}*//*void save(){fd=open("/home/linux/shiyan/list.txt",O_WRONLY|O_CREAT);for(id=0;id<n;id++){write(fd,f,sizeof(struct student));f=f->next;}close(fd);}*/int choose(){int choice;scanf("%d",&choice);return choice;}void selecte(int number){// head=create();// struct student *head;switch(number){case 1:insert();break;case 2:delete();break;case 3:print();break;case 4:load();break;case 5:refer();break;// case 6:// save();// break;case 6:exit(0);default:printf("the choice is not lawful,please input again\n");break;}}void menu(){printf("==========THE MAIN MENU==========\n");printf("1:insert a record in list.\n");printf("2:delete a record from list.\n");printf("3:printf present records on screen.\n");printf("4:read the records from listfile.c.\n");printf("5:select the record from list.\n");printf("6:get away the main menu.\n");printf("=================================\n");printf("please input a choice:1--2--3--4--5--6\n");selecte(choose());}/*void save(){FILE *fp;if((fp=fopen("list.txt","w"))==NULL){printf("can not open file!\n");return;for(id=0;id<n;id++){if(fwrite(f,sizeof(struct student),1,fp)!=1){printf("can not write file!\n");}f=f->next;}fclose(fp);}*//*void load(){FILE *fp;if((fp=fopen("list.txt","r"==NULL))){printf("can not open file!\n");return;}for(id=0;id<n;id++){if(fread(head,sizeof(struct student),1,fp)!=1){if(feof(fp)){fclose(fp);return;}printf("can not read file!\n");}printf("num:%ld age:%d score:%.1f\n",head->num,head->age,head->score);head=head->next;}fclose(fp);}*/int main(){// printf("please input the records:\n");// h=create();// print(h);/* printf("please input the insert record:\n");into=(struct student *)malloc(sizeof(struct student));scanf("%ld %d %f",&into->num,&into->age,&into->score);while(into->num!=0){h=insert(h,into);print(h);printf("please input the insert record:\n");into=(struct student *)malloc(sizeof(struct student));scanf("%ld %d %f",&into->num,&into->age,&into->score);printf("please input the delete record:\n"); scanf("%ld",&dnum);while(dnum!=0){h=delete(h,dnum);print(h);printf("please input the delete record:\n");scanf("%ld",&dnum);} */head=create();while(1){menu();}return EXIT_SUCCESS;}。
单链表以及单链表的建立、清空、插入、删除、查找、修改等运算
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);
单链表的插入和删除
实验一单链表的插入和删除（4个机时）1.1 实验目的：已知线性表中元素为“TANKK︼YOU”，利用模块化编程思想，编程实现如下函数功能：1）建立一个带头结点的单链表，将线性表中元素依次放入(函数1)；输出该单链表中各元素(函数4)。
2）删除单链表中的第四个元素(函数2)；输出执行删除操作之后的单链表(函数4)；3）在单链表中的第二个元素前插入元素“H”(函数3)；输出执行插入操作之后的单链表(函数4)。
1.2 流程图”1.3 实验步骤及程序代码#include<stdio.h>#include<string.h>#include<malloc.h>struct ZFSZ //定义指针类型{int chardata;struct ZFSZ*next;};#define LEN sizeof(struct ZFSZ)#define N 10char c[N]={'t','a','n','k','k','*','y','o','u'}; //字符数组定义，保存字符“tankk+you”struct ZFSZ* creat() //函数一：建立链表{int a;struct ZFSZ *head;struct ZFSZ *p1,*p2;a=0;p1=(struct ZFSZ*)malloc(LEN);p1->chardata=c[0];while(p1->chardata!=NULL){a=a+1;if(a==1){head=p1;}else{p2->next=p1;}p2=p1;p1=(struct ZFSZ*)malloc(LEN);p1->chardata=c[a];}p2->next=NULL;return(head);}void Print (ZFSZ*head) //函数二：建立打印程序，输出链表中的内容{struct ZFSZ*Pp1,*Phead;Phead=head;Pp1=head;while (Pp1!=NULL&&Pp1->chardata!=0){printf("%c",Pp1->chardata);Pp1=Pp1->next;}printf("\n");}void Dell(ZFSZ*head) //函数三：删除第四个元素{struct ZFSZ*Dp1,*Dp2,*Dhead;Dhead=head;int n=1;for(n;n<=4;n++){if(n==3){Dp1=Dhead;}if(n==4){Dp2=Dhead->next;}Dhead=Dhead->next;}free(Dp1->next);Dp1->next=Dp2;}void ChaRu(struct ZFSZ*head) //函数四：再第二个元素前插入字符‘h’{struct ZFSZ*Cp1,*Cp2,*Chead;Chead=head;int m=1;for(m;m<=2;m++){if(m==1){Cp1=Chead;}Cp2=Chead->next;}Chead=(struct ZFSZ*)malloc(LEN);scanf("%c",&Chead->chardata);Cp1->next=Chead;Chead->next=Cp2;}int main() //主函数{struct ZFSZ *head; //调用函数一，建立链表head = creat();Print(head); //调用函数二输出链表中的内容Dell(head); //调用函数三：删除第四个元素Print(head); //调用函数二输出链表中的内容ChaRu(head); //调用函数四：再第二个元素前插入字符‘h’Print(head); //调用函数二输出链表中的内容}1.4 实验结果。
c语言单链表基本操作
c语言单链表基本操作
5. 查找节点：
```c struct Node* searchNode(struct Node* head, int data) {
c语言单链表基本操作
4. 删除节点：
```c void deleteNode(struct Node** head, int data) {
struct Node* currentNode = *head; struct Node* prevNode = NULL;
// 遍历链表，找到要删除的节点 while (currentNode != NULL && currentNode->data != data) {
c语言单链表基本操作
这些是单链表的基本操作，可以根据需要进行调用和组合，实现对链表的创建、插入、删 除、查找和打印等操作。需要注意的是，在使用完链表后，要记得释放节点所占用的内存， 避免内存泄漏。
struct Node* currentNode = head; while (currentNode != NULL && currentNode->data != data) {
currentNode = currentNode->next; } return currentNode; // 返回找到的节点（如果找到） } ```
c语言单链表基本操作
2. 创建链表： ```c struct Node* createLinkedList() {
return NULL; // 返回一个空链表 }
单链表的建立及插入删除操作-c语言
单链表的基本操作#include <stdio。
h>＃include 〈stdlib。
h>typedef char date；typedef struct node{date ch;struct node ＊next；}list；typedef list *linklist;linklist creat()｛date ch;linklist head=(linklist)malloc（sizeof（list）);list *p，＊r；r=head;ch=getchar()；while(ch！='\n')｛p=（linklist)malloc（sizeof（list）)；p—〉ch=ch;r-〉next=p；r=p;ch=getchar（）;｝r->next=NULL;return (head)；}void insert（linklist head,int i,char x）｛int j=0;linklist r，p；p=head-〉next；while（p＆＆j〈i-1){p=p-〉next;j++；}if(!p｜｜j>i-1）exit(1);r=(linklist）malloc（sizeof（list)）;r->ch=x；r—〉next=p—〉next；p—〉next=r;｝void puter（linklist linker){linklist p；p=linker-〉next;while（p！=NULL）｛printf(”％c "，p—>ch）；p=p—>next;｝｝void delet（linklist head ，int i){int j=0;linklist r,p;p=head->next;while(p&＆j〈i-1）{p=p—>next;j++;}if（！p｜|j〉i-1)exit(1)；r=p->next；p—〉next=r—>next；free(r);｝int main(）｛static int q，k；char w;printf("请输入字符穿,并以ENTER键结束\n")；linklist head，p，linker=creat(）;puter（linker);printf（"请输入插入位置和插入字母\n”)；scanf("％d %c"，&q，＆w）；insert(linker,q,w）;puter（linker）；printf（”\n请输入删除位置的序号：\n”);scanf(”%d",＆k）;delet(linker，k);puter(linker);printf(”\n");return 0;}。
C++实现单链表（创建、插入、删除）
C++实现单链表（创建、插⼊、删除）#include <iostream>#include<cstdlib>using namespace std;enum operation{create_List=1,print_List,insert_Node,delete_Node,delete_List,quit};//枚举类型，⽤于菜单选择结果struct node //结点结构{ int data ;node * next;};operation Menu(); //菜单函数node * CreateList( ); //建⽴链表函数声明void PrintList( node *); //输出链表中结点信息函数声明node * InsertNode(node *,node *); //在链表中插⼊结点函数声明node * DeleteNode(node *,int); //在链表中删除结点函数声明node * deleteList(node *head); //删除整个链表void Create(); //对应操作菜单--创建链表的操作void Print( ); //对应操作菜单--遍历链表的操作void Insert( ); //对应操作菜单--插⼊链表结点的操作void Delete( ); //对应操作菜单--删除链表结点的操作void DeleteAll(); //对应操作菜单--删除整个链表的操作int n=0; //全局整型变量存放链表中结点个数node * head=NULL ; //全局指针变量存放链表头结点地址-头指针int main(){operation menu_choice; //存放菜单选择项do//循环现实直到⽤户退出程序{menu_choice=Menu(); //菜单显⽰及⽤户选择switch(menu_choice) //⽤户选择功能匹配{case create_List: system("cls");cout<<"1 创建链表"<<endl<<endl;Create( );break;case print_List: system("cls");cout<<"2 遍历链表"<<endl<<endl;Print();break;case insert_Node: system("cls");cout<<"3 插⼊链表结点"<<endl<<endl;Insert();break;case delete_Node: system("cls");cout<<"4 删除链表结点"<<endl<<endl;Delete();break;case delete_List: system("cls");cout<<"5 删除整个链表"<<endl<<endl;DeleteAll();break;case quit :default: cout<<"退出链表操作，结束程序"<<endl;return0;}}while(menu_choice!=quit);return0;}/*创建链表*/node * CreateList( ) //建⽴链表函数{ node * s, * p ; // s指向新结点，p指向链表中最后的结点s = new node ; //动态建⽴第⼀个新结点cout<<"请输⼊⼀个整数值作为新结点的数据信息,输⼊0时建⽴链表结束"<<endl;cout<<"第"<<n+1<<"个结点"<<endl;cin >> s->data ; //输⼊新结点数据head = NULL ; //头指针初始值为NULLif( s->data==0) //第⼀个结点数据就为0，建⽴⼀个空链表{cout<<"您建⽴的空链表"<<endl;delete s ; //释放数据为0的结点}else//建⽴⾮空链表{while ( s->data != 0 ) //通过判断新结点数据来进⾏循环{ if ( head == NULL ) head = s ; //头指针赋值else p->next = s ; //将新结点插⼊已有链表的最后p = s ; // p指向链表中最后的结点n=n+1;//结点个数增1s = new node ; //动态建⽴⼀个新结点cout<<"请输⼊⼀个整数值作为新结点的数据信息,输⼊0时建⽴链表结束"<<endl;cout<<"第"<<n+1<<"个结点"<<endl;cin >> s->data ; //输⼊新结点数据}p -> next = NULL ; //设置链表尾部为空delete s ; //释放数据为0的结点cout<<endl<<"链表建⽴完成...";cout<<"建⽴的链表中共有"<<n<<"个节点"<<endl<<endl;}return ( head ) ; //返回头指针}/*遍历链表*/void PrintList( node * head) //输出链表中结点信息函数,链表遍历{ node *p=head;int i=1;cout<<endl<<"遍历链表..."<<endl;if (head!=NULL) //如果链表⾮空，即链表中有结点do//循环输出接点数据，直到移动到链表尾，即最后⼀个结点{ cout<<"第"<<i++<<"个结点数据为:"<<p->data<<endl;p=p->next;}while(p!=NULL) ;else{cout<<"链表是空链表!"<<endl;}cout<<"链表中共有"<<n<<"个节点"<<endl;}/*插⼊结点*/node * InsertNode(node *head,node * s) //插⼊结点的函数，head为链表头指针，s指向要插⼊的新结点{node *p,*q;p=head; //使p指向链表中的第⼀个结点if(head==NULL) //原来的链表是空表{ head=s; //使head指向的新结点作为头结点s->next=NULL;}else//原来的链表不是空表{while((s->data>p->data) && (p->next!=NULL)) //⽤循环定位要插⼊的结点位置p，使s插⼊到p之前的位置 {q=p; //q记录下当前的p，即q指向p的前⼀个结点p=p->next; //p后移⼀个结点}if(s->data<=p->data) //要插⼊的结点数据⽐最后⼀个结点数据⼩{ if(head==p) //判断是否插⼊链表中的第⼀个结点之前{ head=s; //插到原来第⼀个结点之前s->next=p;}else//插到q指向的结点之后，p指向的结点之前{ q->next=s;s->next=p;}}else//要插⼊的结点数据⽐最后⼀个结点数据还⼤{ p->next=s; // 插到链表最后的结点之后，作为链表的尾结点s->next=NULL;}}n=n+1; //结点数加１cout<<"成功完成⼀个新结点插⼊..."<<endl;return (head);}/*删除结点*/node *DeleteNode(node *head,int delData) //删除数据为delDate的结点的函数{node *p,*q;p=head; //使p指向第⼀个结点if (head==NULL) //是空表{ cout<<"该链表是空链表，不能进⾏结点删除!"<<endl;return(head);}//先找到要删除的结点while(delData!=p->data && p->next!=NULL) //p指向的不是所要找的结点且后⾯还有结点{ q=p; //q⽤来记录p前⼀个结点p=p->next;} //p后移⼀个结点if(delData==p->data) //找到了要删除的结点{ if(p==head) //如果要删除的是头结点head=p->next; //若p指向的是⾸结点，把第⼆个结点地址赋予headelse q->next=p->next; //否则将下⼀结点地址赋给前⼀结点地址cout<<"成功删除数据为"<<delData<<"的结点"<<endl;n=n-1;}elsecout<<"要删除的数据为"<<delData<<"的结点在链表中没有找到"<<endl; //找不到该结点return(head);}/*删除整个链表*/node * deleteList(node *head) //删除整个链表{node *p,*s;p=head;if(head==NULL)cout<<"链表本⾝就为空链表";else{while(p->next!=NULL){s=p;p=p->next;delete s;n--;}delete p;n--;head=NULL;}cout<<"整个链表删除成功!"<<endl;return head;}/*菜单函数*/operation Menu(){ int choice;cout<<endl<<endl;cout<<"+-------------链表操作菜单---------------+"<<endl;cout<<"| |"<<endl;cout<<"| 1->创建链表 |"<<endl;cout<<"| 2->遍历链表 |"<<endl;cout<<"| 3->插⼊节点 |"<<endl;cout<<"| 4->删除节点 |"<<endl;cout<<"| 5->删除链表 |"<<endl;cout<<"| 6->退出 |"<<endl;cout<<"| |"<<endl;cout<<"+----------------------------------------+"<<endl;cout<<endl<<endl<<"请输⼊功能序号";cin>>choice;return operation(choice);}/*对应操作菜单--创建链表的操作*/void Create(){if(head==NULL) //如果链表中已有结点，不允许重新建⽴{head=CreateList( );}else{cout<<"已创建过链表，不允许再次创建"<<endl;cout<<"如果想重新创建，先删除原先链表"<<endl;}}/*对应操作菜单--遍历链表的操作*/void Print( ){PrintList(head);}/*对应操作菜单--插⼊链表结点的操作*/void Insert( ){char IsGo; //是否继续操作标志IsGo='y';cout<<endl<<"开始进⾏结点插⼊操作"<<endl;node *stu;while(IsGo=='y'||IsGo=='Y'){ stu=new node; //创建要插⼊的新结点cout<<endl<<"输⼊要插⼊的新结点数据:";cin>>stu->data; //输⼊要插⼊的新结点数据head=InsertNode(head,stu); //调⽤插⼊函数，返回链表头指针cout<<"是否继续插⼊新结点? (继续插⼊请按y或Y,退出请按其它键)"; cin>>IsGo;}cout<<endl<<"结点插⼊操作结束"<<endl;}/*对应操作菜单--删除链表结点的操作*/void Delete( ){char IsGo; //是否继续操作标志int del_num; //要删除的结点的数据IsGo='y';cout<<endl<<"开始进⾏结点插⼊操作"<<endl;while(IsGo=='y'||IsGo=='Y'){cout<<endl<<"输⼊要删除的节点的数据:"; //输⼊要插⼊的结点cin>>del_num; //输⼊要删除的结点的数据head=DeleteNode(head,del_num); //删除后链表的头地址cout<<"是否继续删除结点? (继续插⼊请按y或Y,退出请按其它键)"; cin>>IsGo;}cout<<endl<<"结点删除操作结束"<<endl;}/*对应操作菜单--删除整个链表的操作*/void DeleteAll(){head=deleteList(head);}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
printf("%c ",p->ch);
p=p->next;
}
}
void delet(linklist head ,int i)
{
int j=0;
linklist r,p;
p=head->next;
while(p&&j<i-1)
{
p=p->next;
j++;
}
if(!p||j>i-1)
exit(1);
}
if(!p||j>i-1)
exit(1);
r=(linklist)malloc(sizeof(list));
r->ch=x;
r->next=p->next;
p->next=r;
}
void puter(linklist linker)
{
linklist p;
p=linker->next;
while(p!=NULL)
r=p;
ch=getchar();
}
r->next=NULL;
return (head);
}
void insert(linklist head,int i,char x)
{
int j=0;
linklist r,p;
p=head->next;
while(p&&j<i-1)
{
p=p->next;
j++;
r=p->next;
p->next=r->next;
free(r);
}
int main()
{
static int q,k;
char w;
printf("请输入字符穿，并以ENTER键结束\n");
linklist head,p,linker=creat();
puter(linker);
printf("请输入插入位置和插入字母\n");
scanf("%d %c",&q,&w);
insert(linker,q,w);
puter(linker);
printf("\n请输入删除位置的序号:\n");
scanf("%d",&k);
delet(linker,k);
puter(linker);
printf("\n");
return 0;
}
单链表的基本操作
#include <stdio.h>
#include <stdlib.h>
typedef char date;
typedef struct node
{
date ch;
struct node *next;
}list;
typedef list *linklist;
linklist creat()
{
date ch;
linklist head=(linklist)malloc(sizeof(list));
list *p,*r;
r=#39;\n')
{
p=(linklist)malloc(sizeof(list));
p->ch=ch;
r->next=p;