数据结构——单向链表

已于 2022-08-20 18:38:27 修改
阅读量197 收藏
点赞数
分类专栏： 基于Linux的C语言数据结构 文章标签： 链表 数据结构 c语言 linux
于 2022-08-10 17:15:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59700590/article/details/126249683
版权

1、前言

        我们学完顺序表以后我们现在来学习链表，我们先学习最简单的单向链表，

2.链表

        2.1特点

                链式存储不是连续存储，大小不固定，其插入和删除很简单，但是其访问和查找比较难实现，在单向链表中每个节点都有前驱和后继（头结点只有后继，尾结点只有前驱）

        2.2实现一个节点

                我们肯定使用我们学过的结构体来实现我们的节点，我们要在结构体内定义数据域和指针域

typedef int data_type
typedef struct link
{
    //数据域
    data_type data;
    //指针域
    struct link *next;
}Link;
//接下来定义头部节点
Link *head=(Link *)malloc(sizeof(Link));

接下来我们直接写代码吧 

2.2.1先来实现头结点的创建，我们先写库函数link.h

#ifndef _LINK_H
#define _LINK_H
//引入头文件
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//创建结构体
//数据类型的定义
typedef int data_type
struct link
{
    data_type data;
    struct link *next;
}Link;

//定义错误枚举，在这里我把我们接下来可能出现的错误进行定义，以便我们可以快速查找错误
enum value
{
    EMPTY_ERROR=-7,
    FULL_ERROR,
    POS_ERROR,
    CREAT_ERROR,
    NULL_ERROR,
    MALLOC_ERROR,
    ERROR,
    OK
};
Link * my_node();//创建结点
#endif

2.2.2接下来写main.c

#include "../include/link.h"

int main()
{
    Link *phead=NULL;
    phead=my_head;
    if(NULL==phead)
    {
        printf("申请空间失败\n");
        return ERROR;
    }
    printf("申请成功\n");
    return 0;
}

2.2.3编写 link.c

#include "../include/link.h"
//链表节点的建立
Link * my_node()
{
    Link *pHead=(Link *)malloc(sizeof(Link));
    if(NULL==pHead)
    {
        printf("malloc error");
        return NULL;
    }
    memset(pHead,'\0',sizeof(Link));
    return pHead;
}

2.3:插入数据 

        主函数

#include "../include/link.h"

int main()
{
    Link *phead=NULL;
    phead=my_node();
    if(NULL==phead)
    {
        printf("申请空间失败\n");
        return ERROR;
    }
    printf("申请成功\n");
    //插入数据
    int pos;
    int data;
    while(1)
    {
        printf("请输入插入的位置\n");
        scanf("%d",&pos);
        if(pos==-1)
        {
            break;
        }
        printf("请输入插入的数据\n");
        scanf("%d",&data);
        my_insert(pHead,pos,data);
    }

    return 0;
}

 子函数

#include "../include/link.h"
Link * my_node()
{
    Link *pHead=(Link *)malloc(sizeof(Link));
    if(NULL==pHead)
    {
        printf("malloc error");
        return NULL;
    }
    memset(pHead,'\0',sizeof(Link));
    return pHead;
}
//插入函数
//在插入函数的中我们要分三个区域，分别为头部插入（在头结点之后插入）
//中间插入
//尾部插入
int my_insert(SeqLink *phead,int pos,int Newdata)
{
    //入参检查
    if(NULL==*phead)
    {
        printf("creat error:");
        return CREAT_ERROR;
    }
    if(pos<0)
    {
        printf("pos error: ");
        return POS_ERROR;
     }
    //为我们要插入的数据申请一个 结点
    Link *pnew=my_node();
    penw->data=newdata;
    //接下来我们判断插入位置进行插入
    switch(pos)
    {
        //首部插入
        case 1:
           {     //判断此时链表是否为空
                if(NULL==phead->next)
                {
                     phead->next=pnew;
                }
                else
                {
                    pnew->next=phead->next;
                    phead->next=pnew;
                }
                break;
            }
        //尾部插入
        case 0:
            {
                Link *ptail=phead->next;
                if(NULL==ptail)
                {
                    phead->next=pnew;
                }
                else
                {
                    while(NULL != ptail->next)
                    {
                        ptail=ptail->next;
                     }
                    ptail->next=pnew;
                break;
           }
        default:
            {
                Link *ppre=phead;
                if(NULL==ppre->next)
                {
                    ppre->next=pnew;
                }
                else
                {
                    for(int i=0;(i<pos-1)&&(NULL != ppre);i++)
                    {
                        ppre=ppre->next;
                    }
                    if(NULL==ppre)
                    {
                        printf("pos error:");
                        return POS_ERROR;
                    }
                    else
                    {
                        pnew->next=ppre->next;
                        ppre->next=pnew;
                    }
                }
            }
    }
    rerurn OK;
}

2.4删除函数

#include "../include/link.h"
Link * my_node()
{
    Link *pHead=(Link *)malloc(sizeof(Link));
    if(NULL==pHead)
    {
        printf("malloc error");
        return NULL;
    }
    memset(pHead,'\0',sizeof(Link));
    return pHead;
}
//插入函数
//在插入函数的中我们要分三个区域，分别为头部插入（在头结点之后插入）
//中间插入
//尾部插入
int my_insert(SeqLink *phead,int pos,int Newdata)
{
    //入参检查
    if(NULL==*phead)
    {
        printf("creat error:");
        return CREAT_ERROR;
    }
    if(pos<0)
    {
        printf("pos error: ");
        return POS_ERROR;
     }
    //为我们要插入的数据申请一个 结点
    Link *pnew=my_node();
    penw->data=newdata;
    //接下来我们判断插入位置进行插入
    switch(pos)
    {
        //首部插入
        case 1:
           {     //判断此时链表是否为空
                if(NULL==phead->next)
                {
                     phead->next=pnew;
                }
                else
                {
                    pnew->next=phead->next;
                    phead->next=pnew;
                }
                break;
            }
        //尾部插入
        case 0:
            {
                Link *ptail=phead->next;
                if(NULL==ptail)
                {
                    phead->next=pnew;
                }
                else
                {
                    while(NULL != ptail->next)
                    {
                        ptail=ptail->next;
                     }
                    ptail->next=pnew;
                break;
           }
        default:
            {
                Link *ppre=phead;
                if(NULL==ppre->next)
                {
                    ppre->next=pnew;
                }
                else
                {
                    for(int i=0;(i<pos-1)&&(NULL != ppre);i++)
                    {
                        ppre=ppre->next;
                    }
                    if(NULL==ppre)
                    {
                        printf("pos error:");
                        return POS_ERROR;
                    }
                    else
                    {
                        pnew->next=ppre->next;
                        ppre->next=pnew;
                    }
                }
            }
    }
    rerurn OK;
}

//删除数据
int my_delete(Link *pHead,int pos, data_type *pDelData)
{
	if(NULL == pHead)
	{
		printf("creat is error!\n");
		return CREAT_ERROR;
	}
	if(pos < 0)
	{
		printf("pos is error!\n");
		return POS_ERROR;
	}
	if(NULL == pDelData)
	{
		printf("null error!\n");
		return NULL_ERROR;
	}
	switch(pos)
	{
		case HEAD:
			{
				//头部删除
				printf("I am Head!\n");
				break;
			}
		case TAIL:
			{
				//尾部删除
				printf("I am Tail!\n");
				break;
			}
		default:
			{
				//中间删除
				//判断是否为空链表
				Link *pDelPre = pHead;
				if(NULL == pHead->pNext)
				{
					printf("空链表! 不能删除操作!\n");
					return EMPTY_ERROR;
				}
				else
				{
					//采用寻找pos-1的位置即可
					int i;
					for(i=0;(i<pos-1) && (NULL != pDelPre);i++)
					{
						pDelPre = pDelPre->pNext;
					}
					//判断引起for结束的原因 
					if(NULL == pDelPre)
					{
						printf("pos is error!\n");
						return POS_ERROR;
					}
					//定义一个临时指针接替pDelPre->pNext
					Link *pDel = pDelPre->pNext;
					//保存被删除结点之后的所有结点
					pDelPre->pNext = pDel->pNext;
					//保存被删除的数据
					*pDelData = pDel->data;
					//释放 
					free(pDel);
					pDel = NULL;
				}
			}
	}
	return OK;
}

2.5显示函数

        

int my_show(Link *phead)
{
    //入参检查
    if(NULL==phead)
    {
        printf("creak error:\n");
        return CREAK_ERROR;
    }
    Link *pshow=phead->next;
    if(NULL==pshow)
    {
        printf("空链表！\n");
        return EMPTY_ERROR;
    }
    else
        {
             while(NULL != pshow)
                {
                    printf("%3d",pshow->data);
                    pshow=pshow->next;
                }
        
            printf("\n");
            printf("显示完毕\n");
        
         }
    return OK;
}

2.6销毁函数 

int DestroyLink(Link *pHead)
{
	if(NULL == pHead)
	{
		printf("creat is error!\n");
		return CREAT_ERROR;
	}
	//判断是否为空链表
	if(NULL == pHead->pNext)
	{
		//释放头结点的空间
		free(pHead);
		//该置空是不会引起实际参数的指向发生变化，形式参数的指向此时被改变了
		pHead = NULL;
	}
	else
	{
		//不能去直接释放pHead，后续还有一些结点
		//（1）先释放头结点之后的所有结点
		Link *pDelHead = pHead->pNext;
		Link *pDelTemp = NULL;

		while(NULL != pDelHead)
		{
			pDelTemp = pDelHead;
			//释放pDelTemp结点之前：先保存pDelTemp->pNext/pDelHead->pNext
			//之后的所有结点
			pDelHead = pDelHead->pNext;
			//释放
			free(pDelTemp);
			pDelTemp = NULL;
		}
		//（2）最后再释放头结点
		free(pHead);
		//给形式参数pHead置空
		pHead = NULL;
	}
	return OK;

}

3、最后 

       我在单向链表中为大家展示了如何创建节点，如何在插入数据，如何删除数据，如何展示数据，如何销毁链表，因为我们是在堆区开辟的空间最后要我们手动释放空间，剩下的还有如何查找数据，还有修改数据，这两个函数留给大家自己练手，不会的可以私信我，好了，我们的单向链表到这里就要结束了，下一篇文章，我将会为大家讲解双向链表，其大部分的知识点与单向链表差不多，大家学完单向链表再学习双向链表就比较简单了

         

学习C语言之路
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C语言实现链表基本操作
qq_56066173的博客
08-20 4559
如果把数据比喻成珠子，指针就是线，链表通过指针这条线就是把数据这些珠子串起来。
链栈（头插法）
weixin_44119517的博客
10-03 665
#include<stdio.h> #include<malloc.h> typedef struct stack{ int elem; struct stack *next; }*stack_1,stack_2; stack_2 *create(); //创建并初始化 int Judge_empty(stack_1 phead);//判空 void i...
单链表的操作
m0_61784615的博客
11-28 242
1.链表的初始化 struct link{ int data; struct link*next; } struct link* head;//定义头指针变量 head=(struct link*)malloc(sizeof(struct link));//头指针指向分配的头节点内存空间 head->next=NULL;//头节点指针域为空 2.尾插法建立链表 struct link *r,*s; int data; r=head;//r指向头节点 while(1) {
链表
xiunai78的专栏
10-05 408
typedef int DATATYPE typedef struct tag_link {     DATATYPE data;     struct tag_link * next; }link; #define NULL 0 link * CreatLink(void) //表头插入 {     link *head=NULL;     link *P1;     P1=(link*
【C语言】单链表建立、插入删除操作
qq_43782985的博客
06-13 5202
C语言-单链表
数据结构笔记：单向链表
12-22
分类目录——数据结构笔记 离散存储，手拉手，每一块有指向下一块的指针（形象描述，python中没有指针），就好像形成了一条链 一个元素包括两部分：value 和 next 链表与顺序表都是线性表 知识点补充 b = 20 a = 'a...
算法和数据结构——链表.pdf
08-07
在标题《算法和数据结构——链表.pdf》中提到的“算法”指的是对数据的处理过程和步骤，而“数据结构”是指数据在计算机中的组织方式，二者在计算机科学中是基础且核心的概念。在数据结构的学习中，链表是实现算法的...
图解数据结构（使用Python）——链表
12-21
【链表】是一种基本的数据结构，它在计算机科学中扮演着重要的角色，特别是在处理动态数据集合时。链表不同于数组，它的元素在内存中不是连续存储的，而是通过每个节点的指针链接起来。这样的设计使得链表在某些操作...
数据结构 单向链表 双向链表 源程序
05-11
本文将深入探讨两种重要的线性数据结构——单向链表和双向链表，以及它们在实际编程中的应用。 单向链表是一种线性数据结构，它的每个元素（称为节点）包含两部分：数据域，用于存储实际的数据；指针域，用于存储下...
数据结构---线性表之单链表（C语言）
03-28
单链表是数据结构中的一种基础类型，尤其在C语言编程中经常被使用。它是一种线性的、非连续的数据组织形式，每...通过C语言实现，我们可以直观地理解链表的工作原理，这对于进一步学习高级数据结构和算法具有重要意义。
力扣-----链表
最新发布
laugh哥的博客
09-15 861
力扣专题：链表 链表是一种特殊的线性结构，由于不能像数组一样进行随机的访问，所以和链表相关的问题有他自身的穿针引线特点。
C语言单链表操作笔记2.0
ziwei1259455949的博客
01-03 530
#include <stdio.h> #include <stdlib.h> #include <stdbool.h> // 定义表结构类型 typedef struct Link { int data; struct Link *next; } link; /* 预定义函数 */ link* initLink(); // 初始化 单链表 link* InsetElem(.
关于链表头节点 pHead==null 判断 语句放置位置引起错误原因分析
nsjlive的博客
03-01 1947
一、例如，下面这个题目是剑指offer的题目， 复制复杂链表https://mp.csdn.net/postedit/88047408 如果不写if(pHead==null) {return null} 语句，会提示： 答案错误:您提交的程序没有通过所有的测试用例 case通过率为80.00% 分析原因，是没有考虑链表为空的情形。代码如下： /* public class Ra...
创建一个有n个结点的非空单向链表
weixin_53457186的博客
06-08 1639
# include <stdio.h> # include <stdlib.h> //定义结构体 typedef struct node{ int data; //数据域 struct node * next; //指针域 }ElemSN; //将 struct node重命名为 ElemSN //建链表 ElemSN * CreateLink(int a[],int n) { ElemSN *h,*p,*t; //h为头指针 h=NULL; //头指针指向.
tail=(link)malloc(sizeof(node))
lizeyu2011的专栏
04-23 2460
{ link ptr,head,tail;　 　 int num,i; 　 tail=(link)malloc(sizeof(node)); 　 tail->next=NULL; 　 ptr=tail; 　 printf("\nplease input 5 data==>\n"); 　 for(i=0;i 　 { 　　 scanf("%d",&num); 　　 ptr->data
数据结构-单链表的基本操作（C语言详解版）
qq_62100487的博客
05-19 2685
链表，别名链式存储结构或单链表，用于存储逻辑关系为 "一对一" 的数据。与顺序表不同，链表不限制数据的物理存储状态，换句话说，使用链表存储的数据元素，其物理存储位置是随机的。
数据结构—单向链表（详解）
热门推荐
梅山
03-16 1万+
基于C语言的链表基础，包括概念，链表的初始化，插入，删除，查找等操作。
约瑟夫问题解决与数据结构实验——链表实现
在实验中，约瑟夫问题的解决方法采用了单向循环链表的数据结构。单向循环链表由Node结构体定义，包括序号（num）和密码（data）两个字段，以及指向下一个节点的指针（next）。 IniList()函数用于初始化空链表，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

学习C语言之路

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值