数据结构01----C语言单向链表

最新推荐文章于 2022-08-21 12:40:14 发布
最新推荐文章于 2022-08-21 12:40:14 发布
阅读量317 收藏 2
点赞数
分类专栏： 数据结构 文章标签： 链表 算法 数据结构 栈 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LH_SMD/article/details/108112739
版权

下面的叙述如果有什么错误，还请批评指正，谢谢。

一、数据结构与算法简介

1.什么是数据结构？
简单的说法，就是数据以及数据之间存在的关系
数据之间的关系分为：逻辑关系和物理关系（逻辑结构和物理结构）

逻辑关系：即人为赋予的关系：
一对一：线性表  栈  队列
一对多：树
多对多：图

物理关系：数据在计算机中的实际存储。
这就告诉我们，在选择数据的存储结构的时候，需要我们理清楚数据之间结构，从而选择一个合适的物理结构。

2.数据结构与算法
有这么一个式子，相信大家不会陌生：

							程序=结构+算法

数据结构上面已经介绍过，那么什么是算法呢？
所谓的算法就是要完成一个任务具体的实现步骤，那么这个步骤肯定是有优劣之分的，一个好的算法，步骤少，效率高，这也是作为程序员一直追求的东西。这里就引出了两个概念：时间复杂度和空间复杂度，一个算法的好坏就是由这两个复杂度来衡量的。

时间复杂度：大O估算法 O（频度）
i+=1; O(1)
for(i=0;i<n;i++) {} O(n)
for(i=0;i<n;i++){for(j=0;j<n;j++){}} O(n^2)
这个是不是一看就明白了如何计算时间复杂度？

空间复杂度
是对一个算法在运行过程中临时占用存储空间大小的量度。一般情况下，时间复杂度与空间复杂度不可兼得：减少时间复杂度，就势必会导致空间复杂度的增大，反过来，想要减少空间复杂度，就肯定会导致时间复杂度的增大。这就需要我们根据实际需要来做合理取舍了。

好，有关数据结构和算法的概念，就说这么多 ，下面我们的重点，放在数据的存储结构上，注意，需要学习的是他的思想，而非代码，所以重在理解！！！

二、四大逻辑结构

1.集合结构：所有元素在同一个集合上，他们之间没啥关系，这里不做过多的介绍 ；

2.线性结构：一对一的关系：如链表、栈、队列，这里使我们掌握的重点；

3.树形结构：一对多的关系，我们主要学习二叉树；

4.图形结构：多对多的关系，这个在这里也不做过多的叙述。

三、链表

链表属于线性表，线性表的存储分为顺序存储和链式存储，我们接下来要讲的链表，属于链式存储，具体的关系，如下图所示：
在这里插入图片描述
这里需要特别注意的是，我们学习单链表和双向不循环链表都是为了学习双向循环链表，在今后的工作学习中，大多数用的都是双向循环链表。下面的介绍，我们就按照单向不循环->单向循环->双向不循环->双向循环，这样循序渐进的方式来讲述。注意，对于数据结构，我们更重要的是理解，而不只是盯着代码不放，切记！

1.单向不循环链表
他的结构示意图如下：
（忽略其中的错别字，嘿嘿）
在这里插入图片描述
链表，分为指针域和数据域，二者构成一个节点（对应上面一个方框），为了方便理解，如上图，我们把方框的上面部分叫做“数据域”，下面部分看成“指针域”（当然，这个上面下面的顺序无所谓），对于单向链表来说，每个节点的指针（next）都指向下一个节点的地址，最后一个节点的next，指向的是NULL（不循环链表）或者头节点（循环链表）。其中，头结点只是为了方便数据的索引而存在，他的数据域不存放有效数据，有时候为了方便，我们会在头结点的数据域里面存放链表节点的个数（链表的大小）。从首元节点开始，存放有效数据的第一个元素。在C语言中，我们可以这样来表示一个节点：

struct Node
{
	int m_Data;
	struct Node *next;
};
typedef struct Node node_t;

当然，数据域不仅仅可以是单一的数据类型，也可以是多个数据类型，还可以是一个结构体，所以，还可以这样：

struct Data
{
	char 	m_Name[20];
	int 	m_Age;
	double 	m_score;
};
typedef struct Data data_t;

struct Node 
{
	data_t 		m_Data;
	struct Node *next;
};
typedef struct Node node_t;

这个不管怎么样，只要符合上面的规则，都是可以的，这里只是举了两个例子。

学了数据结构的朋友都知道，对链表的操作，无非就是增删改查。

下面我们来看看操作步骤：

  • 1.确定单向链表节点；
  • 2.初始化链表；
  • 3.插入某个数据到某个位置；
  • 4.打印链表；
  • 5.删除某个位置的数据；
  • 6.查询某个数据在节点中的位置
  • 7.更改某个数据为新的数据

在这里插入图片描述

对照上面的视图，理解一下下面的C语言代码：

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

#define SYSERR(x,option,y,a,k) if((x)option(y))\
{\
    printf("%s:%s:%d:%s\n",__FILE__,__func__,__LINE__,a);\
    return (k);\
}

struct Node
{
    int data;
    int list_length;
    struct Node *next;
};

typedef struct Node node_t;

/*
 *链表初始化
 *参数：void
 *返回值：初始化后的链表头结点
 */
node_t* listInit(void)
{
    node_t* head = (node_t *)malloc(sizeof(node_t));
    SYSERR(head,==,NULL,"[malloc err]",(node_t *)-1); /* 判断是否空间申请失败 */
    head->next        = NULL;
    head->list_length = 0;
    return head;
}

/*
 *头插
 *参数：head：要插入的链表   dat：要插入的数据
 *返回值：返回头插后的链表头结点
 */
node_t* insertHead(node_t* head,int dat)
{
    SYSERR(head,==,NULL,"[list is empty]",NULL);
    node_t* temp = (node_t *)malloc(sizeof(node_t));
    SYSERR(temp,==,NULL,"[malloc err]",NULL);
    temp->data = dat;
    temp->next = head->next;
    head->next = temp;
    head->list_length++;
    return head;
}

/*
 *尾插
 *参数：head：要插入的链表   dat：要插入的数据
 *返回值：返回尾插后的链表头结点
 */
node_t* insertTail(node_t* head,int dat)
{
    SYSERR(head,==,NULL,"[list is empty]",NULL);
    node_t* temp = (node_t *)malloc(sizeof(node_t));
    SYSERR(temp,==,NULL,"[malloc err]",NULL);
    node_t* temp1 = (node_t *)malloc(sizeof(node_t));
    SYSERR(temp1,==,NULL,"[malloc err]",NULL);
    temp = head;
    for(;temp->next != NULL; temp = temp->next);
    temp1->data = dat;
    temp1->next = NULL;
    temp->next = temp1;
    head->list_length++;
    return head;
}

/*
 *打印链表
 *参数：head：要打印的链表 
 *返回值：void
 */
int displayList(node_t* head)
{
    SYSERR(head,==,NULL,"[list is empty]",-1);
    node_t* temp = head->next;
    for(;temp != NULL; temp = temp->next)
    {
        printf("-> %d ",temp->data);
    }
    putchar(10);
    return 0;
}

/*
 *删除节点
 *参数：head：要删除节点的链表  dat：要删除的数据 
 *返回值：删除节点后的链表首节点
 */
node_t* deleteNode(node_t* head,int dat)
{
    int num = 0,i = 0,flag = 0;
    SYSERR(head,==,NULL,"[list is empty]",NULL);
    node_t* temp = head->next;
    for(; temp != NULL; temp = temp->next)
    {
        num++;
        if(temp->data == dat)
        {
            flag++;
            break;
        }
        if(flag != 1 && num == head->list_length) {printf("list has not %d\n",dat);return head;}
    }
    node_t* node = head->next;
    node_t* q = node;
    if(num == 1) /* 第一个 */
    {
        head->next = node->next;
        head->list_length--;
        free(q);
    }
    else
    {
        for(i = 0; i < num-2; i++)
        {
            node = node->next;
        }
        node_t* p = node->next;
        node->next = node->next->next;
        head->list_length--;
        free(p);
    }
    return head;
}

int main(void)
{
    node_t* head = listInit();
#if 1
    head = insertHead(head,2);
    head = insertHead(head,5);
    head = insertHead(head,6);
    head = insertHead(head,7);
    head = insertHead(head,53);
    head = insertHead(head,34);
    printf("头插后：");
    (void)displayList(head);
    printf("链表长度为：%d\n\n",head->list_length);
#endif

#if 1
    head = insertTail(head,78);
    head = insertTail(head,23);
    head = insertTail(head,100);
    head = insertTail(head,75);
    head = insertTail(head,37);
    head = insertTail(head,29);
    printf("尾插后：");
    (void)displayList(head);
    printf("链表长度为：%d\n\n",head->list_length);
#endif

#if 1
    head = deleteNode(head,7);
    printf("删除一个节点后：");
    (void)displayList(head);
    printf("链表长度为：%d\n\n",head->list_length);
#endif
    return 0;
}

代码运行结果如下：
在这里插入图片描述
上面例程中，只有初始化、头插、尾插、删除某个节点，只要弄懂这些，剩下的修改查询都是很简单的，这里就不写了。接下来的例程中同样只有这几个部分。这里就一并说明了。

2.单向循环链表
和上面的不循环链表类似，他的模型如下：

在这里插入图片描述
区别就在于最后一个节点的next指向的是头结点而已。那么对于他的操作也是一样的：

  • 1.确定单向链表节点；
  • 2.初始化链表；
  • 3.插入某个数据到某个位置；
  • 4.打印链表；
  • 5.删除某个位置的数据；
  • 6.查询某个数据在节点中的位置
  • 7.更改某个数据为新的数据

注意下面程序上的细微差别：

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

#define SYSERR(x,option,y,b,k) if((x)option(y))\
{\
    printf("%s:%s:%d:%s\n",__FILE__,__func__,__LINE__,b);\
    return (k);\
}

struct Node
{
    int data;
    int list_length;
    struct Node *next;
};

typedef struct Node node_t;

/*
 *链表初始化
 *参数：void
 *返回值：初始化后的链表头结点
 */
node_t* listInit(void)
{
    node_t* head = (node_t *)malloc(sizeof(node_t));
    SYSERR(head,==,NULL,"[malloc err]",(node_t *)-1); /* 判断是否空间申请失败 */
    head->next        = head;  /* 自己指向自己 */
    head->list_length = 0;
    return head;
}

/*
 *头插
 *参数：head：要插入的链表   dat：要插入的数据
 *返回值：返回头插后的链表头结点
 */
node_t* insertHead(node_t* head,int dat)
{
    SYSERR(head,==,NULL,"[list is empty]",NULL);
    node_t* temp = (node_t *)malloc(sizeof(node_t));
    SYSERR(temp,==,NULL,"[malloc err]",NULL);
    temp->data = dat;
    temp->next = head->next;
    head->next = temp;
    head->list_length++;
    return head;
}

/*
 *尾插
 *参数：head：要插入的链表   dat：要插入的数据
 *返回值：返回尾插后的链表头结点
 */
node_t* insertTail(node_t* head,int dat)
{
    SYSERR(head,==,NULL,"[list is empty]",NULL);
    node_t* temp = (node_t *)malloc(sizeof(node_t));
    SYSERR(temp,==,NULL,"[malloc err]",NULL);
    node_t* temp1 = (node_t *)malloc(sizeof(node_t));
    SYSERR(temp1,==,NULL,"[malloc err]",NULL);
    temp = head->next;
    for(;temp->next != head; temp = temp->next);
    temp1->data = dat;
    temp1->next = head;
    temp->next = temp1;
    head->list_length++;
    return head;
}

/*
 *打印链表
 *参数：head：要打印的链表 
 *返回值：void
 */
int displayList(node_t* head)
{
    SYSERR(head,==,NULL,"[list is empty]",-1);
    node_t* temp = head->next;
    for(;temp != head; temp = temp->next)
    {
        printf("-> %d ",temp->data);
    }
    putchar(10);
    return 0;
}

/*
 *删除节点
 *参数：head：要删除节点的链表  dat：要删除的数据 
 *返回值：删除节点后的链表首节点
 */
node_t* deleteNode(node_t* head,int dat)
{
    int num = 0,i = 0,flag = 0;
    SYSERR(head,==,NULL,"[list is empty]",NULL);
    node_t* temp = head->next;
    for(; temp != head; temp = temp->next)
    {
        num++;
        if(temp->data == dat)
        {
            flag = 1;
            break;
        }
        if(flag != 1 && num == head->list_length){printf("list has not %d\n",dat);return head;}
    }
    node_t* node = head->next;
    node_t* q = node;
    if(num == 1)
    {
        head->next = node->next;
        head->list_length--;
        free(q);
    }
    else
    {
        for(i = 0; i < num-2; i++)
        {
            node = node->next;
        }
        node_t* p = node->next;
        node->next = node->next->next;
        head->list_length--;
        free(p);
    }
    return head;
}

int main(void)
{ 
    node_t* head = listInit();
#if 1
    head = insertHead(head,2);
    head = insertHead(head,5);
    head = insertHead(head,6);
    head = insertHead(head,7);
    head = insertHead(head,53);
    head = insertHead(head,34);
    printf("头插后：");
    (void)displayList(head);
    printf("链表长度为：%d\n\n",head->list_length);
#endif

#if 1
    head = insertTail(head,78);
    head = insertTail(head,23);
    head = insertTail(head,100);
    head = insertTail(head,75);
    head = insertTail(head,37);
    head = insertTail(head,29);
    printf("尾插后：");
    (void)displayList(head);
    printf("链表长度为：%d\n\n",head->list_length);
#endif

#if 1
    head = deleteNode(head,53);
    printf("删除一个节点后：");
    (void)displayList(head);
    printf("链表长度为：%d\n\n",head->list_length);
#endif
    return 0;
}

在这里插入图片描述

运行结从上面两个链表来看，无论是循环还是不循环的，都存在着以下的问题：
**只能是一个方向遍历，也就是说，只能找到后继，无法找到前驱。这给数据的操作带来一定的复杂度。**有关前驱和后继，如下图：
在这里插入图片描述
双链表请看：
数据结构02----C语言双向链表
栈：
数据结构03----C语言栈
队列：
数据结构04----队列

all of the time
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C语言初阶-(单向链表)
03-08
包含单向链表的插入，删除，遍历 含有前插法，尾插法等链表操作 适用于数据结构初学者使用 线性表的单链表存储结构，整个链表的存取必须从头指针开始进行，头指针指示链表中第一个结点 (第一个数据元素的存储映像，...
SYSERR - generalized error handling (CICS)
xxx
10-14 1660
01  ERR-PARM.       05  ERR-RESP         PIC S9(8) COMP.       05  ERR-RESP2        PIC S9(8) COMP.       05  ERR-TRAID        PIC X(4).
单向链表——C语言
Ctrl_C_V_is_easy的博客
08-21 1450
链表相较于顺序表来说有很多优点，尤其是表中间插入和表头插入操作更简单，时间复杂度更低，而且空间利用率更高。单链表从表头开始，每个节点之间用指针来链接，最后一个节点的指针指向NULL，所以链表所用的计算机内存不一定是连续的，而每个节点都由数据域和指针域构成。
C语言（单向链表详细讲解）
qq_48240706的博客
07-16 2047
对链表的基本操作有：创建，查找，插入，删除，修改，也就是我们常常说的增删改查 建立带有头结点的单向链表 建立链表就是根据需要一个一个的开辟新结点，在结点中存放数据，并建立结点之间的链接关系，建立单向链表有两个关键的问题： 第一、结点的存储空间必须是由程序来动态分配的 第二、结点之间必须形成链状 建立单向链表的主要操作步骤如下： 读取数据 生成新节点 将数据存入节点的成员变量中 将新结点添加到链表中 重复上述操作直至输入结束 我们用一段代码来说明：建立一个学生电话簿的单向链表 ..
数据结构[单链表]操作大全（初始化，创建，插入，查询，删除，长度，输出）c++代码实现
xxxxxiao123的博客
03-01 1907
今晚上干了许久的链表 看见指针就头大的我真的是头皮发麻了一晚上 代码中写有注释，虽然不是太详细，但是了指针熟练的同学应该可以看懂 main函数中请自由发挥 #pragma GCC optimize(3,"Ofast","inline") #include <iostream> #include <cstdio> #include <cstring> #inclu...
C语言单向链表的基本操作
ziguo2010的博客
06-27 7458
    掌握结构体，指针后，链表作为两种形式的集合，将C语言的作用发挥到巨大。链表知识123链表是线性表，包括两个部分：数据域&amp;指针域数据域：存储需要保存的数据指针域：各个节点之间的连接连续性：链表在逻辑上是连续的，但物理上未必连续链表主要有单向链表，双向链表，循环链表链表操作：对于链表的操作一般包括增加，删除，修改，查找下面对单向链表进行举例操作：操作环境：keil v4，串口软件，有硬...
单向链表结点的逐个删除-C语言教程
07-26
每敲一次代码都会有新的收获，基本功不扎实啥也干不了。单向链表的插入，删除，创建，遍历是数据结构的基本操作。里边的算法值得学习。下面我们就来学习一下单向链表结点的逐个删除的方法。
数据结构-链表的实现代码（C语言版）.rar
10-27
数据结构 -- C语言版 -- 链表的部分实现代码（单向链表、双向链表、循环链表、约瑟夫环等），详细介绍参考数据结构--链表的系列博文。链接为：https://blog.csdn.net/songshuai0223/category_9742561.html。
第11章 动态数据结构-链表-21
08-03
第11章 动态数据结构的C语言实现单向链表-2int power;struct node *next;建立一个单向链表1 创建节点：2 链：使每个节点的指针域存
数据结构---线性表之单链表（C语言）
03-28
数据结构---线性表之单链表，包括单链表的创建、插入、删除等，C语言编写
C语言链表(单向链表)
weixin_44731121的博客
04-30 1238
C语言实现链表 首先我们要了解链表，链表跟数组不同的是非连续存储结构，也就是说实现链表需要一个指针，每用完一个节点指针指向下一个节点,直至表尾。 什么场合使用链表呢？比如说我们要做一个学生信息表，既然是学生信息里面就一定会有学号(int),姓名(char),成绩(float)，如果我们用动态数组来做的话至少一个结构体要70个字节左右吧？ 这样只能存放少数,比如一个班级左右的量，如果我们要存放全...
c语言单向链表
欢迎来到梨+萍的博客，不准备看点啥学习嘛。。。
08-08 1830
简单c语言实现单向链表！
【C语言】链表及单链表基本操作
热门推荐
swag_wg的博客
04-29 12万+
1、什么是链表？链表的分类？ 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 数据结构中： 2、链表的分类 共有8种链表结构 ...
单链表的输入和输出（c语言编写）
半岛落枫的博客
09-26 2万+
#include #include struct link2 {     int data;     struct link2 *next; }*head; void creat(); void Ouput(); int main() {                 creat();             Ouput();             return
C语言单向链表的实现
无界编程
10-30 5万+
一个简单结点的结构体表示为：    struct note    {       int  data；              /*数据成员可以是多个不同类型的数据*/       struct  note  *next；      /*指针变量成员只能是-个*/    }；  一个简单的单向链表的图示 1．链表是结构、指针相结合的-种应用,它是由头、中间、尾多个链环组成的单方向可伸缩的链表,链
数据结构：单链表的C语言实现
Kevin的博客
07-15 1127
链式存储 原理： 链表存储是在程序运行过程中动态的分配空间，只要存储器还有空间，就不会发生存储溢出问题。 优点： 插入和删除速度快，保留原有的物理顺序，插入或者删除一个元素时，只需要改变指针指向即可。 缺点： 查找速度慢，每次查找都要遍历链表。 #include <stdio.h> #include <stdlib.h> typedef int LinkType; //数据...
C语言：数据结构--单向链表详解
weixin_44498318的博客
05-02 2587
单向链表 （1）单向链表的基本了解 先是定义一个单向链表的节点结构体： typedef struct Node{ int data; struct Node *pNext; }NODE, *PNODE; 那么整个结构体可以抽象成下图： 其中，一个空链表就只有一个头节点（在本篇文章中头节点用于数据的存储，只用于作为索引，当然，你也可以将它和普通节点一样存放数据等）： 而n个节点的链表如下（这里n=3）： （2）增删改查 ① 增——在尾部增加节点 ② 增——在中间插入一个节点 ③
数据结构|创建学生成绩的单链表（实验2.2）
记录软件测试过程中遇到的问题
10-10 1577
一、实验目的 巩固线性表的数据结构的存储方法和相关操作，学会针对具体应用，使用线性表的相关知识来解决具体问题。 二、实验内容 建立一个由n个学生成绩的顺序表，n的大小由自己确定，每一个学生的成绩信息由自己确定，实现数据的对表进行插入、删除、查找等操作。分别输出结果。
C语言之单向链表
12-31 94
1，单向链简洁。 单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的；其中每个结点都有指针成员变...
c语言数据结构单向链表使用malloc分配空间
最新发布
01-28
下面是一个示例，演示了如何使用malloc函数来分配空间并创建一个单向链表： ```c #include #include // 定义链表节点结构体 typedef struct Node { int data; struct Node* next; } Node; // 创建链表节点 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

all of the time

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

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

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

打赏作者

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

抵扣说明：

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

余额充值