单链表 数据结构 C语言

最新推荐文章于 2022-02-05 16:33:44 发布
最新推荐文章于 2022-02-05 16:33:44 发布
阅读量277 收藏 4
点赞数 1
分类专栏： C/C++ 文章标签： 数据结构 单链表 c语言 visual studio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44763868/article/details/107387094
版权

单链表-有头结点

环境：VisualStudio2019
操作：

  • 初始化 + 判断表是否为空
  • 创表（图解）
    – 头插法
    – 尾插法
  • 打印单链表 + 求表长
  • 查找
    – 按位查找
    – 按值查找
  • 插入(图解)
    – 后插（在第i个位置插入元素e）
    – 前插（在第i个结点插入）
  • 删除（图解）
    – 按位删除（删除第i个位置的元素）
    – 按结点删除（删除第i个结点的元素）

头文件

#include<stdio.h>
#include<stdbool.h>

void Cut(); //分割线

//初始化
bool InitList(LinkList* L); //初始化（没用到，包含在创表里了）
bool Empty(LinkList L);//判断表是否为空（没用到）

//创表
LinkList HeadCreate(LinkList* L);
LinkList TailCreate(LinkList* L);
void Show(LinkList L);
int Length(LinkList L);

//查找
LNode* GetElem(LinkList L, int i);
int LocateElem(LinkList L, int e);

//插入
bool InsertNextNode(LNode* p, int e); //被ListAfterInsert调用
bool ListAfterInsert(LinkList* L, int i, int e);
bool InsertFormerNode(LNode* p, int e); //被ListBeforeInsert调用
bool ListBeforeInsert(LinkList* L, int i, int e);

//删除
bool ListOrderDelete(LinkList* L, int i);
bool DeleteNode(LNode* p); //被ListNodeDelete调用
bool ListNodeDelete(LinkList* L, int i);

typedef struct LNode  //单链表节点类型
{
    int data;      //存放数据元素
    struct LNode* next;  //指向下个节点的指针

} LNode, *LinkList;//给LNode两个名字

主函数：

int main(void)
{
	LinkList L;
	int i = 1;
	int e = 1;

	printf("================开始=================\n");

	printf("请输入向链表中插入的值，以999作为结束：\n");
	HeadCreate(&L);                                  //创表：头插法
	printf("链表元素是：");
	Show(L);
	Cut();

	printf("请输入向链表中插入的值，以999作为结束：\n");
	TailCreate(&L);                                  //创表：尾插法
	printf("链表元素是：\n");
	Show(L);
	printf("链表当前长度是：%d",Length(L));
	Cut();
	
	printf("您想查看第几个位置的元素？");
	scanf_s("%d", &i);
	LNode* p = GetElem(L, i);                        //查找：按位查找
	printf("查询结果是：%d", p->data);
	Cut();

	printf("您想查值为几的元素位置？");
	scanf_s("%d", &e);
	int num = LocateElem(L, e);                      //查找：按值查找
	printf("查询结果是：%d", num);
	Cut();

	printf("在第几个位置插入？");
	scanf_s("%d",&i);
	printf("插入值的值是？");
	scanf_s("%d", &e);
	printf("插入结果如下：\n");
	if(ListAfterInsert(&L, i, e))                     //插入：后插
		Show(L);
	else
		printf("插入失败\n");
	Cut();

	printf("在第几个结点插入？");
	scanf_s("%d", &i);
	printf("插入值的值是？");
	scanf_s("%d", &e);
	printf("插入结果如下：\n");
	if (ListBeforeInsert(&L, i, e))                   //插入：前插
		Show(L);
	else
		printf("插入失败\n");
	Cut();
	
	printf("删除第几个位置的元素？");
	scanf_s("%d",&i);
	printf("删除结果如下：\n");
	if(ListOrderDelete(&L, i))                        //删除：按位删除
		Show(L);
	else
		printf("删除失败\n");
	Cut();

	printf("删除第几个结点的元素？");
	scanf_s("%d",&i);
	printf("删除结果如下：\n");
	if(ListNodeDelete(&L,i))                          //删除：指定结点删除
		Show(L);
	else
		printf("删除失败\n");
	Cut();

	getchar();
	return 0;
}

函数：
可爱的分割线

void Cut()
{
    printf("\n=============== 完成 ===================\n");
}

初始化+判断表是否位空

/******************************************************************************/
//初始化：带头结点,头结点不存储数据
bool InitList(LinkList *L)
{
    (*L) = (LNode*)malloc(sizeof(LNode));
    //指向头结点
    if ((*L) == NULL)
        return false;//内存不足，分配失败

    (*L)->next = NULL;//头结点后暂时无其它结点
    return true;
}
/******************************************************************************/
//判断链表是否为空
bool Empty(LinkList L)
{
    if (L->next == NULL)
        return true;
    else
        return false;
}

创表：头插法（思路如图1）

/*----------------------------------------------------------------------------*/

//建表：头插法
LinkList HeadCreate(LinkList* L)
{
    //1，初始化链表
    (*L) = (LNode*)malloc(sizeof(LNode));
    (*L)->next = NULL;
    //2,定义头指针
    LNode* phead = (*L);

    int x;
    scanf_s("%d", &x);
    LNode* s;
    while (x != 999)//当输入为999时，不在增加链表长度
    {
        s = (LNode*)malloc(sizeof(LNode));
        s->data = x;
        s->next = phead->next;
        phead->next = s;
        scanf_s("%d", &x);
    }
    return (*L);
}

思路：
在这里插入图片描述
（图1）

创表：尾插法（思路如图2）

/******************************************************************************/
//建表：尾插法
LinkList TailCreate(LinkList* L)
{
    //1,初始化LocateElem(LinkList L, int e);
    (*L) = (LNode*)malloc(sizeof(LNode));
    (*L)->next = NULL;

    //2,定义尾指针
    LNode* ptail = (*L);

    int x = 1;
    scanf_s("%d", &x);
    LNode* s;
    while (x != 999)//当输入为999时，不在增加链表长度
    {
        s = (LNode*)malloc(sizeof(LNode));
        s->data = x;
        ptail->next = s;
        ptail = s;
        scanf_s("%d", &x);
    }
    ptail->next = NULL;//最后一个元素指向空
    return (*L);          //把链表传回
}

思路：
在这里插入图片描述
（图2）

打印单链表+求表长

/********************************************************************************/
//打印单链表
void Show(LinkList L)
{
    LNode* p = L->next;
    while (p != NULL)
    {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}
/******************************************************************************/
//求链表长度
int Length(LinkList L)
{
    LNode* p = L;
    int length = 0;
    while (p != NULL)
    {
        p = p->next;
        length++;
    }
    return length;//算上了头结点
}

查找：按位查找+按值查找

/*-----------------------------------------------------------------------------*/
//按位查找:找到第i位的元素
LNode* GetElem(LinkList L, int i)
{
    if (i < 1)
        return false;
    LNode* p = L;
    int j = 0;
    while (p != NULL && j < i)
    {//找到第i个结点
        p = p->next;
        j++;
    }
    return p;
}
/******************************************************************************/
//按值查找，找到值位e对应的元素位置
int LocateElem(LinkList L, int e)
{
    LNode* p = L->next; //从第一个结点开始找
    int num = 1;
    while (p != NULL && p->data != e)
    {
        p = p->next;
        num++;
    }

    return num;
}

插入：后插（思路如图3）

/*------------------------------------------------------------------------------*/
//指定结点后插：在p节点后插入元素e
bool InsertNextNode(LNode* p, int e)
{
    if (p == NULL)
        return false;     //i不合法：第i-1个地址不存在
    LNode* s = (LNode*)malloc(sizeof(LNode)); //为新元素申请空间
    if (s == NULL)
        return false;     //内存malloc分配失败
    s->data = e;          //装data
    s->next = p->next;    //指向下一个元素地址
    p->next = s;          //新元素的地址给p
    return true;          //插入成功
}
/******************************************************************************/
//按位序插入:在第i个位置插入指定元素e
bool ListAfterInsert(LinkList* L, int i, int e)
{
    // 1，因为在第i个结点插入，所以需要找到第i-1个结点
    if (i < 1)
        return false; //传入的i不合法
    LNode* p;         //指针p记录当前位置
    p = (*L);            //p刚开始在表头
    int j = 0;        //当前p指向的是第几个结点,初始指向头，理解成第0个结点先
    while (p != NULL && j < i - 1)  //循环找到第i-1个结点
    {
        p = p->next;
        j++;
    }

    //2，插入
    return InsertNextNode(p, e);
}

思路：
在这里插入图片描述
（图3）

插入：前插（思路如图4）

/******************************************************************************/
//指定结点前插：在p节点前插入元素e
bool InsertFormerNode(LNode* p, int e)
{
    LNode* s = (LNode*)malloc(sizeof(LNode));
    if (p == NULL || s == NULL)
        return false;   //i不合法或malloc内存分配失败
    s->next = p->next;
    p->next = s;        //在p后插入空间s
    s->data = p->data;  //前一个位置的值给后一个
    p->data = e;        //相当于前插入元素e
    return true;
}
/******************************************************************************/
//按位序插入:在第i个结点插入e（头结点为第一个结点）
bool ListBeforeInsert(LinkList* L, int i, int e)
{
    // 1，找到第i-1个结点
    if (i <= 1)
        return false; //传入的i不合法
    LNode* p;         //指针p记录当前位置
    p = (*L);            //p刚开始在表头
    int j = 0;        //当前p指向的是第几个结点,初始指向头，理解成第0个结点先
    while (p != NULL && j < i-1)  //循环找到第i-1个结点
    {
        p = p->next;
        j++;
    }

    //2，插入
    return InsertFormerNode(p, e);
}

思路：
在这里插入图片描述
（图4）

删除：按位序删除（思路如图5）

/*-----------------------------------------------------------------------------*/
//按位序删除：删除第i个元素，并且用e返回删除元素的值
bool ListOrderDelete(LinkList* L, int i)
{
    //1,删除第i个元素，所以先找到第i-1个元素，以便断开连接
    if (i < 1)
        return false;
    LNode* p = (*L); //指针p记录当前位置；刚开始指向表头
    int j = 0;
    while (p != NULL && j < i - 1)
    {
        p = p->next;
        j++;
    }

    //2，删除并记录第i个元素
    if (p == NULL)
        return false;   //i不合法
    if (p->next == NULL)
        return false;   //i后无元素可删除
    LNode* q = p->next;
    p->next = q->next;
    int e;
    e = q->data;
    free(q);
    return true;
}

思路：
在这里插入图片描述
（图5）

删除：指定结点删除（思路如图6）

/******************************************************************************/
//指定结点删除：删除p结点的元素
bool DeleteNode(LNode* p)
{
    if (p->next == NULL)
        return false;
    LNode* q = p->next;
    p->data = q->data;
    p->next = q->next;
    free(q);
    return true;
}//bug：p为最后一个节点时，删不了

/******************************************************************************/
//按结点删除：删除第i个结点的元素
bool ListNodeDelete(LinkList* L, int i)
{
    //1,删除第i个元素，所以先找到第i-1个元素，以便断开连接
    if (i < 1)
        return false;
    LNode* p = (*L); //指针p记录当前位置；刚开始指向表头
    int j = 0;
    while (p != NULL && j < i - 1)
    {
        p = p->next;
        j++;
    }

    //2，删除并记录第i个元素
    return DeleteNode(p);
}

思路：
在这里插入图片描述
（图6）

泡不会菜
关注
专栏目录
数据结构单链表c语言实现
03-26
数据结构的单链表C语言版完整实现，本人知识初学者实力浅浅，可能对于大佬来说只是rubb**。如果同样是初学者的话，可能对于你或许有些用处。如果帮助到你很开心，如果你觉得有些low希望可以提出宝贵的建议 ！！
数据结构与算法c语言链表,C+数据结构与算法之链表之单链表
weixin_39775428的博客
05-24 386
1.单链表定义每个节点包括一个数据域一个指针域，节点在内存中地址可以不连续，但是节点内部地址必然连续。2.结构定义typedef struct Lnode{int data;struct Lnode *next;}Lnode,*LinkList;3.单链表的创建1)头插法//头插法建立带头结点的单链表LinkList create1(LinkList &L){Lnode *s;int x;...
链表基本操作记录
m0_46200758的博客
08-21 135
链表基本操作记录 单链表的基本操作 #include<stdio.h> #include<stdlib.h> typedef struct LNode{ int data; struct LNode *next; }LNode,*LinkList; int InitList(LinkList &L){ //创建空链表 L =new LNode; L->next=NULL; return 1; } int
单链表
shuangyan5230的专栏
12-18 262
<br />#include<stdio.h> #include<stdlib.h> #define ElemType char struct LNode{ ElemType data; LNode *next; }; typedef LNode *LinkList; void output(LinkList &L); int locateElemPosition(LinkList &L,int i,LinkList &p); void createFromHead(Lin
C语言中的GetElem函数,数据结构中像GetElem(L,i,&e)操作在C语言怎么实现实现？
weixin_33957458的博客
05-20 3448
满意答案lsdiddemj60推荐于 2017.09.28/*GetElem(L,i,&e)用E返回L中第i个数据的值*/#define NULL 0#includestruct student{int num;struct student *next;}main(){struct student *InitList(void);int GetElem(struct student *he...
对单链表的基本操作
kk的博客
09-04 550
准备工作（定义类型，定义存储结构） #include<iostream> using namespace std; typedef int ElemType; typedef bool Status; #define OK true #define ERROR false typedef struct LNode{ ElemType data; struct LNode *...
数据结构-C语言实现单链表-数据结构学习
05-26
C语言实现的数据结构中的单链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习，熟练对链表边界的判定 实现了以下功能： 创建单链表 向顺序表中插入元素(头插法，尾插...
数据结构单链表实验（C语言）
01-08
单链表的接本操作，有在单链表中插入，删除数据的功能，以及...1．单链表的数据结构的建立实现。 2．单链表元素结点插入操作实现。 3．单链表元素结点删除操作实现。 4．实现单链表的合并。 5．实现一元多项式的相加。
单链表（数据结构C语言版）
07-05
单链表（数据结构C语言版） 链表的创建，插入，删除，排序等操作并建立有菜单，可以选择操作
数据结构单链表（C语言）
03-27
通过c语言实现单链表的建立、初始化、尾插法插入结点、头插法插入结点、数据的查找、删除、在指定位置插入结点、在指定位置删除结点、打印输出数据、统计单链表的长度等功能。
各种数据结构的存储结构描述
computer vision, sixth sense, robot, AI
09-01 864
1.线性表的顺序存储结构
LinkList的具体实现
weixin_42349313的博客
09-27 2971
LinkList #include&lt;cstdlib&gt; #include&lt;iostream&gt; using namespace std; #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define...
【链表】单链表的基本操作详解(C语言)
热门推荐
HongKnight的博客
06-01 4万+
本文是单链表的C语言实现方法，包括创建单链表结点、创建单链表、显示链表的数据、获取链表长度、在链表指定位置插入结点、删除指定位置的结点、查找链表中指定的数据、修改链表中指定位置结点的值、修改链表中指定数据的值。
C语言指针详解----函数参数与指针
学如不及,犹恐失之
10-22 646
灵活的使用指针可以让函数传参更加方便，首先讲一下值传递的问题。在C语言的函数中，存在形参和实参两种参数。形参即形式参数，是在函数声明或者实现时使用的参数；而实参，即实际参数，是在函数调用的时候使用的参数。下面举个例子说明： void fun(int x,int y){//x、y为形参 x = y; y = y + 1; } int a = 2; int b...
数据结构（03）——单链表
08-20 570
单链表概念 链表的节点均单向指向下一个节点，形成一条单向访问的数据链。 单链表的初始化 typedef struct _LinkNode { int data; //结点的数据域 struct _LinkNode *next; //结点的指针域 }LinkNode, LinkList; //链表节点、链表 bool InitList(LinkList* &L)//...
c 单链表
HJ_show的专栏
06-29 353
#include #include #include #include using namespace std; struct LNode { int value; struct LNode *pNext; }; typedef struct LNode Node; typedef Node* Linklist; int AddToTail(Node **head,int val
C语言---单链表(详解)---数据结构
weixin_57535054的博客
02-05 3333
单链表所需要的头文件 重命名类型的意义在于以后还需要用到单链表时，存入的类型不一定时int类型，需要更改类型时，要一个个更改，非常麻烦，我们可以直接在这里修改，更加方便(这里的解释我上一篇也有提到) 单链表用到的结构体 这里我们把结构体重命名为ST 单链表需要实现的功能有 1.申请一个新节点的内存空间 2.单链表的头部，尾部的插入和删除 3.单链表的查找 4.单链表查找后的插入和删除 5.单链表的打印 6.单链表的释放 1.单链表的节点申请内存空间 申请内存空间并不是直接使用，.
数据结构自定义单链表数据，C语言
最新发布
10-14
在C语言中，自定义单链表是一种常见的数据结构，它由节点组成，每个节点包含两个部分：一个是存储数据的数据域（通常是`data`），另一个是指向下一个节点的指针（通常是`next`）。下面是一个简单的单链表结构体定义...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值