数据结构（二）——单链表

已于 2023-08-09 09:27:17 修改
阅读量63 收藏
点赞数
分类专栏： 嵌入式学习 数据结构 文章标签： 数据结构
于 2023-08-08 22:37:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59566583/article/details/132177312
版权

一 单链表简介

1、定义

单链表是一种基本的数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一个节点的
指针。

在单链表中，每个节点的指针只指向下一个节点，最后一个节点的指针指向空值，表示链表的尾部。链
表的头部指针指向链表的第一个节点。

2、优缺点

链表的优势在于可以动态地添加和删除节点，不需要预先分配内存空间。但是查找某个节点的效率相对
较低，需要从头部开始遍历。

二 代码示例

1、头文件


/*===============================================
*   文件名称：linklist.h
*   创 建 者:    
*   创建日期：2023年08月08日
*   描    述：
================================================*/
#ifndef _LINKLIST_H
#define _LINKLIST_H
typedef int data_t;

//定义节点类型
typedef struct linklist
{
    data_t data;
    struct linklist* next ;
}link,*plink;

//创建头节点
plink init_linklist();

//插入节点
int insert_linklist(plink L , int index , data_t value);

//按值删除
int delete_linklist(plink L , data_t value);

//按下标删除
int pdelete_linklist(plink L , int pos );

//判空
int empty_linklist(plink L );

//打印
int show_linklist(plink L );

//求长度
int getlen_linklist(plink L);

//按值修改
int change_linklist(plink L , data_t value ,data_t data);

//按下标修改
int pchange_linklist(plink L , int pos ,data_t data);


//按值查询下标
int select_linklist(plink L , data_t value );

//按下标查询值
int pselect_linklist(plink L , int pos );

//清空
int clear_linklist( plink L );

//销毁
int destroy_linklist( plink *L );

//逆序
int Rs_linklist( plink L);

//排序
int sort_linklist( plink L );

#endif

2、功能代码


创建头节点
//创建头节点
plink  init_linklist()
{
    plink L = (plink)malloc(sizeof(link)); // 开辟空间
    if( NULL == L )
    {
        return NULL;
    }
    L->next = NULL; //初始l->next为0
    return L;
}

插入函数
//插入节点
int insert_linklist(plink L , int index ,data_t value)
{
    if( NULL == L )
    {
        return -1;
    }
    if( index < 0 || index > getlen_linklist(L))
        return -2;

    //将L移动到需要插入的位置
    while(index--)
        L = L->next;
        
    plink S = (plink)malloc(sizeof(link));  //开辟空间给插入的节点
    if( NULL == S )
    {
        return -1;
    }
    S->next = L->next ;//新节点的next先指向L的next，防止L的后面节点丢失
    L->next = S ;  // L的next指向S
    S->data = value ;// 给新节点赋值
    return 0;
}

删除（按值）
//按值删除
int delete_linklist(plink L , data_t value)
{
    if( NULL == L )
    {
        return -1;
    }
    if( 0 == empty_linklist(L) )
    {
        return -2;
    }
    plink p = L->next ; // p 指向第一个有数据的节点
    while(p->next) //通过p循环遍历
    {
        
        if( value == p->next->data )  // 找到链表中对应的值
        {
            plink q = p->next; // q暂存需要删除的节点
            p->next = q->next; // p断开该节点
            free(q);  // 释放该节点空间
            q = NULL ;  // 将q指向NULL 防止野指针
            continue; // 如果找到了之后，删除节点后结束本次循环，避免下一次循环跳过两个数值相邻且都需要删除的情况
        }
    
        p = p->next; // p向后移动
    }
    
    return 0;
}

删除（按下标）
//按下标删除
int pdelete_linklist(plink L , int pos )
{

    if( NULL == L )
    {
        return -1;
    }
    if( 0 == empty_linklist(L) )
    {
        return -2;
    }
 
    //将L移动到相应下标处
    while(pos--)
    L = L->next; 
    plink q = L->next; //定义q临时存储需要删除的节点
    L->next = q->next;  // L指向下一个节点
    free(q); // 释放q指向节点
    q = NULL ;//将q指向NULL 防止野指针

    return 0;
}

判空
//判空
int empty_linklist(plink L )
{
    if( NULL == L )
    {
        return -1;
    }
    if( NULL == L->next ) // 如果头节点的next为空，则链表为空
        return 0 ;

}

打印
//打印
int show_linklist(plink L )
{
    if( NULL == L )
    {
        return -1;
    }
    if( 0 == empty_linklist(L) )
    {
        return -2;
    }
    plink p = L ;
    int i = 0 ;
    p = p->next;// p指向第一个有数据的节点
    while( 1 )
    {
        
        if( p == NULL ) // 如果p==NULL 则指向最后，结束循环
            break;
        printf("节点[%d].data = %d  ",i,p->data);
        p = p->next;  // p移动一位 
        i++; 
    }
    puts("");
    return 0;
}

计算长度
//计算链表长度
int getlen_linklist(plink L )
{

    if( NULL == L )
    {
        return -1;
    }
    plink p=L->next;//p指向第一个有数据的节点
    int count=0;//记录链表节点个数
    while(L->next) // 循环整个链表
    {
        count++;//一次循环，则增加一次
        L=L->next;
    }
    return count;//返回节点个数
}

修改（按值）
//按值修改
int change_linklist(plink L , data_t value , data_t data)
{

    if( NULL == L )
    {
        return -1;
    }
    if( 0 == empty_linklist(L) )
    {
        return -2;
    }
    

    L = L->next; //使L指向第一个有数据的节点
    while( L )
    {
        if( value == L->data) // 找到匹配的数据值
        {
            L->data = data; //将该数据值更改
        }
        L = L->next; // L 移动一位
    }
    return 0;
}

修改（按下标）
//按下标修改
int pchange_linklist(plink L , int pos , data_t data)
{
    if( NULL == L )
    {
        return -1;
    }
    if( pos < 0 || pos >= getlen_linklist(L))
        return -2;

   // 找到该下标对应节点
    while(pos--)
        L = L->next;
    L = L->next;   // 因为L是从头节点开始，所以要再移动一位才是对应的节点
    L->data = data; //更改数据值
    return 0;
}

查询（按值）
//按值查询下标
int select_linklist(plink L , data_t value )
{
    if( NULL == L )
    {
        return -1;
    }
    if( 0 == empty_linklist(L) )
    {
        return -2;
    }

    int count = 0;
    L = L->next; //使L指向第一个有数据的节点
    while(L) 
    {
        if( value == L->data )  // 找到对应值
        {
            break; //结束循环，此时count记录的值即为下标
        }
        L = L->next;
        count++;
    }
    if( 0 == count )
        return -3;// 如果没有找到对应值，则返回-3
    else
        return count;
}

查询（按下标）
//按下标查询值
int pselect_linklist(plink L , int pos )
{

    if( NULL == L )
    {
        return -1;
    }
    if( pos < 0 || pos >= getlen_linklist(L))
        return -2;

    //找到该下标的节点
    while(pos--)
        L = L->next;
    L = L->next;
    
    return L->data; //返回该节点的数据
}

清空链表
//清空
int clear_linklist( plink L )
{

    if( NULL == L )
    {
        return -1;
    }
    if( 0 == empty_linklist(L) )
    {
        return 0;
    }

	//得到链表长度
    int i = getlen_linklist(L);
    
    //循环调用删除函数，将所有节点（除头节点外）删除
    while(i--)
    {
        pdelete_linklist(L,0);
    
    }
    return 0;
}

销毁链表
//销毁
int destroy_linklist( plink *L )
{

    if( NULL == *L )
    {
        return -1;
    }


    clear_linklist(*L); //调用清除函数，将链表只有头节点
    free(*L);//释放头节点
    *L = NULL; //将*L指向NULL
    return 0;
}

逆序

将链表的数据逆反过来，将头结点与有数据的链表分开，看作两个链表，将数据链表节
点依次按照头插的方式插入头结点链表，（头插方式先插入的在后面）

//逆序  将链表的数据逆过来存储在其中
int Rs_linklist( plink L)
{
    
    if( NULL == L )
    {
        return -1;
    }
    if( 0 == empty_linklist(L) )
    {
        return 0;
    }

    plink p = L->next  ; //p指向第一个有数据的节点
    L->next = NULL ;  // 断开头节点
    
    while(p) // 使用头插循环插入
    {
        plink q = p->next; // q存储p->next，防止链表地址丢失
        
        // 将p指向节点通过头插连接到头节点的链表上
        p->next = L->next; 
        L->next = p ;
        
        
        p = q ;//p指向下一个节点
    }
    return 0;
}

排序

将链表的数据进行排序，将头结点与有数据的链表分开，看作两个链表，将数据链表节
点依次插入头结点链表，循环头结点链表进行比较，将数据节点插入到比自己大的节点前一个位置上

//排序
int sort_linklist( plink L )
{
    
    if( NULL == L )
    {
        return -1;
    }
    if( 0 == empty_linklist(L) )
    {
        return 0;
    }

    plink p = L->next; //p指向第一个有数据的节点
    L->next = NULL ; // 断开头节点
    
    
    //外循环，遍历有数据的链表
    while(p)
    {
        plink q = L ; // q为头节点链表的指针
        plink t = p->next; // t存储了p->next
        
        //内循环，遍历头节点的链表
        while( q->next )
        {
            if( q->next->data > p->data)//找到比p节点数据大的数据，确定插入位置为该数据前一位
                break;
            q = q->next;
        }
        
        // 将p指向的节点插入到头节点的链表中
        p->next = q->next;
        q->next = p ;
        
        
        p = t; // p向后移一位

    }
    return 0;

}

3、测试代码

/*===============================================
*   文件名称：main.c
*   创 建 者:   
*   创建日期：2023年08月08日
*   描    述：
================================================*/
#include <stdio.h>
#include "linklist.h"
int main(int argc, char *argv[])
{ 
    //初始化单链表
    plink L = init_linklist();
    if( NULL == L )
    {
        puts("init err");
        return -1;
    }

//插入节点
    for(int i = 0 ; i < 8 ; i++ )
    {
        if( 0 != insert_linklist(L ,i,i+1))
        {
            puts("for: insert err");
            return -1;
        }
    }
    if( 0 != show_linklist(L ))
    {
        puts("show err");
        return -1;
    }
    puts("");

//删除

    puts("删除3");
    if( 0 != delete_linklist(L , 3))
    {
        puts(" delete  err");
        return -1;
    }
    
    if( 0 != show_linklist(L ))
    {
        puts("show err");
        return -1;
    }
    puts("");
//删除

    puts("删除下标2");
    if( 0 != pdelete_linklist(L , 2))
    {
        puts(" pdelete  err");
        return -1;
    }
    
    if( 0 != show_linklist(L ))
    {
        puts("show err");
        return -1;
    }
    puts("");

//修改

    puts("按值修改，1");
    if( 0 != change_linklist(L , 1 , 1111))
    {
        puts(" change  err");
        return -1;
    }
    
    if( 0 != show_linklist(L ))
    {
        puts("show err");
        return -1;
    }
    puts("");


//按下标修改

    puts("按下标修改,2");
    if( 0 != pchange_linklist(L , 2 , 2222))
    {
        puts("pchange  err");
        return -1;
    }
    
    if( 0 != show_linklist(L ))
    {
        puts("show err");

    return 0;
    }
    puts("");

//按值查询

    puts("按值查询.2222");
    int ret = 0;
    if( 0 > ( ret = select_linklist(L ,2222)))
    {
        puts(" select  err");
        return -1;
    }
    printf("查询到的下标是：%d\n",ret);
    puts("");


//按位置查询

    puts("按位置查询，5");
    if( 0 >( ret = pselect_linklist(L ,5)))
    {
        puts(" pselect  err");
        return -1;
    }
    printf("查询到的值是：%d\n",ret);
    puts("");

//逆序
   
    puts("逆序：");
    Rs_linklist(L);
    show_linklist(L);
    puts("");


//排序
    puts("排序:");
    sort_linklist(L);
    show_linklist(L);
    puts("");

//清空
    puts("清空:");
    clear_linklist(L);
    ret = show_linklist(L);
    if( -2 == ret )
        puts("已清空");



//销毁
    puts("销毁:");
    destroy_linklist(&L);
    ret = show_linklist(L);
    if( -1 == ret )
        puts("已销毁");


return 0;
}

三 运行结果

在这里插入图片描述

南城花開
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——单链表实验
06-15
熟悉单链表的定义，单链表的建立方法及相关基本操作，理解单链表的基本思想，能够根据实际情况选择合适的存储结构。 2.实验内容 1、利用头插法或尾插法建立单链表 2、对已建立的单链表实现插入、删除等基本操作； 3...
【数据结构】——单链表超详细介绍（独家介绍，小白必看！！！）
热门推荐
yakiyakiya的博客
09-06 2万+
今天又是认真更新的一天耶！！一万字的文章，带你吃透单链表！文章内含链表的构建、链表构建时的易错点和注意事项以及链表与顺序表的区别，详细讲解到小白都能学会。
数据结构精讲——单链表
weixin_43635473的博客
10-15 287
新手必会数据结构精讲——单链表
数据结构初阶——单链表
m0_64607843的博客
05-05 3077
上一篇为各位介绍了顺序表， 那么这一篇就来介绍另一种数据结构：单链表。想看代码的老铁直接跳转到结尾
数据结构07——单链表查找算法
weixin_45658431的博客
09-20 464
从链表的头指针出发，顺着next域逐个结点往下搜索，直到查找到与要搜索的值相等的数据为止。3）如果查遍整个链表都没有找到其值和e相等的元素，则返回0或“NULL”2）如果找到一个值与e相等的数据元素，则返回其在链表中的地址。1）从第一个结点起，依次和e比较。
数据结构——单链表
Tang_ming_yue的博客
04-29 749
dan链表是一种链式存取的数据结构，，链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。以“结点的序列”表示的线性表称作线性链表（单链表），单链表是链式存取的结构。 ...
数据结构08——单链表插值算法
weixin_45658431的博客
09-20 49
1.插入——在第i 个结点前插入值为e 的新结点算法步骤：算法描述：
数据结构基础——单链表顺序存储结构
溯洄℡
09-10 750
单链表顺序存储结构的基本操作 实验内容： 单链表的整表创建。 单链表的第i个位置插入元素。 单链表的第i个位置删除元素。 单链表的按值查询。 单链表的整表输出。 单链表的整表删除。 SinglyLinkedList.h /*单链表的建立*/ #include <stdio.h> #include <stdlib.h> /****提供malloc、realloc、fr...
数据结构学习——单链表的基本操作
m0_58327740的博客
11-08 1677
一.题目要求 实现单链表各种基本运算的算法】 问题描述：该算法的设计，要求运行结果如下所示： 单链表的基本运算如下: (1)初始化单链表head (2)依次采用尾插法插入a,b,c,d,e元素 (3)输出单链表head:a b c d e (4)单链表head长度:5 (5)单链表head为非空 (6)单链表head的第3个元素:c (7)元素a的位置:1 (8)在第4个元素位置上插入f元素 (9)输出单链表head:a b c f d e ...
数据结构————单链表
d__yz的博客
09-17 197
** 存在一个含有n个元素的单链表，将第i-1个结点与第i个结点互换，指针不变 ** #include<stdio.h> #include<malloc.h> //有一个n个结点的单链表 ，将第i-1个结点与第i个结点互换，指针不变 typedef int ElemType; typedef struct LNode{ ElemType data; struct ...
数据结构——单链表（下）
麦麦的博客
03-04 1307
数据结构——单链表（下）：干货十足，图文并茂，不容错过的优质好文，欢迎小伙伴们前来学习！！！
数据结构学习笔记——单链表
12-21
链表（linked list）是一种在物理上非连续，非顺序的数据结构，由若干节点（node）组成 单链表每一个节点又包含两部分，1是存放数据的变量data，2是存放指向下一个结点的指针next 双向链表每一个节点包含三部分，在...
数据结构——单链表.zip
09-16
完全实现严蔚敏数据结构教材中的单链表，可测试。包含初始化，插入，删除，连接等操作
数据结构实验报告——单链表.docx
12-05
数据结构实验报告
JAVA数据结构——单链表的操作.docx
07-11
JAVA数据结构——单链表的操作 单链表的操作 方法一： package ch02; (1)建立结点类Node.java public class Node { public Object data;//存放结点数据值 public Node next;//存放后继结点 //无参构造函数 public ...
数据与结构--二叉树
weixin_66905164的博客
05-10 970
树是一种非线性的数据结构，它是由n(n>=0)个有限结点组成的一个具有层次关系的集合。树的特点：有一个特殊的结点，称为根结点，根结点没有前驱结点。除根结点外，其余结点被分成M(M>0)互不相交的集合T1,T2…Tm，其中每一个集合Ti(1<=i<=m)又是一颗结构与树类似的子树。每棵子树的根结点有且仅有一个前驱，可以有0个或多个后继。因此，树是递归定义的。节点的度：一个节点含有的子树的个数称为该节点的度；如上图：A的为6叶节点或终端节点：度为0的节点称为叶节点；
C++的数据结构(一）
winterling的博客
05-11 466
C++的数据结构(一）：链表，栈，二叉搜索树
数据结构——队列
最新发布
babilunlaobanjiu的博客
05-11 205
原来 1 2 3 4 入队 出队两次， 变成 3 4 .
5/11后面部分：+顺序排序+元素交换+计算每门课程的各种成绩+存放规律的数据 注意：一味的复制肯定要出问题，第2个的最后一部分有修改，注意观察
2201_75637762的博客
05-11 769
i++)j < i;j++)printf("排序完成的数组为：");i < 10;int main()printf("请输入值:\n");i < m;j < m;i < m;j < m;
数据结构复习——习题一
10-07
数据结构习题集中的习题一是关于栈的内容。栈是一种特殊的线性表，它的特点是先进后出。栈的基本操作包括入栈和出栈。入栈是将元素添加到栈的顶部，而出栈是将栈顶的元素移除。栈的实现方式有顺序栈和链栈两种。顺序栈使用数组来实现，而链栈使用链表来实现。 习题一：栈 题目：设计一个栈，包括入栈、出栈和获取栈顶元素的操作，并分析它们的时间复杂度。 解答： 入栈操作的时间复杂度为O(1)，因为只是将元素添加到栈顶，不需要遍历整个栈。 出栈操作的时间复杂度也为O(1)，因为只是将栈顶元素移除，不需要遍历整个栈。 获取栈顶元素的操作的时间复杂度也为O(1)，直接返回栈顶元素即可。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值