C语言实现链表初始化增，删，改，查和链表排序

已于 2022-09-28 21:31:55 修改
阅读量673 收藏 7
点赞数 4
文章标签： 链表 c语言 数据结构
于 2022-09-21 13:19:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/narogre/article/details/126970571
版权

刚学完链表老师就安排了作业

链表是一种物理 存储单元 上非连续、非顺序的 存储结构 ， 数据元素 的逻辑顺序是通过链表中的 指针 链接次序实现的。 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。易于插入和删除，查找效率较低.

首先定义一个结构体，包括数据和结构体指针

typedef struct Link {
    int  elem;
    struct Link *next;
}link;

然后使用头插法连接链表，

link * initLink() 
{
	//int n;
    link * p = (link*)malloc(sizeof(link));//创建一个头结点
    link * temp = p;//声明一个指针指向头结点，用于遍历链表
    //生成链表
    temp->next = NULL;
    for (int i = 1; i <= n; i++) 
    {
        link *a = (link*)malloc(sizeof(link));
        a->elem = i;
        a->next = temp->next;
        temp->next = a;
    }
    return p;
}

插入节点的操作

link * insertElem(link * p, int elem, int add) 
{
    link * temp = p;//创建临时结点temp
    //首先找到要插入位置的上一个结点
    for (int i = 1; i < add; i++) 
    {
        temp = temp->next;
        if (temp == NULL) 
        {
            printf("插入位置无效\n");
            return p;
        }
    }
    //创建插入结点c
    link * c = (link*)malloc(sizeof(link));
    c->elem = elem;
    //向链表中插入结点
    c->next = temp->next;
    temp->next = c;
    return  p;
}

接下来是删除节点的操作

link * delElem(link * p, int add) 
{
    link * temp = p;
    //遍历到被删除结点的上一个结点
    for (int i = 1; i < add; i++) 
    {
        temp = temp->next;
        if (temp->next == NULL) 
        {
            printf("没有该结点\n");
            return p;
        }
    }
    link * del = temp->next;//单独设置一个指针指向被删除结点，以防丢失
    temp->next = temp->next->next;//删除某个结点的方法就是更改前一个结点的指针域
    free(del);//手动释放该结点，防止内存泄漏
    return p;
}

然后是查找结点的操作，从头比较所查数据

int selectElem(link * p, int elem) {
    link * t = p;
    int i = 1;
    while (t->next) {
        t = t->next;
        if (t->elem == elem) {
            return i;
        }
        i++;
    }
    return -1;
}

修改链表数据的函数

link *amendElem(link * p, int add, int newElem) 
{
    link * temp = p;
    temp = temp->next;//tamp指向首元结点
    //temp指向被删除结点
    for (int i = 1; i < add; i++) 
    {
        temp = temp->next;
    }
    temp->elem = newElem;
    return p;
}

链表冒泡排序的函数,在两层循环中减少无效的比较，可以极大提高运行效率，外层循环只需比较n-1次，内层循环每个数只需要n-i-1次，这属于冒泡排序的优化

link * sortLink(struct Link * head)
{
	link *L=head;//定义一个头指针
	link *p1;//用来存储用来比较的两个结点中的靠前的节点
	link *p2;//用来存储用来比较的两个结点中的靠后的节点
	int T=0;//交换的中间变量
	for(int i=1;i<=n-1;i++){
		L=head->next;
		for(int j=1;j<=n-i;j++){
			p1=L;
			p2=L->next;
			if(p1->elem>p2->elem){
				T=p1->elem;
				p1->elem=p2->elem;
				p2->elem=T;
			} 
			L=L->next; 
		} 
	}
	return head;
}

输出链表的函数

void display(link *p) 
{
    link* temp = p;//将temp指针重新指向头结点
    //只要temp指针指向的结点的next不是Null，就执行输出语句。
    while (temp->next) 
    {
        temp = temp->next;
        printf("%d ", temp->elem);
    }
    printf("\n");
}

建立一个循环，输入不同的数对链表操作，输入1插入数据，输入2删除数据，输入3查找数据，输入4更改数据，输入5排序，输入0退出循环结束运行

所有的代码如下，定义的函数都在main函数之后，因此都需要先声明，再使用

#include <stdio.h>　　　　//增+删+改+查+初始化+输出
#include <stdlib.h>
int n;//自定义链表长度
int m;//输入1，2，3，4对链表操作 
typedef struct Link //定义结构体
{
    int  elem;//数据
    struct Link *next;//用来指向下一个结点的指针
}link;
link * initLink();
//链表插入的函数，p是链表，elem是插入的结点的数据域，add是插入的位置
link * insertElem(link * p, int elem, int add);
//删除结点的函数，p代表操作链表，add代表删除节点的位置
link * delElem(link * p, int add);
//查找结点的函数，elem为目标结点的数据域的值
int selectElem(link * p, int elem);
//更新结点的函数，newElem为新的数据域的值
link *amendElem(link * p, int add, int newElem);
void display(link *p);
void sortLink(link* & head);
int main() {//第一个输入为链表长度，接下来的五个输入可以控制对链表增删改查
    int x,y;
    printf("请输入链表长度\n");
	scanf("%d",&n);//输入链表长度 
    //初始化链表（1，2，3，4）
    void sortLink(link * head);
    printf("初始化链表为：\n");
    link *p = initLink();
    display(p);
    printf("输入1插入数据，输入2删除数据，输入3查找数据，输入4更改数据，输入5排序，输入0退出\n");
    for(int i=0;;i++) 
	{  
        scanf("%d",&m);
        if(m==0) return 0;
        else if(m==1){//插入数据
        printf("请输入需要插的位置和插入的数\n");
        scanf("%d%d",&x,&y);
        printf("在第%d的位置插入元素%d：\n",y,x);
        n++;//链表长度加1 
        p = insertElem(p, x, y);
        display(p);
	}
        else if(m==2){//删除数据
        printf("请输入要删除第几个位置的元素\n");
	    scanf("%d",&y);
        printf("删除第%d个位置的元素:\n",y);
        n--;
        p = delElem(p, y);
        display(p);
	}
    else if(m==3)//查找数据
	{
	    printf("请输入要查找的元素的位置");
	    scanf("%d",&y);
        printf("查找元素%d的位置：\n",y);
        int address = selectElem(p, y);
        if (address == -1) {
        printf("没有该元素");
    }
    else {
        printf("%d\n", address);
    }
}
    else if(m==4){//更改数据
    printf("请输入需要更改的位置和需要改成什么\n");
	scanf("%d%d",x,y);
    printf("更改第3的位置上的数据为7:\n");
    p = amendElem(p, x, y);
    display(p);
	}
    else if(m==5) 
	{
    sortLink(p);
    printf("排序后输出\n"); 
    display(p);
    }
}
    return 0;
}
link * sortLink(struct Link * head)//链表的冒泡排序
{
	link *L=head;
	link *p1;
	link *p2;
	int T=0;
	for(int i=1;i<=n-1;i++){
		L=head->next;
		for(int j=1;j<=n-i;j++){
			p1=L;
			p2=L->next;
			if(p1->elem>p2->elem){
				T=p1->elem;
				p1->elem=p2->elem;
				p2->elem=T;
			} 
			L=L->next; 
		} 
	}
	return head;
}
link * initLink() 
{
	//int n;
    link * p = (link*)malloc(sizeof(link));//创建一个头结点
    link * temp = p;//声明一个指针指向头结点，用于遍历链表
    //生成链表
    temp->next = NULL;
    for (int i = 1; i <= n; i++) {
        link *a = (link*)malloc(sizeof(link));
        a->elem = i;
        a->next = temp->next;
        temp->next = a;
    }
    return p;
}
link * insertElem(link * p, int elem, int add) 
{
    link * temp = p;//创建临时结点temp
    //首先找到要插入位置的上一个结点
    for (int i = 1; i < add; i++) {
        temp = temp->next;
        if (temp == NULL) {
            printf("插入位置无效\n");
            return p;
        }
    }
    //创建插入结点c
    link * c = (link*)malloc(sizeof(link));
    c->elem = elem;
    //向链表中插入结点
    c->next = temp->next;
    temp->next = c;
    return  p;
}
link * delElem(link * p, int add) 
{
    link * temp = p;
    //遍历到被删除结点的上一个结点
    for (int i = 1; i < add; i++) 
    {
        temp = temp->next;
        if (temp->next == NULL) 
        {
            printf("没有该结点\n");
            return p;
        }
    }
    link * del = temp->next;//单独设置一个指针指向被删除结点，以防丢失
    temp->next = temp->next->next;//删除某个结点的方法就是更改前一个结点的指针域
    free(del);//手动释放该结点，防止内存泄漏
    return p;
}
int selectElem(link * p, int elem) 
{
    link * t = p;
    int i = 1;
    while (t->next) {
        t = t->next;
        if (t->elem == elem) 
        {
            return i;
        }
        i++;
    }
    return -1;
}
link *amendElem(link * p, int add, int newElem) 
{
    link * temp = p;
    temp = temp->next;//tamp指向首元结点
    //temp指向被删除结点
    for (int i = 1; i < add; i++) 
    {
        temp = temp->next;
    }
    temp->elem = newElem;
    return p;
}
void display(link *p) 
{
    link* temp = p;//将temp指针重新指向头结点
    //只要temp指针指向的结点的next不是Null，就执行输出语句。
    while (temp->next) 
    {
        temp = temp->next;
        printf("%d ", temp->elem);
    }
    printf("\n");
}

运行结果如下：

Narogre
关注
  • 4
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C语言如何建立链表并实现增删查改详解
01-01
以下是本人完成的一个C语言建立链表并进行增删查改操作的程序，为方便学习，本人将整个程序分为头文件和主函数两部分： 1.头文件(函数部分) (1)初始化函数 #include #include typedef struct { int *head; int...
单链表的创建、插入、删除、查找、遍历等功能（C语言实现）
weixin_46626833的博客
05-25 4614
下面展示一些 内联代码片。 //用到的头文件、结构体 #include <stdio.h> #include <stdlib.h> typedef int elemtype; typedef struct node { elemtype data; struct node *next; }LinkList; int i;//记录链表节点的个数(除头结点) //头插法创建链表 LinkList *creat_LinkListF() { i = 0;
C语言实现单链表的初始化及增删改查
m0_51060495的博客
09-23 1128
C语言实现链表的初始化及增删改查 文件组织 main.c main.c //注意：linkList为头节点，头节点只是为了后面操作方便。其数据域无意义，但是头节点数据域通常保存链表长度，头指针指向第一个节点。 #include "test.h" //初始化链表 void InitLinkList(LinkList * linkList,ElementType * dataArray,int length); //插入节点 void InsertLinkList(LinkList * linkList
学习记录：第二章 线性表的链式存储_单链表_插入删除查找三种基本操作以及求表长（代码、图示、C++）
weixin_45790081的博客
05-09 1329
本文给出了单链表的插入和删除两种基本操作的代码及相应图示助于理解，代码实现使用的是C语言在线工具。无概念解释，初学者建议配合书本食用。
单链表——基本操作（求表长、查找、插入、删除）(java)
IFollowRivers
04-13 2540
public class LinkedList { public Node first;//定义头结点 public LinkedList(){ this.first=null; } //定义节点类 public class Node{ int data; Node next=null; public Node(int data){ this.data=
数据结构：（c实现）单向链表，单链表的头增，尾增，头删，尾删，任意位置的删除与插入。
qq_51004011的博客
05-13 1181
一：什么是单链表 （1）单链表节点数据结构 （2）单链表结构物理图解 二：单链表的几种接口函数的实现 （1）单链表的尾插函数（顺序插入） (2)单链 链表一般分成两块：一部分存储数据，另一部分存储下一个节点的指针。 链表与顺序表不同，链表的存储形式不是一块物理地址连续的空间。而是在内存中随机存储。需要存入一个新的数据时，就malloc开辟一个新的节点。并将新开辟的空间的地址放置到上一个节点的指针中。 再将该节点的指针赋NULL。 ...
C语言版数据结构中单链表的插入，查找，删除，排序与逆置
qq_55921267的博客
10-03 1469
感言 其实吧，这是我第一次在csdn里上传我写的代码，其实我写这个的初衷是为了和大家分享自己的一些思路，听取他人的意见，弥补自己不足（本人刚开始接触数据结构，是个在校大学生）。初来咋到，不足处还望各位海涵，如果代码中有什么不好，或者不对的用法，欢迎在评论区留言，一起讨论，一起进步。 单链表 单链表~~删除线格式~~ ...
c语言单链表的实现，包括链表的创建、插入、查询、删除、打印、长度计算
weixin_44818115的博客
11-25 607
#include <stdio.h> #include <stdlib.h> typedef struct node{ char data; struct node *next; }LINKLIST; // 链表初始化操作,返回一个空链表 LINKLIST *INITLIST() { LINKLIST *head; head = (LINKLIST*)malloc(sizeof(LINKLIST)); head->next = NULL; return h
使用C语言写带头结点的链表，含有创建、输出、查找、删除、插入、合并
hua_you_qiang的博客
03-15 4570
用C语言写出带头结点的链表那些带头结点的链表的题目必要代码定义一个结构体创建一个带头结点的单链表 今天有一位学弟在网上向我吐血求助，让我帮他写c语言带头结点的链表题目。 我想了想，c语言我有一年半载没有接触了。正好温习温习一下，就写下此博客，来回顾一下我学习c语言的汗(Lei)水(Shui)与快(Tong)乐(Ku)。尽管我没有老师写的那么详尽，也没有教科书式的讲的那么专业。但我是站在学生的角度去...
c语言链表的基本操作实现
03-28
C语言链表的基本操作主要包括**初始化、创建节点、插入节点、删除节点和查找节点**。具体如下： 1. **初始化**：创建一个空的链表，通常指创建一个头指针，该指针指向NULL，表示链表的开始。 2. **创建节点**：在...
c语言实现循环链表的源代码
03-24
关于循环链表的简单操作。包括：循环链表的定义，初始化；对链表结点的插入删除和查找；判空以及遍历。
C语言实现静态链表
12-17
4、初始化链表时，链表只有最后一个空间的cur是0, 意味是头指针，并没有任何分配的空间。备用链表的头指针是空间的第一个位置，最后一个指针的cur也是0。 0 在静态链表中也意味着NULL； 5、使用
c语言通用链表库
02-02
本代码提供采用c语言编写链表的使用源码，有创建、初始化、删除、插入、查找等等功能
C语言【链表】排序
maybeornot的博客
12-23 1578
对于输入的 n 个数据 num 进行排序，要求将输入的数据按 num 升序建立带有表头结点的链表，且链表中不能有重复的数据。 　　现在已经给出结点定义和程序框架，包括 main 函数和链表输出函数 outlist，请编写函数 sortlist 完成链表排序功能。 函数原型 sortlist( PNODE h, int num ) 的参数含义如下： h ：单链表的头指针 num ：新输入的需要插入链表中的数据
C语言 单链表 插入/删除/查找/遍历/递归/合并/排序
HardessGod的博客
12-12 3207
       单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 1 链表结构      2 链表操作     链表操作难度不大，只要我们熟悉其数据结构，说白了就是操作指针。下面附上我对单链表的相关...
【C语言对链表的操作（链表的初始化，建立，求长，增加，删除，以及输出）】
m0_49586319的博客
07-22 2456
C语言对链表的操作（链表的初始化，建立，求长，增加，删除，以及输出）
[数据结构（C语言）]单链表的定义，实现初始化、创建、插入、增、删、改、查等基本操作
DuFengYa的博客
06-06 3824
首先，让我们回顾一下顺序表的优缺点： 采用链式存储结构的线性表称为链表。 链表有单链表、循环链表和双向链表等多种类型。链表中，不仅需要存储每个数据元素，还需存储其直接后继的存储地址，这两部分数据信息组 合起来称为结点。 每个结点只包含一个指针域的链表，称为单链表。 最后一个结点的指针域为NULL，在图中记为^。first是头指针，指向链表中的第一个结点，链表中的第一个结点称为头结点 目录头文件及函数声明等：菜单函数：初始化链表：显示元素：添加元素：​编辑插入元素：​编辑删除元素：​编辑 查找元素：修改元素：
C语言数据结构创建单链表，插入操作，删除操作，存取操作，查找操作的代码实现
LLF_ABC的博客
12-10 1985
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。一个单链表结点由以下两个域构成。数据域指针域datanext其中数据域data存放该结点的数据域的值，指针域存放该结点的后继结点的地址信息。关于单链表的主要操作有插入操作，删除操作，存取操作，查找操作等。如果想要去跑下面代码的实现，请先加上头文件和结构体声明以及全局变量，这里也附带了一个测试用的主函数。
C语言——模拟实现库函数atoi
最新发布
2302_80250536的博客
05-13 441
INT_MAX 和 INT_MIN 是 C语言 的两个预定义宏，代表了整型变量能够存储的最大正整数21474836472^31 − 1）和最小负整数-2^31这个值是相对于二进制补码表示的，也就是说，负数的范围比正数大 1,这两个宏在头文件中定义。
c语言输出一个包括增删改查的链表
03-31
很抱歉，我不是一个能够编写代码的AI语言模型，但是我可以提供你链表的基本结构和一些基本的增删改查操作的思路。 链表基本结构： ```c struct ListNode { int data; // 节点的数据 struct ListNode* next; // 指向下一个节点的指针 }; ``` 链表的初始化： ```c struct ListNode* initList() { struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode)); head->next = NULL; return head; } ``` 链表的插入操作： ```c void insertNode(struct ListNode* head, int data) { struct ListNode* newNode = (struct ListNode*)malloc(sizeof(struct ListNode)); newNode->data = data; newNode->next = head->next; head->next = newNode; } ``` 链表的删除操作： ```c void deleteNode(struct ListNode* head, int data) { struct ListNode* p = head->next; struct ListNode* q = head; while(p != NULL && p->data != data) { q = p; p = p->next; } if(p != NULL) { q->next = p->next; free(p); } } ``` 链表的修改操作： ```c void modifyNode(struct ListNode* head, int oldData, int newData) { struct ListNode* p = head->next; while(p != NULL && p->data != oldData) { p = p->next; } if(p != NULL) { p->data = newData; } } ``` 链表的查找操作： ```c struct ListNode* searchNode(struct ListNode* head, int data) { struct ListNode* p = head->next; while(p != NULL && p->data != data) { p = p->next; } return p; } ``` 以上是链表的基本结构和增删改查操作的思路，你可以根据需要进行修改和完善。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值