数据结构之C语言实现单链表

已于 2023-12-27 16:23:22 修改
阅读量1.5k 收藏 17
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 c语言 c++
于 2022-05-13 15:53:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45074341/article/details/124753529
版权

数据结构之C语言实现单链表

定义

什么是单链表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QwWuWTPk-1652428304786)(https://secure2.wostatic.cn/static/daqpKL7WpQHTCSjLmooNZG/image.png)]

  • 优点：不要求大片不连续空间，改变容量方便
  • 缺点：不可随机存取，要耗费一定空间存放指针

用代码定义一个单链表

struct LNode{
  ElementType data;
  struct LNode *next;
}


struct LNode* p=(struct LNode*)malloc(sizeof(struct LNode));

要表示一个单链表时，只需声明一个头指针L，指向单链表的第一个节点

typedef使用

// typedef 关键字--数据类型重命名
typedef <数据类型> <别名>
typedef int zhengshu;
typedef int *zhengshuzhizhen;
type struct LNode LNode;
LNode *p=(LNode*)malloc(sizeof(LNode));


typedef stuct LNode{    //定义单链表结点类型
  ElemType data;        //每个结点存放一个数据元素
  struct LNode *next;   //指针指向下一个节点
}LNode,*LinkList;

struct LNode{
  ElemType data;
  struct LNode *next;
};
typedef struct LNode LNode;
typedef struct LNode *LinkList;


/**
 * LNode *强调这是返回一个结点指针
 * LinkList 强调这是一个单链表
 */
LNode *GetElem(LinkList l,int i){
  int j=1;
  LNode *p=l->next;
  if(i==0){
    return l;
  }
  if(i<1){
    return NULL;
  }
  where(p!=NULL&&j<i){
    p=p->next;
    j++;
  }
  return p;
}

不带头节点

typedef struct LNode{
  ElemType data;
  struct LNode *next;
}LNode,*LinkList;

//初始化一个空的单链表
bool initList(LinkList &l){
  //空表，暂时还没有任何结点，防止脏数据
  l=NULL;
  return true;
}
//判断单链表是否为空
bool Empty(LinkList l){
  return l==NULL;
}

带头结点

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;
//初始化一个单链表(带头结点)
bool initList(LinkList &L){
  L=(LNode*)malloc(sizeof(LNode));
  if(L==NULL){
    return false;
  }
  L->next=NULL;
  return true;
}
//判断单链表是否为空
bool Empty(LinkList L){
  return L->next==NULL;
}

基本操作的实现

插入删除操作

  1. 插入
    1. 按位序插入
      1. 带头结点
      2. 不带头节点
    2. 指定节点的后插操作
    3. 指定节点的前插操作
  2. 删除
    1. 按位序删除
    2. 指定节点的删除
/**
 * LNode *强调这是返回一个结点指针
 * LinkList 强调这是一个单链表
 * @author five-five
 * @created 2022/5/9
 *
 */
#include "stdlib.h"
#include "stdio.h"
#include "stdbool.h"

typedef struct LNode {
    int data;
    struct LNode *next;
} *LinkList, LNode;

/**
 * 初始化单链链表
 * @param linkList 链表指针
 * @return 0:初始失败?初始成功
 */
bool initList(LinkList *linkList) {
    *linkList = (LinkList) malloc(sizeof(LNode));
    if (NULL == *linkList) {
        return false;
    }
    (*linkList)->data = 0;
    (*linkList)->next = NULL;
    return true;
}

/**
 *
 * @param linkList 单链链表
 * @return 0:初始失败?初始成功
 */
bool empty(LinkList linkList) {
    return linkList == NULL;
}

/**
 * 按照顺序插入
 * @param linkList 单链链表
 * @param i 插入的位置
 * @param e 元素值
 * @return
 */
bool listInsert(LinkList linkList, int i, int e) {
    //下标不合法，默认不允许插入到第一位
    if (i < 1) {
        return false;
    }
    LNode *cur = NULL;
    cur = linkList;
    int curIndex = 0;
    //把下标以后的结点都后移一个，并且将目标指针的上个指征保留下来，i-1即可
    while (cur != NULL && curIndex < i - 1) {
        cur = cur->next;
        curIndex++;
    }
    //判断当前结点是否有效，下标可能指向了空结点，看上面的while循环
    if (NULL == cur) {
        return false;
    }
    //创建结点，赋值插入
    LNode *targetNode = (LNode *) malloc(sizeof(LNode));
    //内存失败
    if (NULL == targetNode) {
        return false;
    }
    targetNode->data = e;
    //插入，目标结点的一些指针为当前结点的下一节点,当前结点的下一指针为目标结点
    targetNode->next = cur->next;
    cur->next = targetNode;
    return true;
}

/**
 * 后插操作：在p结点之后插入元素e
 * @param p 要参考的指针 
 * @param e 元素
 * @return true?成功:失败
 */
bool insertNextNode(LNode *p, int e) {
    if (NULL == p) {
        return false;
    }
    //创建指针,分配空间
    LNode *targetNode = (LNode *) malloc(sizeof(LNode));
    if (NULL == targetNode) {
        return false;
    }
    targetNode->data = e;
    targetNode->next = p->next;
    p->next = targetNode;
    return true;
}

/**
 * 前插操作：在p前插入一个节点
 * 重点: 修改两个结点元素值
 * @param p 目标结点
 * @param e 要插入结点
 * @return true?成功:失败
 */
bool insertPriorNode(LNode *p, int e) {
    if (NULL == p) {
        return false;
    }
    //创建指针,分配空间
    LNode *targetNode = (LNode *) malloc(sizeof(LNode));
    if (NULL == targetNode) {
        return false;
    }
    targetNode->next = p->next;
    p->next = targetNode;
    //修改元素值
    targetNode->data = p->data;
    p->data = e;
    return true;
}
/**
 * 按位序删除结点
 * @param linkList 单链链表
 * @param i 下标
 * @param e 接收删除元素值得指针
 * @return true?成功:失败
 */
bool listDelete(LinkList linkList, int i, int *e) {
    //不可删除头结点
    if (i < 1) {
        return false;
    }
    LNode *cur = NULL;
    cur = linkList;
    int curIndex = 0;
    while (NULL != cur && curIndex < i - 1) {
        cur = cur->next;
        curIndex++;
    }
    if (NULL == cur) {
        return false;
    }
    LNode *targetLNode = cur->next;
    //返回值赋值
    *e = targetLNode->data;
    //跳过结点
    cur->next = targetLNode->next;
    //释放内存
    free(targetLNode);
    return true;
}

/**
 * 删除指定结点
 * bug：删除最后节点时，有问题
 * @param p 要删除结点
 * @return true?成功:失败
 */
bool deleteNode(LNode *p) {
    if (NULL == p) {
        return false;
    }
    LNode *nextNode = p->next;
    if (NULL!=nextNode) {
        p->data = nextNode->data;
        p->next = nextNode->next;
        //释放内存
        free(nextNode);
    } else {
        p = NULL;
    }
    return true;
}

/**
 *
 * @return 0为程序运行成功，1为运行不成功
 */
int main() {
    LinkList linkList = NULL;
    initList(linkList);
    printf("%llu\n", sizeof(*linkList));
    printf("%llu\n", sizeof(*(linkList->next)));
    return 0;
}

查找操作

  1. 按位查找

  2. 按值查找

  3. 求单链表长度

  4. 三种基本操作的时间复杂度都是O_(n)

  5. 如何写循环扫描各个节点的代码逻辑

  6. 注意边界条件处理

/**
 * 按位查找
 * @param linkList 单链链表
 * @param i 下标
 * @return 返回结点指针
 */
LNode *getElem(LinkList linkList, int i) {
    LNode *node = NULL;
    if (NULL == linkList) {
        return node;
    }
    node = linkList;
    while (node != NULL && i > 0) {
        node = node->next;
        i--;
    }
    return node;
}

/**
 * 按值查找
 * @param linkList 单链链表
 * @param e 要查询的值
 * @return 返回结点指针
 */
LNode *locateElem(LinkList linkList, int e) {
    LNode *node = NULL;
    node = linkList;
    while (node != NULL) {
        if (node->data == e) {
            return node;
        }
        node = node->next;
    }
    return node;
}

/**
 * 返回链表的长度
 * @param linkList 单链链表
 * @return 链表的长度
 */
int length(LinkList linkList) {
    int length = 0;
    LNode *node = linkList;
    //有next才加1(初始化头结点不算入进来)
    while (node->next != NULL) {
        node = node->next;
        length++;
    }
    return length;
}

单链表的建立

步骤：

  1. 初始化一个单链表
  2. 每次取一个数据元素，插入到表尾或表头
/**
 * 正向创建单链表(尾插法)
 * @param linkList 单链表(指针的指针)
 * @param data 头结点的data
 * @return
 */
LinkList listTailInsert(LinkList *linkList, int data) {
    int x;
    *linkList = (LinkList) malloc(sizeof(LNode));
    (*linkList)->data = data;
    (*linkList)->next = NULL;
    LNode *s = NULL;
    LNode *r = *linkList;
    //下列写法s不会赋值
    //LNode *s,*r = *linkList;
    scanf("%d", &x);
    while (x != -1) {
        s = (LinkList) malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        r = s;
        scanf("%d", &x);
    }
    r->next = NULL;
    return *linkList;
}

/**
 * 头插法创建单链表
 * @param linkList 单链表(指针的指针)
 * @param data 头结点的data
 * @return
 */
LinkList listHeadInsert(LinkList *linkList, int data) {
    int x = 0;
    *linkList = (LinkList) malloc(sizeof(LNode));
    (*linkList)->data = data;
    (*linkList)->next = NULL;
    LNode *s;
    scanf("%d", &x);
    while (x != -1) {
        s = (LinkList) malloc(sizeof(LNode));
        s->data = x;
        s->next = (*linkList)->next;
        (*linkList)->next = s;
        scanf("%d", &x);
    }
    return *linkList;
}

头插法，尾插法：核心就是初始化操作、指定节点的后插操作

tips：尾插法注意设置一个尾指针tip

five-five
关注
  • 1
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
单链表(C语言)
09-29
C语言的单链表，有存储、查询、删除等功能，代码简单，有注释。适合初学者
C语言一个单链表的实现
04-25 87
-- 所谓链表记住一句即可：地址不连续，大家只是握个手而已； list0.c #include<stdio.h> #include<malloc.h> typedef int Item;//定义数据项类型 typedef struct node * PNode;//定义节点指针 //节点的定义 typedef str...
数据结构链表（单链表、顺序表）的C语言代码以及实现
最新发布
changan277的博客
03-06 456
使用C语言实现数据结构中单链表和顺序表相关代码
C语言实现单链表
ljx_5489464的博客
03-15 2019
1、用于存放声明的头文件#define _CRT_SECURE_NO_WARNINGS #pragma once #include <stdio.h> #include <assert.h> #include <malloc.h>typedef int DataType;typedef struct SListNode { DataType data;
数据结构——单链表（C语言实现）
weixin_57154303的博客
08-23 3707
单链表的基本操作有 初始化，头插，尾插，按位置插，头删，尾删，按位置删，查找，按值删，获取有效值个数，判空，清空，销毁，打印 - 单链表是一种链式存取的数据结构，链表中的数据是以结点来表示的，每个结点的构成：==元素(数据元素的映象)== + ==指针(指示后继元素存储位置)==，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。以“结点的序列”表示的线性表称作线性链表（单链表），单链表是链式存取的结构。
数据结构 C语言实现循环单链表的实例
08-30
主要介绍了数据结构 C语言实现循环单链表的实例的相关资料,需要的朋友可以参考下
数据结构单链表c语言实现
03-26
数据结构的单链表C语言版完整实现，本人知识初学者实力浅浅，可能对于大佬来说只是rubb**。如果同样是初学者的话，可能对于你或许有些用处。如果帮助到你很开心，如果你觉得有些low希望可以提出宝贵的建议 ！！
C语言实现单链表（常规操作）
06-19
C语言实现单链表（常规操作） LinkList CreateHeadListH(); // 头插法创建单链表 LinkList CreateHeadListT(); // 尾插法创建单链表 int ListEmpty(); // 单链表判空 int ListLength(); // 求单链表长度...
数据结构——基于C语言实现单链表的应用.rar
08-11
//初始化表 //头插法添加结点 // 尾插法添加结点 //查找的函数（按序号查找） //根据长度输出单链表的数据 // 插入一个新的结点 //单链表的删除操作
数据结构C语言版之单链表的逆置.cpp
10-07
数据结构老师布置的作业，运用课本代码，较为基础经典，适合大学本科在上数据结构这门课的同学参考，简单易懂，关于单链表的逆置问题
C语言单链表实现
01-16
c语言单链表的简单实现代码，有初学者的小伙伴可以参考一下。
(C语言数据结构)单链表
09-16
C语言实现单链表 Init(初始化) Length(当前结点个数) AddEnd(尾部添加) AddFirst(首部添加) Insert(插入) * Delete(删除) Find(查找返回) ShowAll(显示所有元素) Destory(销毁链表)
单链表（c语言实现）
MsPu_的博客
04-09 618
前言对于结构体和指针的深层运用，建议具有一定基础食用。单向性：每个节点只有一个指针，指向下一个节点，不能回溯到前面的节点。动态性：单链表的长度可以动态地改变，可以根据需要进行节点的添加和删除操作。存储效率较低：与数组相比，单链表的存储效率较低，因为每个节点需要额外的指针空间来指向下一个节点。随机访问效率较低：由于单链表只能从头节点开始逐个遍历，因此访问某个特定位置的节点需要线性时间，效率较低。插入和删除操作效率较高：由于单链表的动态性，插入和删除操作只需要改变指针的指向，效率较高。空间分配灵活：单链表的节点
c语言实现单链表
wangyangzhizunwudi的博客
08-30 132
#include <stdio.h> #include <stdlib.h> struct list_node_t{ struct list_node_t *next; union { int data; int index; }u_data; }; struct list_node_t *create_list(...
单链表的实现（C语言版）
陶人超有料的博客
08-10 289
FLinkList.h头文件： #ifndef _FLINKLIST_H_ #define _FLINKLIST_H_ typedef void LinkList; //利用void指针来接受任意类型的数据 typedef struct _tag_LinkListNode FLinkListNode; struct _tag_LinkListNode { FLinkListNode* n...
C语言之创建单链表
qq_40691051的博客
04-22 687
#include &lt;stdio.h&gt; #include&lt;string.h&gt; #include &lt;malloc.h&gt; /*包含动态内存分配函数的头文件*/ #define N 10 /*N为人数*/ typedef struct node {     char name[20];     struct node *link; /**link是node结构体类型的的...
C语言 创建单链表
qq_54628272的博客
02-06 2782
废话不多说直接上代码 注意传参 使用的是指针的指针，否则链表得不到初始化和创建。对用指针作为参数，且要改变实参指针指向，不懂的同学可以参考这篇博客的最下面部分 #include<stdio.h> #include<malloc.h> typedef struct lnode { int data; struct lnode *next; }lnode,*linklist; void initlist( lnode **L) { (*L)=(lnode *)mall
数据结构c语言版单链表
05-26
以下是C语言实现的单链表数据结构： ```c #include #include // 定义链表节点 typedef struct Node { int data; struct Node* next; } Node; // 初始化链表 Node* initList() { Node* head = (Node*)malloc...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

five-five

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

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

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

打赏作者

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

抵扣说明：

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

余额充值