数据结构之单链表的操作

最新推荐文章于 2024-09-30 21:20:40 发布
最新推荐文章于 2024-09-30 21:20:40 发布
阅读量661 收藏 10
点赞数 10
文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Volimteczh/article/details/136197362
版权

main函数

 #include <stdio.h>                          
 #include "./03_linkList.h"                  
 int main(int argc, const char *argv[])      
 {                                           
     linkList* head = creatr_linkList();     
     insertHead_linkList(head,37);           
                                             
     insertHead_linkList(head,35);           
     insertHead_linkList(head,28);           
     insertHead_linkList(head,13);           
     show_linkList(head);                    
     insertSort_linkList(head,23);           
     show_linkList(head);                    
     selectByposition(head,3);               
         return 0;                           
 }

头文件：

 #ifndef __linkList_H__                                                                
 #define __linkList_H__                                                                
 typedef int datatype;                                                                 
 union msg{    //若数据的类型也为int，则不需要这个联合体                               
 datatype data;                                                                        
 int len;       //放头结点，记录链表长度                                               
 };                                                                                    
 typedef struct node{                                                                  
     union msg text;                                                                   
     struct node* next; //指针，由于指针指向这一整个节点，所以类型为struct node*       
 }linkList;                                                                            
                                                                                       
 linkList* creatr_linkList(void);                                                      
 void insertHead_linkList(linkList* head,datatype num);                                
 void show_linkList(linkList* head);                                                   
 void insertTail_linkList(linkList* head,datatype num);                                
 void deleteHead_linkList(linkList* head);                                             
 void deleteTail_linkList(linkList* head);                                             
 void insertByPositon_linkList(linkList* head,int pos,datatype num);                   
 void deleteByposition_linkList(linkList* head,int pos);                               
 void selectByposition(linkList* head,int pos);                                        
 void insertSort_linkList(linkList* head,datatype num);                                
 #endif

 函数部分：

 #include <stdio.h>                                                                                                                                                         
 #include <stdlib.h>                                                                                                                                                        
 #include "./03_linkList.h"                                                                                                                                                 
 //创建一个带有头指针的单向空链表                                                                                                                                           
 linkList* creatr_linkList()                                                                                                                                                
 {                                                                                                                                                                          
     linkList* head = (linkList*)malloc(sizeof(linkList));                                                                                                                  
     if(NULL == head)                                                                                                                                                       
     {                                                                                                                                                                      
         printf("头结点申请失败！\n");                                                                                                                                      
         return NULL;                                                                                                                                                       
     }                                                                                                                                                                      
     head->text.len = 0;//将链表长度初始化为0                                                                                                                               
     head->next = NULL;//第一个结点的指针指向空                                                                                                                             
     return head;                                                                                                                                                           
 }                                                                                                                                                                          
 //判断链表是否为空                                                                                                                                                         
 int isEmpty_linkList(linkList* head)                                                                                                                                       
 {                                                                                                                                                                          
     return head->next==NULL ? 1:0;                                                                                                                                         
 }                                                                                                                                                                          
 //插入数据                                                                                                                                                                 
 //头插法                                                                                                                                                                   
 void insertHead_linkList(linkList* head,datatype num)                                                                                                                      
 {                                                                                                                                                                          
     //创建一个新的结点                                                                                                                                                     
     linkList* temp =(linkList*)malloc(sizeof(linkList));                                                                                                                   
     if(NULL==temp)                                                                                                                                                         
     {                                                                                                                                                                      
         printf("结点申请失败！\n");                                                                                                                                        
         return;                                                                                                                                                            
     }                                                                                                                                                                      
     //定义该节点                                                                                                                                                           
     temp->text.data=num;//将需要插入的数据赋值给该结点                                                                                                                     
     temp->next=NULL;//先将插入的结点指向空                                                                                                                                 
     //先将temp指针指向头指针原先指向的那个元素，然后将头指针重新指向temp                                                                                                   
     temp->next=head->next;                                                                                                                                                 
     head->next=temp;                                                                                                                                                       
     //插入了新的元素，链表长度增加                                                                                                                                         
     head->text.len++;                                                                                                                                                      
     return;                                                                                                                                                                
 }                                                                                                                                                                          
 //尾插                                                                                                                                                                     
 void insertTail_linkList(linkList* head,datatype num)                                                                                                                      
 {                                                                                                                                                                          
     //创建一个新的结点                                                                                                                                                     
     linkList* temp =(linkList*)malloc(sizeof(linkList));                                                                                                                   
     if(NULL==temp)                                                                                                                                                         
     {                                                                                                                                                                      
         printf("结点申请失败！\n");                                                                                                                                        
         return;                                                                                                                                                            
     }                                                                                                                                                                      
     //定义该节点                                                                                                                                                           
     temp->text.data=num;//将需要插入的数据赋值给该结点                                                                                                                     
     temp->next=NULL;//先将插入的结点指向空                                                                                                                                 
     linkList* p=head;//定义一个p找到链表的尾部                                                                                                                             
     while(p->next!=NULL)                                                                                                                                                   
     {                                                                                                                                                                      
         p=p->next;                                                                                                                                                         
     }                                                                                                                                                                      
     //当p->next==NULL时退出循环，此时就是链表的尾部                                                                                                                        
         p->next=temp;//直接将尾部指向temp                                                                                                                                  
         temp->next=NULL;//然后将temp->next指向空                                                                                                                           
         head->text.len++;                                                                                                                                                  
     return;                                                                                                                                                                
 }                                                                                                                                                                          
 //头删                                                                                                                                                                     
 void deleteHead_linkList(linkList* head)                                                                                                                                   
 {                                                                                                                                                                          
     if(isEmpty_linkList(head))                                                                                                                                             
     {                                                                                                                                                                      
         printf("该链表为空，删除失败！\n");                                                                                                                                
         return;                                                                                                                                                            
     }                                                                                                                                                                      
     linkList* temp=head->next;                                                                                                                                             
     head->next=temp->next;                                                                                                                                                 
     free(temp);                                                                                                                                                            
     temp=NULL;                                                                                                                                                             
     head->text.len--;                                                                                                                                                      
     return;                                                                                                                                                                
 }                                                                                                                                                                          
 //尾删                                                                                                                                                                     
 void deleteTail_linkList(linkList* head)                                                                                                                                   
 {                                                                                                                                                                          
     if(isEmpty_linkList(head))                                                                                                                                             
     {                                                                                                                                                                      
         printf("该链表为空，删除失败！\n");                                                                                                                                
         return;                                                                                                                                                            
     }                                                                                                                                                                      
     linkList* temp=head;                                                                                                                                                   
     while(temp->next->next!=NULL)                                                                                                                                          
     {                                                                                                                                                                      
         temp=temp->next;                                                                                                                                                   
     }                                                                                                                                                                      
     free(temp->next);                                                                                                                                                      
     temp->next=NULL;                                                                                                                                                       
     head->text.len--;                                                                                                                                                      
     return;                                                                                                                                                                
 }                                                                                                                                                                          
 //按位置插入，位置编号从1开始编号                                                                                                                                          
 void insertByPositon_linkList(linkList* head,int pos,datatype num)                                                                                                         
 {                                                                                                                                                                          
     //判断插入的位置是否合法                                                                                                                                               
     if(pos < 1 || pos >head->text.len+1)                                                                                                                                   
     {                                                                                                                                                                      
         printf("插入的位置非法！\n");                                                                                                                                      
         return;                                                                                                                                                            
     }                                                                                                                                                                      
                                                                                                                                                                            
     linkList* p=head;                                                                                                                                                      
     int i=0;                                                                                                                                                               
     //利用for循环找到目标位置的前一个结点                                                                                                                                  
     for(i=0;i<pos-1;i++)                                                                                                                                                   
     {                                                                                                                                                                      
         p=p->next;                                                                                                                                                         
     }                                                                                                                                                                      
     linkList* temp=(linkList*)malloc(sizeof(linkList));                                                                                                                    
     if(NULL==temp)                                                                                                                                                         
     {                                                                                                                                                                      
         printf("结点申请失败！\n");                                                                                                                                        
         return;                                                                                                                                                            
     }                                                                                                                                                                      
     //定义该节点                                                                                                                                                           
     temp->text.data=num;//将需要插入的数据赋值给该结点                                                                                                                     
     temp->next=NULL;//先将插入的结点指向空                                                                                                                                 
     //插入操作                                                                                                                                                             
     temp->next=p->next;                                                                                                                                                    
     p->next=temp;                                                                                                                                                          
     head->text.len++;                                                                                                                                                      
     return;                                                                                                                                                                
 }                                                                                                                                                                          
                                                                                                                                                                            
 //按位置删除                                                                                                                                                               
 void deleteByposition_linkList(linkList* head,int pos)                                                                                                                     
 {                                                                                                                                                                          
     if(isEmpty_linkList(head))                                                                                                                                             
     {                                                                                                                                                                      
         printf("该链表为空，删除失败！\n");                                                                                                                                
         return;                                                                                                                                                            
     }
     if(pos < 1 || pos >head->text.len)                                                                                                                                     
     {                                                                                                                                                                      
         printf("删除的位置非法！\n");                                                                                                                                      
         return;                                                                                                                                                            
     }                                                                                                                                                                      
                                                                                                                                                                            
                                                                                                                                                                            
     linkList* p=head;                                                                                                                                                      
     int i;                                                                                                                                                                 
     for(i=0;i<pos-1;i++)//找到需要删除位置的前一个结点                                                                                                                     
     {                                                                                                                                                                      
         p=p->next;                                                                                                                                                         
     }                                                                                                                                                                      
     linkList* temp=p->next;                                                                                                                                                
     p->next=p->next->next;                                                                                                                                                 
     free(temp);                                                                                                                                                            
     temp=NULL;                                                                                                                                                             
     head->text.len--;                                                                                                                                                      
     return;                                                                                                                                                                
 }                                                                                                                                                                          
 //按位置查找数据,从11开始                                                                                                                                                  
 void selectByposition(linkList* head,int pos)                                                                                                                              
 {                                                                                                                                                                          
         if(isEmpty_linkList(head))                                                                                                                                         
     {                                                                                                                                                                      
         printf("该链表为空，查找失败！\n");                                                                                                                                
         return;                                                                                                                                                            
     }                                                                                                                                                                      
                                                                                                                                                                            
     if(pos < 1 || pos >head->text.len)                                                                                                                                     
     {                                                                                                                                                                      
         printf("查找的位置非法！\n");                                                                                                                                      
         return;                                                                                                                                                            
     }                                                                                                                                                                      
     int i;                                                                                                                                                                 
     linkList* p=head;                                                                                                                                                      
     for(i=0;i<pos;i++)//找到需要查找的结点的位置                                                                                                                           
     {                                                                                                                                                                      
         p=p->next;                                                                                                                                                         
     }                                                                                                                                                                      
     printf("%d位置的数据是%d\n",pos,p->text.data);                                                                                                                         
     return;                                                                                                                                                                
 }                                                                                                                                                                          
 //直接插入排序                                                                                                                                                             
 void insertSort_linkList(linkList* head,datatype num)                                                                                                                      
 {                                                                                                                                                                          
                                                                                                                                                                            
     linkList* p = head;//用于找到比temp大的前一个数的结点                                                                                                                  
     linkList* temp=(linkList*)malloc(sizeof(linkList));                                                                                                                    
     if(NULL==temp)                                                                                                                                                         
     {                                                                                                                                                                      
         printf("结点申请失败！\n");                                                                                                                                        
         return;                                                                                                                                                            
     }                                                                                                                                                                      
     //定义该节点                                                                                                                                                           
     temp->text.data=num;//将需要插入的数据赋值给该结点                                                                                                                     
     temp->next=NULL;//先将插入的结点指向空                                                                                                                                 
     //当p->next为空时，即在尾部插入，此时p不需要再偏移了，                                                                                                                 
     //如果temp插入位置                                                                                                                                                     
     while(p->next!=NULL && p->next->text.data < temp->text.data)                                                                                                           
     {                                                                                                                                                                      
         p=p->next;                                                                                                                                                         
     }                                                                                                                                                                      
     temp->next=p->next;                                                                                                                                                    
     p->next=temp;                                                                                                                                                          
     head->text.len++;                                                                                                                                                      
     return;                                                                                                                                                                
 }                                                                                                                                                                          
 //遍历该链表                                                                                                                                                               
 void show_linkList(linkList* head)                                                                                                                                         
 {                                                                                                                                                                          
     //定义一个指针指向该链表的头结点，然后将p后移访问该链表中的数据                                                                                                        
     linkList* p=head;                                                                                                                                                      
     while(p->next!=NULL)                                                                                                                                                   
     {                                                                                                                                                                      
         p=p->next;//将p后移，由于p刚开始指向的是head,不是有效数据，所以先后移再访问数据                                                                                    
         printf("%d ",p->text.data);//打印p所指向的数据                                                                                                                     
     }                                                                                                                                                                      
     printf("\n");                                                                                                                                                          
 }

 Makefile:

 -include ./makefile.cfg     
 $(Target):$(Obj)
     $(CC) $^ -o $@
 
 %.o:%.c
     $(CC) $< $(CAN) $@
 .PHONY: clean
 clean:
     rm $(Obj)

makefile.cfg

Target:=a.out
Obj:=01_main.o 02_linkList.o
CAN:= -c -o
CC:=gcc

Volimtey
关注
数据结构之单链表实验
// 在校菜鸟大学生的日常学习博客
09-01 5959
单链表实验实验目的实验环境实验要求实验内容源代码运行结果 实验目的 掌握线性表的定义、特点、逻辑结构，理解线性表的抽象数据类型。 熟练掌握线性表的两种存储结构的结构类型定义、特点和基本操作的实现。 通过本次实验帮助学生加深对线性表的理解，并加以应用； 实验环境 CodeBlocks 实验要求 1.熟悉c语言的语法知识； 2.了解线性表的逻辑结构特性； 3.掌握线性表的链式存储结构—单链表的定义、创建、插入、删除、取值等基本操作； 实验内容 完成单链表的基本操作（定义、初始化、插入、删除、定位等）的汇总，
数据结构：单链表的基本操作
weixin_45213079的博客
08-17 1208
数据结构：单链表的基本操作
C语言数据结构之单链表操作
Lei_baobao的博客
05-22 441
目录单链表操作一、定义单链表存储结构二、创建单链表1、头插法2、尾插法三、单链表的读取四、单链表的遍历五、单链表的插入六、单链表的删除七、单链表的整表删除 单链表操作 一、定义单链表存储结构 // 定义单链表存储结构 typedef struct Node { ElemyType data; struct Node *next; }Node,*Linklist; 二、创建单链表 1、头插法 // 头插法——创建单链表 void CreatListHead(Linklist *L,int n
数据结构之单链表操作
LY_624的专栏
03-21 860
/* 编写一个程序，实现单链表的各种基本运算（假设单链表的元素类型为Char）。 （1）初始化单链表h; （2）采用尾插法依次插入元素a,b,c,d,e; （3）输出单链表h; （4）输出单链表h长度； （5）判断单链表h是否为空； （6）输出单链表h的第3个元素； （7）输出元素a的位置； （8）在第4个元素位置上插入元素f; （9）输出单链表h; （10）删除h的第3个元素； （11）输出单链
数据结构之单链表
chuxinchangcun的博客
08-15 1736
前言： 之前的文章，我们了解了顺序表，包括静态顺序表和动态顺序表。具体可以看我的上两篇文章 1.静态顺序表知识及代码实现：静态顺序表 2.动态顺序表知识及代码实现：动态顺序表 既然顺序表已经能存储数据，那么我们什么又要引入链表呢？ 首先，我们要知道顺序表的优缺点： 优点：空间连续，支持随机访问 缺点： 1.中间或前面部分的插入删除的时间复杂度为O(N) 2.增容的代价比较大 为了解决上述问题，我们引入了链表的概念。 目录 一:什么是链表 二:链表的种类 三:...
【数据结构】单链表的操作
qq_45972928的博客
04-21 6187
内容： 1）实现单链表的以下基本操作：建立单链表，查找单链表，插入单链表，删除单链表。 2）采用单链表结构编程实现：两个有序单链表的归并运算。 实现思路： ① 定义数据域类型； ② 定义单链表，分为数据域和指针域； ③ 分别编写实现前插法创建单链表、后插法创建单链表、初始化单链表、单链表的查找、向单链表插入元素、删除单链表中某元素、遍历单链表并显示、求单链表最大节点、判断单链表是否为空、求单链表长度、逆转单链表、两个有序单链表的归并等函数功能； ④ 在主函数中定义单链表； ⑤ 使用while实现循环操.
C++数据结构之单链表
suren_jun的博客
09-14 1812
这里详细讲解了C++数据结构中的单链表的实现，采用了头节点存储数据和不存储数据两种方式对单链表的各种操作做了实现。
数据结构-单链表操作
有朋自远方来，不亦乐乎。
07-27 1312
注意步骤（2）（3）的顺序不能颠倒，否则会导致插入位置后的部分链表丢失。（2）将新结点的next指针指向插入位置后的结点。（3）将插入位置前的节点指针next指向新的结点。（2）手动释放掉结点，回收被结点占用的存储空间。插入位置一共分三种，分别是头部插入、中间插入和尾部插入。先找到目标位置再更改结点的数据域。（1）创建一个新的要插入的结点。（1）将结点从链表中摘下。...
数据结构之单链表的插入删除
2301_76969701的博客
04-25 811
这里还是使用“偷天换日”大法(这名字真的好羞耻呀)，将p复制为后继结点q，然后删除q，这样就等价于p被删除了。思路：找到第i-1个结点，将其指针指向第i+1个结点，并释放第i个结点。小tips：如果p是最后一个结点，就只能从表头开始依次寻找p的前驱了。空表判断：L->next==NULL(带头结点)分为带头节点和不带头节点两种方法。此时的时间复杂度为O(1)
《数据结构》单链表操作实验报告
yageqin的博客
02-24 4947
用于复习链表，自己写的有关链表的一些操作，包括后插前插创建链表，删除，插入，有序合并，查找，遍历，反转，查中间节点，删倒数节点，检测环结构的功能。可以用做C语言实训参考。 下面展示一些 内联代码片。 #include<iostream> #include<stdio.h> using namespace std; //定义结构体 typedef struct LNode{ int data; struct LNode *next; }LNode,*LinkList;
数据结构之单链表操作合集.zip
06-16
这个“数据结构之单链表操作合集.zip”文件显然是针对大学生学习数据结构而准备的资源，包含了丰富的学习材料。下面将详细讨论单链表的相关知识点。 单链表是一种线性数据结构，由一系列节点（也称为元素或记录）...
基于JAVA的数据结构之单链表操作合
03-25
单链表是一种基础且重要的数据结构，它在计算机科学中被广泛使用，特别是在编程语言如Java中。单链表由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的引用。这种数据结构允许动态地添加、删除和...
数据结构之单链表操作合集_LinkedList_learning.zip
09-16
数据结构之单链表操作合集_LinkedList_learning
C语言 数据结构之单链表基本操作
10-05
单链表操作介绍 1. 创建头节点 2. 创建有数据节点 3. 判断链表是否为空 4. 遍历链表(有头节点链表) 5. 遍历链表(无头节点链表) 6. 头插、头删、尾插、尾删 7. 按照顺序插入(自带排序) 8. 按照位置插入数据 9. 按照...
SwipeRefreshLayout和ViewPager滑动冲突的原因和正确的解决方式
杰森丶郭达斯坦森的博客
09-30 125
重写SwipeRefreshLayout的onIntercept方法就可以很简单的解决了。以下就是重写后的SwipeRefreshLayout，直接复制到项目就可以使用了。
每日学习一个数据结构-链表
wendao76的专栏
09-30 680
链表（Linked List）是一种常见的数据结构，由一系列节点（Node）组成，每个节点包含两个部分：一部分用于存储数据（称为数据域），另一部分用于存储指向下一个节点的指针（或链接、引用）。链表是线性数据结构的一种，但与数组不同的是，链表中的元素在内存中的存储位置不必连续。单向链表（Singly Linked List）每个节点包含一个数据域和一个指向下一个节点的指针。最后一个节点的指针为null或None，表示链表的结束。双向链表（Doubly Linked List）
[数据结构] 二叉树题目(一)
nmbg11的博客
09-27 418
leetcode有关二叉树的相关题目. 翻转二叉树. 相同的树. 对称二叉树.
【笔记】选择题笔记+数据结构笔记
最新发布
m0_52024881的博客
09-30 310
连通分量是极大连通子图一个连通图的生成树是一个极小连通子图。
数据结构——栈的基本操作
2301_80492355的博客
09-30 385
define MAXSIZE 100 //顺序表的存储范围#define STACK_INCREMENT 2 //存储空间分配增量//这里假定SElemType是int类型//栈底指针//栈顶指针//栈可用的最大容量}SqStack;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值