数据结构之链表(c语言版)

最新推荐文章于 2022-12-22 18:05:46 发布
最新推荐文章于 2022-12-22 18:05:46 发布
阅读量392 收藏 6
点赞数 1
分类专栏： 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43688691/article/details/102458686
版权

数据结构之链表(c语言版)

链表是线性表，链表的特点就是可以动态增减元素。种类有单向链表、双向链表，循环链表。

一、单链表

单链表的储存思想使用指针表示节点之间的逻辑关系，它的储存单元可以连续也可以不连续，每个储存单元需要储存信息和储存与后继节点的地址信息，储存单元又称之为节点。单链表由头指针唯一确定，整个单链表的操作必须由头指针开始。

链表的单位是一个一个节点，每个节点分为数据域和指针域，数据域存放数据，指针域存放指向下一个节点的指针（没有指针的语言存放的是对下一个节点的引用）。

头节点通常不放数据（也可以存放数据），尾节点指针域为空（循环链表不为空）。

单链表示意图：

在这里插入图片描述

c语言实现单链表1.0

还是1.0版本和2.0版本哈，2.0是后来增加的，更加健壮！

#include<stdio.h>
#include<stdlib.h>

//定义节点
typedef struct list
{   int data;
    struct list *next;
    /* data */
}Node;


//节点初始化
Node *create_node(){
    Node *p=(Node *)malloc(sizeof(Node));
    //节点
    p->next=NULL;
    return p;
}

//建立链表,尾部增加
Node *link_list(int d[],int size){
    Node *head=create_node();
    Node *tail=head;        //尾节点，此时尾节点就是头节点
    for(int i=0;i<size;i++){
        Node *p=(Node *)malloc(sizeof(Node));
        p->data=d[i];
        p->next=NULL;
        tail->next=p;
        tail=p;//p变为尾节点
    }

    return head;
}

//追加
int append(Node *head,int e){
    Node *p=create_node();
    p->data=e;
    Node *s=head;
    while(s->next!=NULL){
        s=s->next;
    }
    s->next=p;
    return 1;
}

//长度
int Len(Node *head){
    Node *p=head;
    int count=0;
    for(;p!=NULL;count++){
        p=p->next;
    }
    return count;
    
}

//插入
int Insert(Node *head,int i,int e){

    if(i<1){
        printf("插入错误，程序终止");
        exit(0);
    }
    if(i>=Len(head)+1){
        //此时为追加
        append(head,e);
        return 1;
    }
    
    
    int n=1;
    Node *p=head;
    
    for(;n<i;n++){
        p=p->next;
    }
    Node *s=create_node();
    s->data=e;
    s->next=p->next;
    p->next=s;
    return 1;

}

//删除
int Delete(Node *head ,int i){

    if(i<1||i>Len(head)){
        printf("删除非法，程序终止");
        exit(0);
    }


    Node *f=head;//前指针
    Node *b;//后指针


    for(int n=1;n<i;n++){
        f=f->next;
        b=(f->next)->next;
    }

    Node *s=f->next;//此为被销毁的节点

    f->next=b;

    free(s);//释放内存

    return 1;
}

//查找
int Query(Node *head ,int i){

    if(i<1||i>Len(head)){
        printf("查找非法，程序终止");
        exit(0);
    }

    Node *p=head;//工作指针


    for(int n=1;n<i;n++){
        p=p->next;
    }

    int e=p->data;//查询的元素

    return e;
}
//修改
int Update(Node *head ,int i,int e){

    if(i<1||i>Len(head)){
        printf("修改非法，程序终止");
        exit(0);
    }


    Node *p=head;//工作指针


    for(int n=1;n<i;n++){
       p=p->next;
    }

    p->data=e;

    return 1;
}

//判空
int is_Empty(Node *head){
    if(head->next==NULL){
        return 1;
    }
    return 0;
}

//遍历链表
void display(Node *head){


    Node *p=head->next;//头节点没有数据

    printf("此时有%d个节点\n",Len(head));

    for(;p!=NULL;p=p->next){
        printf("The data is %d\n",p->data);
    }
}

//销毁链表
void Destory(Node *head){

    for(Node *p=head;head!=NULL;){
        head=head->next;
        free(p);
        p=head;
    }
    printf("链表已经销毁\n");
    exit(0);

}

这里把大部分功能都用函数表达了，有些功能用属性似乎更加简便，不过无伤大雅。

在主函数中测试一下功能：

int main(){
    int a[5]={2,1,5,11,6};
    int size=sizeof(a)/sizeof(int);
    printf("创建链表\n ");
   
    Node *p=link_list(a,size);
    
    display(p);

    append(p,18);
    display(p);

    Insert(p,2,37);
    Insert(p,4,23);
    Insert(p,14,37);
    display(p);

    Delete(p,2);
    display(p);

    int i=9;
    int e=Query(p,i);
    printf("查询的是第%d个元素，值为%d\n",i,e);

    Update(p,i,10);
    printf("修改了%d号元素,现在值为%d\n",i,Query(p,i));

    Destory(p);
}

测试结果：

创建链表
 此时有6个节点
The data is 2
The data is 1
The data is 5
The data is 11
The data is 6
此时有7个节点
The data is 2
The data is 1
The data is 5
The data is 11
The data is 6
The data is 18
此时有10个节点
The data is 2
The data is 37
The data is 1
The data is 23
The data is 5
The data is 11
The data is 6
The data is 18
The data is 37
此时有9个节点
The data is 2
The data is 1
The data is 23
The data is 5
The data is 11
The data is 6
The data is 18
The data is 37
查询的是第9个元素，值为37
修改了9号元素,现在值为10
链表已经销毁
c语言实现单链表2.0

从全局静态变量来表示头节点和节点数量，此时代码逻辑简单多了。

增删改查功能都没有实现，可以自行摸索。

#include<stdio.h>
#include<stdlib.h>

//定义节点
typedef struct list
{   int data;
    struct list *next;
    /* data */
}Node;

static int count=0;//节点数量，代替了Len函数中的逻辑
static Node *head=NULL;//头节点


//节点初始化
Node *create_node(){
    Node *p=(Node *)malloc(sizeof(Node));
    //节点
    p->next=NULL;
    return p;
}

//建立链表,尾部增加
Node *link_list(int d[],int size){
    head=create_node();
    Node *tail=head;        //尾节点，此时尾节点就是头节点
    for(int i=0;i<size;i++){
        Node *p=create_node();
        p->data=d[i];
        p->next=NULL;
        tail->next=p;
        tail=p;//p变为尾节点
        printf("链表增加元素%d\n",d[i]);
    }

    count=size+1;//头节点也算
    printf("链表创建成功\n");
    return head;
}



//长度
int Len(){
    //原先的代码去掉，直接由count代替
    return count;
}



//判空
int is_Empty(){
    if(count==0){
        return 1;
    }
    return 0;
}

//遍历链表
void display(){


    printf("此时有%d个节点\n",count);
    Node *p=head->next;

    // for(;p!=NULL;p=p->next){
    //     printf("The data is %d\n",p->data);
    // }

    for(int i=1;i<count;i++){
        printf("The data is %d\n",p->data);
        p=p->next;
    }
}

int main(){
    int a[5]={2,1,5,11,6};
    int size=sizeof(a)/sizeof(int);
    printf("创建链表\n ");
   
    Node *p=link_list(a,size);
    display();
    
}

二、单向循环链表

循环链表有单向的也有双向的，其实就是尾节点的指针域指向了头节点，成为循环结构。这样从任意位置都可以遍历所有。

在这里插入图片描述

在单链表1.0的基础上稍作修改，一个单向循环链表就完成了。在指针的指向方面稍作修改就可以完成，部分方法就没有提供了，可以自行摸索。

单循环链表1.0
#include<stdio.h>
#include<stdlib.h>

//定义节点
typedef struct list
{   int data;
    struct list *next;
    /* data */
}Node;


//节点初始化
Node *create_node(){
    Node *p=(Node *)malloc(sizeof(Node));
    //节点
    p->next=NULL;
    return p;
}

//建立链表,尾部增加
Node *link_list(int d[],int size){
    Node *head=create_node();
    Node *tail=head;        //尾节点，此时尾节点就是头节点
    for(int i=0;i<size;i++){
        Node *p=(Node *)malloc(sizeof(Node));
        p->data=d[i];
        p->next=head;//指向头节点
        tail->next=p;
        tail=p;//p变为尾节点
    }

    return head;
}


//长度
int Len(Node *head){
    Node *p=head;
    if(p==NULL){
        return 0; 
    }
    p=head->next;
    Node *s=head;
    int count=1;
    for(;p!=s&&p!=NULL;count++){
        p=p->next;
    }
    return count;
    
}


//判空
int is_Empty(Node *head){
    if(head->next==NULL){
        return 1;
    }
    return 0;
}

//遍历链表
void display(Node *head){


    Node *p=head->next;//头节点没有数据
    Node *s=head;//标记指针

    printf("此时有%d个节点\n",Len(head));

    for(;p!=s;p=p->next){
        printf("The data is %d\n",p->data);
    }
}

在主函数中测试一下：

int main(){
    int a[5]={2,1,5,11,6};
    int size=sizeof(a)/sizeof(int);
    printf("创建链表\n ");
   
    Node *p=link_list(a,size);
    
    display(p);//遍历循环链表

    Node * s=(p->next)->next;//指向其他节点的指针

    display(s);//其他节点遍历
}

结果如下，可以看到不是预期的结果，某个数据。。。是1995024，这是个啥，这是头节点的data,自动分配的。

创建链表
 此时有6个节点
The data is 2
The data is 1
The data is 5
The data is 11
The data is 6
此时有6个节点
The data is 5
The data is 11
The data is 6
The data is 1995024
The data is 2

这肯定不行啊，说好的头节点不放数据的，所以我们遇到头节点得跳到下一级。1.0版本的可以自己实现一下！

我们搞个2.0版本的。

单循环链表2.0
#include<stdio.h>
#include<stdlib.h>

//定义节点
typedef struct list
{   int data;
    struct list *next;
    /* data */
}Node;

static Node *head=NULL;
static int count=0;


//节点初始化
Node *create_node(){
    Node *p=(Node *)malloc(sizeof(Node));
    //节点
    p->next=NULL;
    return p;
}

//建立链表,尾部增加
Node *link_list(int d[],int size){
    head=create_node();
    Node *tail=head;        //尾节点，此时尾节点就是头节点
    for(int i=0;i<size;i++){
        Node *p=create_node();
        p->data=d[i];
        p->next=head;//指向头节点
        tail->next=p;
        tail=p;//p变为尾节点
    }

    count+=size+1;//节点数量
    return head;
}

//查询
int query(int i){
    is_error(i);

    Node *p=head;

    for(int n=1;n<i;n++){
        p=p->next;
    }
    return p->data;

}

//是否非法
int is_error(int i){
 if(is_Empty()){
        printf("NULL,非法\n");
        return 1;
    }
    if(i<1||i>count){
        printf("查询超长，非法\n");
        return 2;
    }

    return 0;
}


//长度
int Len(){

    return count;
}


//判空
int is_Empty(){
    if(count==0){
        return 1;
    }
    return 0;
}


//遍历链表
void display(Node *p){


    printf("此时有%d个节点\n",count);
   
        for(int i=1;i<count;i++){
            if(p==head){	//判断是否是头指针
                p=p->next;
            }
            printf("The data is %d\n",p->data);
            p=p->next;
        }
    

}

主函数中测试一下：

int main(){
    int a[5]={2,1,5,11,6};
    int size=sizeof(a)/sizeof(int);
    printf("创建链表\n ");
   
    Node *p=link_list(a,size);
    
    display(p);//遍历循环链表

    p=p->next->next;//偏移

    display(p);//其他节点遍历
}

创建链表
 此时有6个节点
The data is 2
The data is 1
The data is 5
The data is 11
The data is 6
此时有6个节点
The data is 1
The data is 5
The data is 11
The data is 6
The data is 2

此时结果应该是正确的！

三、双向链表

双向链表即有两个指向的链表，通常指指向前节点和后继节点的链表。这样也是从任何部位都能遍历全部元素，

且查找元素时，可以向前查找或者向后查找，不必完全遍历全链表。

双向链表示意图：

双向链表

c语言实现双链表

在单链表2.0的基础上研究双链表。

先创建一个双向链表。

#include<stdio.h>
#include<stdlib.h>

//定义节点
typedef struct list
{   int data;
    struct list *next;//双指针
    struct list *prev;
    /* data */
}Node;


static int count=0;//节点数量

static Node *head=NULL;//头节点


//节点初始化
Node *create_node(){
    Node *p=(Node *)malloc(sizeof(Node));
    //节点
    p->next=NULL;
    p->prev=NULL;
    return p;
}


//尾节点
Node *get_tail(){
    Node *tail=head;

    for(int i=1;i<count;i++){
        tail=tail->next;
    }

    return tail;
}

//建立链表,尾部增加
Node *link_list(int d[],int size){
    head=create_node();//头节点初始化
    Node *tail=head;        //尾节点，此时尾节点就是头节点
    for(int i=0;i<size;i++){
        Node *p=create_node();
        p->data=d[i];
        tail->next=p;
        p->prev=tail;
        tail=p;//p变为尾节点
    }
    count=size+1;
    return head;    //返回头节点
}


//长度
int Len(){

    return count;
}


//判空
int is_Empty(){
    if(count==0){
        return 1;
    }
    return 0;
}

//遍历链表，从头节点开始
void display(){

    printf("此时有%d个节点\n",count);

    Node *p=head->next;

    for(;p!=NULL;p=p->next){
        printf("The data is %d\n",p->data);
    }
}

//查找元素
//查找元素
Node* query(int i){
    if(error(i)){
        return NULL;
    }
     Node *p;
    if(i<=(int)(count/2)){//从头结点开始查找
       p=head;
        for(int n=1;n<i;n++){
            p=p->next;
        }
        return p;

    }else                   //从尾节点向前查找
    {
        p=get_tail();
        for(int n=0;n<count-i;n++){
            p=p->prev;
        }
        return p;   
    }
    return NULL;
}

//得到节点
Node *get_node(int i){
    Node *p=head;
    if(i==count){
        return get_tail();
    }
     if(error(i)){
        return NULL;
    }
    for(int s=1;s<i;s++){
        p=p->next;
    }
    return p;
}

//判断传入参数是否非法
int error(int i){
    if(is_Empty()){
        printf("链表NULL,非法\n");
        return 1;
    }
    if(i<1||i>count){
        printf("查询超长，非法\n");
        return 2;
    }

    return 0;
}

测试一下：

int main(){
    int a[5]={2,1,5,11,6};
    int size=sizeof(a)/sizeof(int);
    printf("创建链表\n ");
   
    Node *p=link_list(a,size);
    display();

    
    printf("查询的元素是%d\n",query(5)->data);
    printf("查询的元素是%d\n",query(2)->data);
    
 
}

此时可以查询。

创建链表
 此时有6个节点
The data is 2
The data is 1
The data is 5
The data is 11
The data is 6
查询的元素是11
查询的元素是2

再加入删除、更新、插入函数。

//插入
void insert(int i,int e){

    Node *s =query(i);

    Node *p=create_node();
    p->data=e;
    p->next=s;
    p->prev=s->prev;
    (s->prev)->next=p;
    s->prev=p;
    count++;
}
//删除
void delete(int i){
    Node *s=query(i);
    Node *p,*n;
    //修改指针指向
    p=s->prev;
    n=s->next;
    p->next=n;
    n->prev=p;
    free(s);    //销毁节点
    count--;//数量减少
}
//更新
void update(int i,int e){
    Node *p=query(i);
    p->data=e;
}

再次测试：

int main(){
    int a[5]={2,1,5,11,6};
    int size=sizeof(a)/sizeof(int);
    printf("创建链表\n ");
   
    Node *p=link_list(a,size);
    display();


    printf("查询的元素是%d\n",query(5)->data);
    printf("查询的元素是%d\n",query(2)->data);

    update(2,8);
    display();

    delete(2);
    display();

    insert(2,8);
    display();

}

如下所示：

创建链表
 此时有6个节点
The data is 2 
The data is 1 
The data is 5 
The data is 11
The data is 6
查询的元素是11
查询的元素是2
此时有6个节点
The data is 8
The data is 1
The data is 5
The data is 11
The data is 6
此时有5个节点
The data is 1
The data is 5
The data is 11
The data is 6
此时有6个节点
The data is 8
The data is 1
The data is 5
The data is 11
The data is 6
四、双向循环链表

双向循环链表的用处比较广泛、不过就是双向链表的基础上进行了循环。构造难度不大，可以参考单链表循环实现。

数据结构与算法学习目录

cgl_dong
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构—链表（c语言）
three_points的博客
05-17 514
链表的基本操作 链是一种非常重要的数据结构，我们可以对链表进行增删改查等基本操作 #include<stdio.h> #include<stdlib.h> struct node { int num,score; struct node * next; }; void find(struct node * head)/*查找节点*/ struct node *p; int x; printf("输入要查找的学号:\n"); scanf("%d",&x); p=h
数据结构-单链表（c语言）
jxau_dslj的博客
03-07 1879
线性表的链式表示和实现： 提示：这里简述项目相关背景： 例如：项目场景：示例:通过蓝牙芯片(HC-05)与手机 APP 通信，每隔 5s 传输一批传感器数据(不是很大) 问题描述： 提示：这里描述项目中遇到的问题： 例如：数据传输过程中数据不时出现丢失的情况，偶尔会丢失一部分数据 APP 中接收数据代码： @Override public void run() { bytes = mmInStream.read(buffer); mHandl
C语言数据结构之链表
广源的博客
11-14 3052
目录 1.什么是链表 2.链表的定义 3.链表的分类 4.动态内存分配 4.1.malloc函数 4.2.动态数组的构造 4.3.动态内存和静态内存的比较 4.链表的创建 5.遍历链表 6.链表节点的插入 7.链表节点的删除     1.什么是链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（...
C语言数据结构——链表
热门推荐
zcxmjw的博客
12-22 1万+
大家好，本篇文章主要带领大家了解一下什么是链表，链表的两个主要结构，以及链表和顺序表的差别。
数据结构——C语言实现链表
theonly_Love的博客
05-22 1万+
一. 链表的概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。在这里介绍链表中的两种结构
数据结构——链表 C语言
03-16
设单链表A和B均非递减有序，试设计算法，将A和B合并成非递增有序的单链表C，并要求利用原表A和B的结点空间构造表C。
C语言数据结构-链表版学生管理系统
10-02
《C语言数据结构-链表版学生管理系统》 在计算机科学中，数据结构是组织、存储和处理数据的重要工具，而链表作为一种基础且灵活的数据结构，被广泛应用于各种复杂算法和系统设计中。本项目《C语言数据结构-链表版...
数据结构-链表的C语言使用
03-25
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在处理动态数据集合时。在C语言中，链表不像是数组那样在内存中连续存储元素，而是通过一系列分散的内存块（称为节点）来表示数据。每个...
数据结构C语言链表的实现
04-18
数据结构C语言链表的实现
(C语言数据结构)单链表
09-16
C语言实现单链表 Init(初始化) Length(当前结点个数) AddEnd(尾部添加) AddFirst(首部添加) Insert(插入) * Delete(删除) Find(查找返回) ShowAll(显示所有元素) Destory(销毁链表)
数据结构单链表c语言实现
03-26
数据结构的单链表C语言版完整实现，本人知识初学者实力浅浅，可能对于大佬来说只是rubb**。如果同样是初学者的话，可能对于你或许有些用处。如果帮助到你很开心，如果你觉得有些low希望可以提出宝贵的建议 ！！
数据结构链表的全操作C语言
06-20
数据结构链表全操作，使用C语言编写，完整，兼容，高效，欢迎访问www.omegaxyz.com查看更多。
C语言 数据结构之链表实现代码
01-20
最近在复习数据结构的相关知识，感觉在初学的时候还是有很多东西没有掌握，不过现在终于算是搞得比较有头绪了，所以就在写出来和大家一起分享！ 什么是链表 简单的说，链表就是由多个结点离散分配，彼此通过指针...
C语言基础入门：链表详解篇
C语言C++学习俱乐部：765860056
11-24 2763
链表概述 　　链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。它可以根据需要开辟内存单元。链表有一个“头指针”变量，以head表示，它存放一个地址。该地址指向一个元素。链表中每一个元素称为“结点”，每个结点都应包括两个部分： 一为用户需要用的实际数据，二为下一个结点的地址。因此，head指向第一个元素：第一个元素又指向第二个元素;……，直到最后一个元素，该元素不再指向其它元素，它称为“表尾”，它的地址部分放一个“NULL”(表示“空地址”)，链表到此结束。 　　链表的各类操.
Redis学习之底层链表源码分析
Y先森0.0
04-20 165
Redis学习之底层链表源码分析 ps：C语言没有内置的链表，所以Redis构建了自己的链表实现，研究Redsi源码的话链表必须要研究一下！ 一.链表结点的结构（单个结点）： // listNode 双端链表节点 typedef struct listNode { // 前置节点 struct listNod...
【数据结构】【C语言】------ 单链表
m0_63601181的博客
05-14 4178
前言 大家好，我是Abert。 这篇文章和大家分享用C语言实现数据结构中的单链表。 单链表可以看作是“拆分开”的顺序表。在顺序表的基础上，单链表做了一些优化，但同时也丧失了一些顺序表有的功能。 我们一起来学习单链表吧！！！ 文章目录 一、单链表的讲解 二、程序基本框架的搭建与讲解 2.1 文件的创建 2.2 变量的创建 三、各种功能的实现及逻辑关系的讲解 3.1 尾插 3.2 头插 3.3 尾删 ...
数据结构-循环链表
qq_37993640的博客
11-18 115
单链表：每个节点存储了存储了下一个节点的地址。上一个节点存储有后一个节点的地址。 双链表：每个节点不仅存储了下一个节点的地址，还存储了上一个节点的地址。 循环单链表：链表尾节点存放了链表头节点的地址。 循环双链表：每个节点不仅存储了下一个节点的地址，还存储了上一个节点的地址，同时，链表尾节点和链表头节点也存在上述关系构成闭环。 代码如下： #include <stdio.h> #include<stdlib.h> #include<iostream> #include&
数据结构奇偶链表c语言
最新发布
11-16
以下是一个C语言实现的奇偶链表的例子： ```c struct ListNode* oddEvenList(struct ListNode* head) { if (head == NULL) { return head; } struct ListNode* odd = head; // 奇数第一个结点 struct ListNode* evenHead = head->next; // 保存偶数头结点 struct ListNode* even = evenHead; // 偶数第一个结点 while (even != NULL && even->next != NULL) { odd->next = even->next; // 奇偶指针的变换 odd = odd->next; even->next = odd->next; even = even->next; } odd->next = evenHead; // 奇数链表的尾巴指向偶数链表的头 return head; } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值