单链表的建立及插入删除操作-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 链表的尾部。
- 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;